re-master

Original source / Raw SKILL.md

---
name: re-master
description: Manage off-plan real estate investments, payment milestones, group buy allocations, and ROI simulations. Use when a user needs to: (1) Track property installments (Dubai 60/40, 70/30 plans), (2) Calculate proportional ownership between investors (Binkl/Dad/Friends), (3) Manage a cash buffer pool for admin payments, (4) Generate unique sharing links for investors, (5) Simulate ROI or payment gap scenarios.
metadata:
  {
    "openclaw": {
      "requires": {
        "bins": ["python3"]
      }
    }
  }
---

# Real Estate Master (Off-Plan Tracker) 🏙️

This skill enables precise management and simulation of off-plan property investments, particularly for group buy scenarios with an admin-managed cash pool.

## Core Workflows

### 1. Project Initialization
When a user adds a new unit (e.g., Rotana, Ohana):
1.  **Define Price & Fees:** Typically 4% DLD + registration.
2.  **Define Payment Plan:** (e.g., 10% DP + 1% monthly or 10% every 6 months).
3.  **Establish Buffer:** Define the starting cash pool (e.g., AED 480k).

### 2. Group Buy Allocation
Calculate equity based on:
-   **Initial DP Contribution:** Who put in what at the start.
-   **Monthly Commitment:** Ongoing AED/month contributions.
-   **Weighted Time:** Ownership adjusts dynamically as payments are made.

Use `scripts/equity_calc.py` for simple math or `scripts/re_sim.py` for full multi-month simulations.

### 3. Buffer & Milestone Simulation
The "Admin Cash Pool" strategy:
-   Use the pool to cover shortfalls or early milestones.
-   Simulate "Fair Share" requests to investors to keep the pool above a safety threshold (e.g., > AED 250k).

Run `python3 scripts/re_sim.py <config.json>` to generate a full funding forecast.

### 4. Sharing URLs (Developer Note)
The `re-master` skill provides data for per-investor views. To generate URLs:
-   **Local:** Use the `dash/<token>` routes if using the original Deal Tracker server.
-   **Static:** Use the simulation output to generate static reports for participants.
This skill does not run a web server; it provides the logic to power one.

## References

-   **Dubai Norms:** See [references/dubai_standards.md](references/dubai_standards.md) for tax, fee, and escrow basics.
-   **Equity Math:** See [references/equity_formulas.md](references/equity_formulas.md) for the "weighted contribution" logic used in group buys.

## Scripts

-   `scripts/re_sim.py`: Comprehensive multi-unit simulation engine. Input unit/account config ➔ Output monthly milestone funding breakdown.
-   `scripts/equity_calc.py`: Simple point-in-time equity calculator.

---
*Created for Binkl 👑 — 2026-03-06*


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### references/dubai_standards.md

```markdown
# Dubai Off-Plan Real Estate Standards (2026)

## Common Fees & Taxes

| Fee Name | Percentage | Recipient |
| :--- | :--- | :--- |
| **DLD (Land Department)** | **4.0%** of property value | Dubai Government |
| **Registration Fee** | **AED 5,000** (typical) | DLD |
| **Escrow Account** | 50% - 100% of construction cost | Bank (Project-specific) |
| **VAT** | **0%** on residential (5% on commercial) | FTA |

## Typical Payment Plans

-   **60/40 Plan:** 10% DP ➔ 50% during construction ➔ 40% on handover.
-   **70/30 Plan:** 20% DP ➔ 50% during construction ➔ 30% on handover.
-   **Post-Handover:** Pay 1% - 2% monthly for 2-3 years after completion.

## Completion Milestones

-   **Groundbreaking:** 10% - 15% payment.
-   **Structure / Shell:** 30% - 40% payment.
-   **Handover / Completion:** Final payment + final DLD fees (if not paid at start).

```

### references/equity_formulas.md

```markdown
# Equity Calculation Formulas (re-master)

This reference documents the logic used in the `scripts/equity_calc.py` and `scripts/re_sim.py` tools.

## Proportional Ownership Formula

Ownership is calculated based on the total cumulative capital contribution at any given point in time (Month $T$).

$$Ownership\%_{a,T} = \frac{Capital_{a,T}}{\sum_{i=1}^{n} Capital_{i,T}} \times 100$$

Where $Capital_{a,T}$ is:
$$Capital_{a,T} = DP_a + (Monthly_a \times T)$$

- **$DP_a$**: Initial Downpayment contribution from Account $a$.
- **$Monthly_a$**: Monthly recurring contribution from Account $a$.
- **$T$**: Months elapsed since the signing date.

## Admin Cash Pool Allocation (inv1)

In the current version of the simulation, the "Admin Cash Pool" (available liquid buffer) is treated as a contribution from the primary administrator account (**`inv1`**).

- At Month 0, the total available funding for the Downpayment includes `inv1.upfront` + `total_cash_pool`.
- This reflects the real-world scenario where the admin provides the initial liquidity buffer to secure the unit while partners catch up via monthly contributions.

## Fair Share Request Calculation

To maintain a buffer threshold (e.g., AED 250,000), the "Fair Share" request for Partner $P$ is calculated as:

$$Request_P = (TargetBuffer - CurrentBuffer) \times Ownership\%_P$$

This ensures that the cost of maintaining liquidity is borne proportionally by all equity holders.

```

### scripts/equity_calc.py

```python
import sys
import json

def calculate_equity(participants, months_elapsed=0):
    """
    Calculate proportional ownership based on total contributed equity.
    
    participants = {
        'inv1': {'dp': 132149, 'monthly': 17000},
        'inv2': {'dp': 240000, 'monthly': 12000},
        ...
    }
    """
    totals = {}
    grand_total = 0
    
    for name, data in participants.items():
        contrib = data.get('dp', 0) + (data.get('monthly', 0) * months_elapsed)
        totals[name] = contrib
        grand_total += contrib
        
    if grand_total == 0:
        return {name: 0 for name in participants}
        
    return {name: (val / grand_total) * 100 for name, val in totals.items()}

if __name__ == "__main__":
    if len(sys.argv) > 1:
        data = json.loads(sys.argv[1])
        months = int(sys.argv[2]) if len(sys.argv) > 2 else 0
        print(json.dumps(calculate_equity(data, months), indent=2))
    else:
        print("Usage: python3 equity_calc.py <json_participants> [months_elapsed]")

```

### scripts/re_sim.py

```python
import json
from datetime import datetime
def add_months(date_str, months):
    from datetime import datetime
    d = datetime.strptime(date_str, '%Y-%m-%d')
    month = d.month - 1 + months
    year = d.year + month // 12
    month = month % 12 + 1
    day = min(d.day, [31,
        29 if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) else 28,
        31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month-1])
    return datetime(year, month, day).strftime('%Y-%m-%d')

def gen_milestones(u):
    ms = []
    # DP
    ms.append({
        'idx': 0,
        'label': f"DP ({u['first_pct']}%)",
        'month': 0,
        'pct': u['first_pct'],
        'date': u['signing_date'],
        'cost': round(u['price'] * u['first_pct'] / 100) + u.get('fees', 0)
    })
    
    for i in range(1, u['milestone_count']):
        mo = i * u['months_between']
        d_str = add_months(u['signing_date'], mo)
        ms.append({
            'idx': i,
            'label': f"Installment {i}",
            'month': mo,
            'pct': u['inst_pct'],
            'date': d_str,
            'cost': round(u['price'] * u['inst_pct'] / 100)
        })
    return ms

def simulate(config):
    accounts = config['accounts']
    units = config['units']
    cash_pool = sum(e.get('amount', 0) for e in config.get('my_cash', {}).get('entries', []))
    
    monthly_total = sum(a.get('monthly', 0) for a in accounts)
    total_upfront = sum(a.get('upfront', 0) for a in accounts)
    
    unit_data = []
    for u in units:
        u_copy = u.copy()
        u_copy['milestones'] = gen_milestones(u)
        unit_data.append(u_copy)
        
    max_month = max((m['month'] for u in unit_data for m in u['milestones']), default=0)
    
    available = cash_pool + total_upfront
    
    # ms_fund[unit_id][ms_idx] = {total: 0, pa: {acc_id: 0}}
    ms_fund = {}
    for u in unit_data:
        ms_fund[u['id']] = {}
        for ms in u['milestones']:
            ms_fund[u['id']][ms['idx']] = {'total': 0, 'pa': {a['id']: 0 for a in accounts}}
            
    ms_ptr = {u['id']: 0 for u in unit_data}
    
    for mo in range(max_month + 1):
        if mo > 0:
            available += monthly_total
            
        needs = []
        for u in unit_data:
            while ms_ptr[u['id']] < len(u['milestones']):
                ms = u['milestones'][ms_ptr[u['id']]]
                if ms_fund[u['id']][ms['idx']]['total'] >= ms['cost']:
                    ms_ptr[u['id']] += 1
                    continue
                if ms['month'] <= mo:
                    rem = ms['cost'] - ms_fund[u['id']][ms['idx']]['total']
                    needs.append({'uid': u['id'], 'ms': ms, 'need': rem})
                break
                
        if not needs or available <= 0:
            continue
            
        total_need = sum(n['need'] for n in needs)
        
        for n in needs:
            share = min(n['need'], int(available * n['need'] / total_need))
            if share <= 0: continue
            
            # Allocation rates
            rates = []
            for a in accounts:
                rate = a.get('upfront', 0) if mo == 0 else a.get('monthly', 0)
                if mo == 0 and a['id'] == 'inv1': # Admin share of cash pool
                    rate += cash_pool
                rates.append({'id': a['id'], 'rate': rate})
            
            rate_total = sum(r['rate'] for r in rates)
            rem_share = share
            
            for r in rates:
                amt = int(share * r['rate'] / rate_total) if rate_total > 0 else 0
                actual = min(amt, rem_share)
                ms_fund[n['uid']][n['ms']['idx']]['total'] += actual
                ms_fund[n['uid']][n['ms']['idx']]['pa'][r['id']] += actual
                rem_share -= actual
                
            # Remainder to admin (inv1)
            if rem_share > 0:
                ms_fund[n['uid']][n['ms']['idx']]['total'] += rem_share
                ms_fund[n['uid']][n['ms']['idx']]['pa']['inv1'] += rem_share
                
            available -= (share - rem_share)
            
    # Format output for JSON
    results = []
    for u in unit_data:
        res = {
            'id': u['id'],
            'name': u['name'],
            'milestones': []
        }
        for ms in u['milestones']:
            ms_res = ms.copy()
            ms_res['funding'] = ms_fund[u['id']][ms['idx']]
            res['milestones'].append(ms_res)
        results.append(res)
        
    return results

if __name__ == "__main__":
    import sys
    if len(sys.argv) > 1:
        with open(sys.argv[1], 'r') as f:
            cfg = json.load(f)
        print(json.dumps(simulate(cfg), indent=2))

```



---

## Skill Companion Files

> Additional files collected from the skill directory layout.

### _meta.json

```json
{
  "owner": "binkl69",
  "slug": "re-master",
  "displayName": "Real Estate Master",
  "latest": {
    "version": "1.0.1",
    "publishedAt": 1772821920308,
    "commit": "https://github.com/openclaw/skills/commit/e3fbcca4de884bb9aaa03dcaa359a16bea5ce523"
  },
  "history": [
    {
      "version": "1.0.0",
      "publishedAt": 1772821637312,
      "commit": "https://github.com/openclaw/skills/commit/4be7bf141dbdedcc43e65b32efb1441d49b97630"
    }
  ]
}

```

### assets/MARKETPLACE_DESCRIPTION.md

```markdown
# 🏙️ Real Estate Master (re-master)
### Professional Off-Plan Property Investment & Group Buy Tracker

The **Real Estate Master** skill transforms OpenClaw into a sophisticated financial advisor for off-plan property investments. Specifically designed for the **Dubai real estate market**, it handles the complex math of "Group Buys," proportional equity tracking, and cash-pool drawdown simulations.

---

### 🚀 Key Features

*   **Proportional Equity Engine:** Dynamically calculate ownership percentages between multiple investors based on initial downpayments (DP) and ongoing monthly contributions.
*   **Multi-Unit Simulation:** Forecast funding requirements across multiple properties (e.g., Rotana, Ohana) simultaneously.
*   **Admin Cash-Pool Strategy:** Manage a central "buffer" pool to cover milestones. Simulate when the pool will run dry and when to request "Fair Share" injections from partners.
*   **Dubai Market Presets:** Pre-configured with DLD (4%) fees, escrow account logic, and standard 60/40 or 70/30 payment plans.
*   **Investor-Ready Reporting:** Generate data for individual sharing links, allowing you to show partners only what they need to see while maintaining overall project control.

### 🛠️ Included Tools

*   `scripts/re_sim.py`: High-fidelity simulation engine for multi-month funding forecasts.
*   `scripts/equity_calc.py`: Instant proportional ownership calculator.
*   `references/dubai_standards.md`: A 2026 guide to Dubai property fees and milestones.

### 💰 Why Use This?

Stop using static spreadsheets that break when an installment is missed or an investor changes their monthly contribution. **Real Estate Master** provides a "Living Simulation" that adjusts as your investment evolves.

Perfect for **Real Estate Agents** looking to offer value-add services to "Investor Groups," or **Individual Investors** managing family/friend property pools.

---
*Created by Sona 👑 for the OpenClaw Marketplace.*

```

### assets/sample-config.json

```json
{
  "accounts": [
    { "id": "inv1", "name": "Admin", "monthly": 15000, "upfront": 0 },
    { "id": "inv2", "name": "Partner A", "monthly": 10000, "upfront": 0 },
    { "id": "inv3", "name": "Partner B", "monthly": 12000, "upfront": 0 }
  ],
  "my_cash": { "entries": [ { "amount": 250000, "note": "Initial Buffer" } ] },
  "units": [
    {
      "id": "u1",
      "name": "Luxury Tower A",
      "price": 2500000,
      "fees": 70000,
      "signing_date": "2026-06-01",
      "milestone_count": 8,
      "first_pct": 10,
      "inst_pct": 5,
      "months_between": 6
    }
  ]
}

```