delimit-cli 4.1.53 → 4.3.0

package/gateway/ai/supabase_sync.py

@@ -29,6 +29,33 @@ if not SUPABASE_URL:
             pass
 
 
+_VENTURE_CANONICAL = {
+    "delimit": "delimit",
+    "domainvested": "domainvested",
+    "domain_vested": "domainvested",
+    "dv": "domainvested",
+    "wirereport": "wirereport",
+    "wire_report": "wirereport",
+    "wire.report": "wirereport",
+    "wr": "wirereport",
+    "livetube": "livetube",
+    "livetubeai": "livetube",
+    "livetube.ai": "livetube",
+    "lt": "livetube",
+}
+
+
+def _normalize_venture(value) -> str:
+    """LED-1008: map freeform venture strings into the canonical 4-member
+    vocabulary the Inbox + Ventures surfaces expect. Blank stays blank
+    (unattributed). Unknown values pass through lowercased so we notice
+    them in the dashboard instead of silently losing them."""
+    if not value:
+        return ""
+    key = str(value).strip().lower()
+    return _VENTURE_CANONICAL.get(key, key)
+
+
 def _get_client():
     """Lazy-init Supabase client. Returns the SDK client, 'http' for fallback, or None."""
     global _client, _init_attempted
@@ -188,3 +215,284 @@ def sync_ledger_update(item_id: str, status: str, note: str = ""):
             client.table("ledger_items").update(update).eq("id", item_id).execute()
     except Exception as e:
         logger.debug(f"Ledger update sync failed: {e}")
+
+
+def sync_work_order(wo: dict):
+    """Sync a work order to Supabase for dashboard inbox.
+
+    Gateway-local work order (from ai.work_order.create_work_order) maps to
+    the Supabase work_orders table (migration 020).
+    """
+    try:
+        client = _get_client()
+        if client is None:
+            return
+        row = {
+            "id": wo.get("id", ""),
+            "title": wo.get("title", ""),
+            "goal": wo.get("goal", ""),
+            "context": wo.get("context", ""),
+            "steps": wo.get("steps", []),
+            "acceptance_criteria": wo.get("acceptance_criteria", []),
+            "ledger_item_id": wo.get("ledger_item_id", ""),
+            "priority": wo.get("priority", "P1"),
+            "tools_needed": wo.get("tools_needed", []),
+            "estimated_minutes": wo.get("estimated_minutes", 15),
+            "worker_type": wo.get("worker_type", ""),
+            "status": wo.get("status", "pending"),
+            "preview": wo.get("preview", "")[:2000],
+            "artifact_path": wo.get("filepath", ""),
+            "executable_actions": wo.get("executable_actions", []),
+            "execution_status": wo.get("execution_status", ""),
+            "execution_log": wo.get("execution_log", []),
+            "executed_at": wo.get("executed_at"),
+            "executed_by": wo.get("executed_by", ""),
+            "venture": _normalize_venture(wo.get("venture", "")),
+        }
+        if not row["id"] or not row["title"]:
+            return
+        if client == "http":
+            _http_post(
+                "work_orders",
+                row,
+                headers_extra={
+                    "Prefer": "resolution=merge-duplicates,return=minimal",
+                },
+            )
+        else:
+            client.table("work_orders").upsert(row).execute()
+
+        # LED-977 (rescoped): push notification on new pending WO. Safe to
+        # call every time sync runs; notify_new_work_order dedupes via the
+        # sent-marker file so only the initial pending insert pushes.
+        try:
+            notify_new_work_order(row)
+        except Exception as exc:
+            logger.debug("notify_new_work_order hook failed: %s", exc)
+    except Exception as e:
+        logger.debug(f"Work order sync failed: {e}")
+
+
+def sync_deliberation(delib: dict):
+    """Sync a deliberation transcript summary to Supabase."""
+    try:
+        client = _get_client()
+        if client is None:
+            return
+        row = {
+            "id": delib.get("id") or delib.get("transcript_saved", "").split("/")[-1].replace(".json", ""),
+            "question": delib.get("question", "")[:2000],
+            "context": delib.get("context", "")[:2000],
+            "scope": delib.get("scope", ""),
+            "models_participated": delib.get("models_participated", []),
+            "rounds": delib.get("rounds", 0),
+            "status": delib.get("status", "unknown"),
+            "final_verdict": delib.get("final_verdict", "")[:4000],
+            "transcript_path": delib.get("transcript_saved", ""),
+            "ledger_items_created": delib.get("ledger_items_created", []),
+            "venture": _normalize_venture(delib.get("venture", "")),
+        }
+        if not row["id"] or not row["question"]:
+            return
+        if client == "http":
+            _http_post(
+                "deliberations",
+                row,
+                headers_extra={
+                    "Prefer": "resolution=merge-duplicates,return=minimal",
+                },
+            )
+        else:
+            client.table("deliberations").upsert(row).execute()
+    except Exception as e:
+        logger.debug(f"Deliberation sync failed: {e}")
+
+
+# ---------------------------------------------------------------------------
+# LED-977 (rescoped): push notifications on new work-order approvals.
+# Uses ntfy.sh — free, open-source, zero account/API-key management. User
+# installs the ntfy mobile app (iOS/Android), subscribes to their private
+# topic URL, and taps the push to deep-link into the dashboard inbox.
+# ---------------------------------------------------------------------------
+
+NTFY_ENV_KEY = "DELIMIT_NTFY_TOPIC"
+NTFY_BASE_URL = os.environ.get("DELIMIT_NTFY_BASE_URL", "https://ntfy.sh")
+NTFY_CLICK_URL = os.environ.get(
+    "DELIMIT_NTFY_CLICK_URL",
+    "https://app.delimit.ai/dashboard/inbox",
+)
+# Cache so we only send one push per WO — a WO gets upserted every time its
+# status changes (approved, executed, etc), but the push is only meaningful
+# on the initial pending insert.
+_NTFY_SENT_FILE = Path.home() / ".delimit" / "notifications" / "ntfy_sent.jsonl"
+
+
+def _ntfy_already_sent(wo_id: str) -> bool:
+    """Check if we've already pushed a notification for this WO."""
+    if not _NTFY_SENT_FILE.exists():
+        return False
+    try:
+        with _NTFY_SENT_FILE.open() as fh:
+            for line in fh:
+                try:
+                    if json.loads(line).get("wo_id") == wo_id:
+                        return True
+                except Exception:
+                    continue
+    except Exception:
+        pass
+    return False
+
+
+def _ntfy_record_sent(wo_id: str, title: str) -> None:
+    """Append a sent marker so the next sync for the same WO is a no-op."""
+    try:
+        _NTFY_SENT_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with _NTFY_SENT_FILE.open("a") as fh:
+            fh.write(json.dumps({
+                "wo_id": wo_id,
+                "title": title[:80],
+                "ts": os.environ.get("_NTFY_TS_OVERRIDE") or __import__("time").strftime("%Y-%m-%dT%H:%M:%SZ"),
+            }) + "\n")
+    except Exception as exc:
+        logger.debug("ntfy sent-marker write failed: %s", exc)
+
+
+def notify_new_work_order(wo: dict) -> None:
+    """Fire a push when a brand-new pending work order lands.
+
+    Fire-and-forget. Silent no-op when DELIMIT_NTFY_TOPIC isn't set so this
+    is opt-in — the service keeps working without it.
+    """
+    topic = os.environ.get(NTFY_ENV_KEY, "").strip()
+    if not topic:
+        return
+    if wo.get("status") != "pending":
+        return
+    wo_id = wo.get("id", "")
+    if not wo_id or _ntfy_already_sent(wo_id):
+        return
+
+    title = wo.get("title") or "New work order"
+    priority = str(wo.get("priority") or "P2").upper()
+    worker = wo.get("worker_type") or "worker"
+    body_lines = [wo.get("goal", "")[:200]]
+    if wo.get("ledger_item_id"):
+        body_lines.append(f"Source: {wo['ledger_item_id']}")
+    body_lines.append(f"Drafted by: {worker}")
+    body = "\n".join(l for l in body_lines if l).strip()
+
+    try:
+        import urllib.request
+        url = f"{NTFY_BASE_URL.rstrip('/')}/{topic}"
+        req = urllib.request.Request(
+            url,
+            data=body.encode("utf-8"),
+            headers={
+                "Title": f"[Delimit {priority}] {title}"[:180],
+                "Tags": "memo" if priority == "P2" else "warning",
+                "Click": NTFY_CLICK_URL,
+                "Priority": {"P0": "5", "P1": "4", "P2": "3"}.get(priority, "3"),
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            if 200 <= resp.status < 300:
+                _ntfy_record_sent(wo_id, title)
+                logger.info("ntfy push sent wo=%s", wo_id)
+            else:
+                logger.warning("ntfy push unexpected status: %s", resp.status)
+    except Exception as exc:
+        logger.warning("ntfy push failed for %s: %s", wo_id, exc)
+
+
+def sync_social_draft(draft: dict):
+    """Sync a social draft row to Supabase + optional ntfy push.
+
+    `draft` is the same shape save_draft() writes to social_drafts.jsonl.
+    Fire-and-forget like the other sync helpers — an outage here never
+    blocks the drafting worker.
+    """
+    try:
+        client = _get_client()
+        if client is None:
+            return
+        row = {
+            "draft_id": draft.get("draft_id", ""),
+            "platform": draft.get("platform", ""),
+            "account": draft.get("account", ""),
+            "text": draft.get("text", ""),
+            "thread_url": draft.get("thread_url", ""),
+            "context": draft.get("context", ""),
+            "source_fingerprint": draft.get("source_fingerprint", ""),
+            "quality": draft.get("quality", "review"),
+            "status": draft.get("status", "pending"),
+            "quote_tweet_id": draft.get("quote_tweet_id", ""),
+            "reply_to_id": draft.get("reply_to_id", ""),
+            "conversion_target": draft.get("conversion_target", ""),
+            "notification_message_id": draft.get("notification_message_id", ""),
+            "timestamp": draft.get("timestamp"),
+            "venture": _normalize_venture(draft.get("venture", "")),
+        }
+        if not row["draft_id"] or not row["text"]:
+            return
+        if client == "http":
+            _http_post(
+                "social_drafts",
+                row,
+                headers_extra={
+                    "Prefer": "resolution=merge-duplicates,return=minimal",
+                },
+            )
+        else:
+            client.table("social_drafts").upsert(row).execute()
+
+        # ntfy on NEW pending drafts only, dedupe via the WO sent-marker file
+        # (reused — scoped by draft_id vs wo_id so no collision)
+        if row["status"] == "pending":
+            try:
+                _push_draft_notification(row)
+            except Exception as exc:
+                logger.debug("draft ntfy failed: %s", exc)
+    except Exception as e:
+        logger.debug(f"Social draft sync failed: {e}")
+
+
+def _push_draft_notification(row: dict) -> None:
+    """Fire a medium-priority ntfy when a new pending draft lands."""
+    import time as _time
+    topic = os.environ.get(NTFY_ENV_KEY, "").strip()
+    if not topic:
+        return
+    draft_id = row.get("draft_id", "")
+    if not draft_id or _ntfy_already_sent(draft_id):
+        return
+    platform = (row.get("platform") or "?").upper()
+    quality = row.get("quality") or "?"
+    title = f"[Delimit DRAFT {platform}/{quality}]"
+    body_preview = (row.get("text") or "").replace("\n", " ")[:220]
+    body_lines = [
+        f"Thread: {row.get('thread_url', '?')}",
+        f"Account: {row.get('account', '?')}",
+        "",
+        body_preview,
+    ]
+    try:
+        import urllib.request as _ur
+        req = _ur.Request(
+            f"{NTFY_BASE_URL.rstrip('/')}/{topic}",
+            data="\n".join(body_lines).encode(),
+            headers={
+                "Title": title[:180],
+                "Tags": "memo" if quality == "ready" else "warning",
+                "Click": "https://app.delimit.ai/dashboard/inbox",
+                "Priority": "4" if quality == "ready" else "3",
+            },
+            method="POST",
+        )
+        with _ur.urlopen(req, timeout=5) as resp:
+            if 200 <= resp.status < 300:
+                _ntfy_record_sent(draft_id, row.get("text", "")[:80])
+                logger.info("draft ntfy sent draft_id=%s", draft_id)
+    except Exception as exc:
+        logger.warning("draft ntfy push failed for %s: %s", draft_id, exc)

package/gateway/ai/work_order.py

@@ -0,0 +1,216 @@
+"""Work-order generator (STR-177 Week 3-4).
+
+Converts deliberation TASK outputs into structured markdown files the
+founder can copy-paste into an interactive Claude Code session. Bridges
+the gap between "strategy decided this" and "founder executes this."
+
+Work orders live at ~/.delimit/work-orders/WO-YYYY-MM-DD-NNN.md and
+are surfaced via the daily digest + delimit_digest MCP tool.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+WORK_ORDERS_DIR = Path.home() / ".delimit" / "work-orders"
+
+
+def _ensure_dir():
+    WORK_ORDERS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _next_id() -> str:
+    _ensure_dir()
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    existing = sorted(WORK_ORDERS_DIR.glob(f"WO-{today}-*.md"))
+    n = len(existing) + 1
+    return f"WO-{today}-{n:03d}"
+
+
+def create_work_order(
+    title: str,
+    goal: str,
+    context: str = "",
+    steps: Optional[List[str]] = None,
+    acceptance_criteria: Optional[List[str]] = None,
+    ledger_item_id: str = "",
+    deliberation_ref: str = "",
+    priority: str = "P1",
+    estimated_minutes: int = 0,
+    tools_needed: Optional[List[str]] = None,
+    worker_type: str = "",
+    executable_actions: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """Create a work-order markdown file.
+
+    Returns dict with the work-order ID, file path, and a preview.
+    """
+    _ensure_dir()
+    wo_id = _next_id()
+    now = datetime.now(timezone.utc).isoformat()
+
+    lines = [
+        f"# {wo_id}: {title}",
+        "",
+        f"**Priority**: {priority}",
+        f"**Created**: {now[:19]}Z",
+    ]
+    if estimated_minutes:
+        lines.append(f"**Estimated**: ~{estimated_minutes} min")
+    if ledger_item_id:
+        lines.append(f"**Ledger**: {ledger_item_id}")
+    if deliberation_ref:
+        lines.append(f"**Deliberation**: {deliberation_ref}")
+    lines.append("")
+
+    lines.extend([
+        "## Goal",
+        "",
+        goal,
+        "",
+    ])
+
+    if context:
+        lines.extend([
+            "## Context",
+            "",
+            context,
+            "",
+        ])
+
+    if steps:
+        lines.extend([
+            "## Steps",
+            "",
+        ])
+        for i, step in enumerate(steps, 1):
+            if step.startswith("```") or step.startswith("  "):
+                lines.append(step)
+            else:
+                lines.append(f"{i}. {step}")
+        lines.append("")
+
+    if tools_needed:
+        lines.extend([
+            "## Tools needed",
+            "",
+        ])
+        for tool in tools_needed:
+            lines.append(f"- `{tool}`")
+        lines.append("")
+
+    if acceptance_criteria:
+        lines.extend([
+            "## Acceptance criteria",
+            "",
+        ])
+        for ac in acceptance_criteria:
+            lines.append(f"- [ ] {ac}")
+        lines.append("")
+
+    lines.extend([
+        "## How to execute",
+        "",
+        "Copy this work order into a Claude Code session:",
+        "",
+        "```",
+        f"Execute work order {wo_id}: {title}",
+        f"Goal: {goal}",
+        "```",
+        "",
+        "Or run specific steps manually from the Steps section above.",
+        "",
+        "---",
+        f"Generated by Delimit work-order system at {now}",
+    ])
+
+    content = "\n".join(lines)
+    filepath = WORK_ORDERS_DIR / f"{wo_id}.md"
+    filepath.write_text(content)
+
+    # Validate executable_actions against the executor whitelist so a worker
+    # can't smuggle an unsupported action through. A drafting worker that
+    # emits a bad action should fail loud at draft time, not later.
+    executable_actions = executable_actions or []
+    if executable_actions:
+        try:
+            from ai.workers.executor import validate_actions
+            errors = validate_actions(executable_actions)
+            if errors:
+                raise ValueError(
+                    "executable_actions failed validation: " + "; ".join(errors)
+                )
+        except ImportError:
+            # Executor module not available (e.g. in a stripped bundle); drop
+            # the actions rather than shipping unvalidated data.
+            executable_actions = []
+
+    # Also write a JSON sidecar for machine consumption
+    meta = {
+        "id": wo_id,
+        "title": title,
+        "goal": goal,
+        "context": context,
+        "steps": steps or [],
+        "acceptance_criteria": acceptance_criteria or [],
+        "tools_needed": tools_needed or [],
+        "estimated_minutes": estimated_minutes or 15,
+        "priority": priority,
+        "ledger_item_id": ledger_item_id,
+        "deliberation_ref": deliberation_ref,
+        "worker_type": worker_type,
+        "executable_actions": executable_actions,
+        "created_at": now,
+        "status": "pending",
+        "filepath": str(filepath),
+        "preview": content[:2000],
+    }
+    (WORK_ORDERS_DIR / f"{wo_id}.json").write_text(json.dumps(meta, indent=2))
+
+    # Fire-and-forget sync to Supabase so the dashboard approval inbox
+    # can surface this work order to Pro users.
+    try:
+        from ai.supabase_sync import sync_work_order
+        sync_work_order(meta)
+    except Exception:
+        pass
+
+    return {
+        "id": wo_id,
+        "filepath": str(filepath),
+        "preview": content[:500],
+    }
+
+
+def list_work_orders(status: str = "pending", limit: int = 10) -> List[Dict[str, Any]]:
+    """List work orders filtered by status."""
+    _ensure_dir()
+    results = []
+    for jf in sorted(WORK_ORDERS_DIR.glob("WO-*.json"), reverse=True):
+        try:
+            meta = json.loads(jf.read_text())
+            if status == "all" or meta.get("status") == status:
+                results.append(meta)
+                if len(results) >= limit:
+                    break
+        except Exception:
+            continue
+    return results
+
+
+def complete_work_order(wo_id: str, note: str = "") -> Dict[str, Any]:
+    """Mark a work order as completed."""
+    jf = WORK_ORDERS_DIR / f"{wo_id}.json"
+    if not jf.exists():
+        return {"error": f"work order {wo_id} not found"}
+    meta = json.loads(jf.read_text())
+    meta["status"] = "completed"
+    meta["completed_at"] = datetime.now(timezone.utc).isoformat()
+    if note:
+        meta["completion_note"] = note
+    jf.write_text(json.dumps(meta, indent=2))
+    return meta

package/gateway/ai/workers/__init__.py

@@ -0,0 +1,32 @@
+"""Worker pool v1 — read-only bounded agents (LED-975, LED-976).
+
+Workers are specialized and sandboxed per the swarm charter:
+  - Each worker has a bounded capability surface
+  - Cannot escalate without re-deliberation
+  - Cannot write files, commit, push, or modify state
+  - Output is always an artifact (work order) for founder approval
+
+The daemon dispatches work to workers. Workers produce artifacts.
+The founder approves artifacts from their interactive session or
+mobile PWA. Approved artifacts get executed.
+
+This is ledger-based, not time-based: workers pull from the ledger,
+produce work orders, and the ledger tracks completion.
+"""
+
+from ai.workers.base import Worker, WorkerResult
+from ai.workers.pr_drafter import PRDrafterWorker
+from ai.workers.outreach_drafter import OutreachDrafterWorker
+
+WORKER_REGISTRY = {
+    "pr_drafter": PRDrafterWorker,
+    "outreach_drafter": OutreachDrafterWorker,
+}
+
+__all__ = [
+    "Worker",
+    "WorkerResult",
+    "PRDrafterWorker",
+    "OutreachDrafterWorker",
+    "WORKER_REGISTRY",
+]