delimit-cli 4.1.53 → 4.2.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [4.2.0] - 2026-04-21
+
+### Added (gateway sync — LED-987 through LED-1008)
+- **Venture tagging (LED-1008)** — work orders, deliberations, and social drafts carry a canonical venture tag propagated through `save_draft` and the Supabase sync writers. `_normalize_venture` maps freeform strings (e.g., "DomainVested", "wire.report", "LT") to the canonical 4-member vocabulary (delimit / domainvested / wirereport / livetube). Unknown values pass through lowercased so they surface instead of dropping.
+- **Warm-window filter for social targets (LED-998)** — 72h window on X scans, 14d on reddit. Env-tunable via `DELIMIT_X_WARM_HOURS` and `DELIMIT_REDDIT_WARM_HOURS`. Fail-open on missing timestamps so parser bugs don't silently drop everything.
+- **X draft salvage (LED-997)** — `_try_trim_twitter_draft` trims LLM output at sentence boundary when it exceeds 3 sentences or 280 chars. Runs before the max-length check so a good-but-long draft becomes a good-and-short one instead of dying in the sanitizer. Proven live: salvaged a 626-char draft to 241 chars on the first post-deploy cycle.
+- **Reversible stale cleanup (LED-990)** — weekly systemd timer demotes blocked items to a cold lane after 30d instead of deleting. Ledger update restores cold → blocked/open with a single status flip. First-run safe with DRY_RUN=1.
+- **Warm-thread PR watcher (LED-989)** — 14-day warm window on outreach follow-ups; skip threads inactive longer than that. MAX_ACTIVE_THREADS=8 cap prevents dog-piling a single repository.
+- **Lemon Squeezy → Supabase reconciler (LED-996)** — trial watcher now polls LS every 6h and upserts subscription_status + role into the Supabase users table. Catches webhook drops without manual SQL intervention.
+- **ACTION_DENYLIST (LED-988)** — executor v2 gains an explicit denylist of prohibited action categories (money, legal/identity, credentials, deploy, contracts) that fires BEFORE the ACTION_SPEC whitelist check. Defense-in-depth against LLM-driven executor drift.
+- **Reddit residential-IP proxy (LED-987)** — scoped service bypasses 429s on reddit34.p.rapidapi.com by routing through a residential IP. Systemd-managed, auto-restart, rate-limited.
+- **propose_pr autonomous build primitive (LED-988)** — executor can propose PRs against an allowlisted repo set (`PROPOSE_PR_ALLOWED_REPOS`) with a fixed branch prefix (`delimit/`) and author (`delimit-bot`). Guarded by denylist + whitelist.
+
+### Fixed
+- **Exit-shim counter undercounting** — previously missed commits outside `SESSION_CWD` and dropped Z-suffixed timestamps; both now captured.
+- **Proprietary path leaks** — sync-gateway.sh EXCLUDE list hardened to keep Jamsons-portfolio-specific files (social.py, social_target.py, inbox_daemon.py, founding_users.py, deliberation.py) out of the npm bundle.
+
+### Tests
+- Gateway: 163/163 passing on changed-file tests (social.py, social_target.py, supabase_sync).
+- npm CLI: 134/134 passing (no CLI behavior changes — bundled gateway update).
+- Security audit: 0 real findings across gateway + UI (false positives only — test fixtures and TypeScript `token:` parameter types).
+
+### Notes
+- Companion dashboard changes at app.delimit.ai (LED-995 Billing + API Keys wiring, LED-997 Blocked drafts tab, LED-1008 venture chips + filters) shipped via delimit-ui/main.
+- Supabase migration 025 (venture TEXT column on 4 tables) applied separately via Management API.
+
 ## [4.1.53] - 2026-04-10
 
 ### Fixed (cycle engine — think→build→deploy)

package/bin/delimit-cli.js

@@ -5768,8 +5768,7 @@ program
             // Try to run deliberation directly via the gateway
             const HOME = process.env.HOME || require('os').homedir();
             const gatewayScript = path.join(HOME, '.delimit', 'server', 'ai', 'deliberation.py');
-            const gatewayAlt = '/home/delimit/delimit-gateway/ai/deliberation.py';
-            const scriptPath = fs.existsSync(gatewayScript) ? gatewayScript : fs.existsSync(gatewayAlt) ? gatewayAlt : null;
+            const scriptPath = fs.existsSync(gatewayScript) ? gatewayScript : null;
 
             if (scriptPath) {
                 console.log(chalk.dim('Running multi-model deliberation...\n'));

package/bin/delimit-setup.js

@@ -780,15 +780,30 @@ delimit_exit_screen() {
     else
         DURATION="\${ELAPSED}s"
     fi
-    # Count git commits made during session (@ prefix tells git the value is epoch)
+    # Count git commits made during session. SESSION_CWD is captured at shim
+    # launch; commits made in other repos during the session would be missed.
+    # Scan a best-effort set of known roots plus the launch cwd.
     COMMITS=0
-    if [ -d "\$SESSION_CWD/.git" ] || git -C "\$SESSION_CWD" rev-parse --git-dir >/dev/null 2>&1; then
-        COMMITS=\$(git -C "\$SESSION_CWD" log --oneline --after="@\$SESSION_START" --format="%H" 2>/dev/null | wc -l | tr -d ' ')
-    fi
-    # Count ledger items created during session (by timestamp)
+    # Customer-facing: scan launch cwd, its parent, and common project roots.
+    # If an org or solo dev keeps multiple repos in \$HOME or \$HOME/code, commits
+    # there during a session get counted.
+    REPO_ROOTS="\$SESSION_CWD"
+    for parent in "\$SESSION_CWD/.." "\$HOME" "\$HOME/code" "\$HOME/src" "\$HOME/projects"; do
+        [ -d "\$parent" ] || continue
+        for d in "\$parent"/*/.git; do
+            [ -d "\$d" ] && REPO_ROOTS="\$REPO_ROOTS \$(dirname \$d)"
+        done
+    done
+    for r in \$REPO_ROOTS; do
+        [ -d "\$r/.git" ] || continue
+        C=\$(git -C "\$r" log --after="@\$SESSION_START" --format="%H" 2>/dev/null | wc -l | tr -d ' ')
+        COMMITS=\$((COMMITS + C))
+    done
+    # Count ledger items created during session (by timestamp).
+    # Ledger JSON is written with ": " (space) between key and value, and ISO
+    # timestamps end with "Z" (UTC), so the regex must tolerate both.
     LEDGER_DIR="\$DELIMIT_HOME/ledger"
     LEDGER_ITEMS=0
-    # Convert epoch SESSION_START to ISO prefix for string comparison
     SESSION_ISO=\$(date -u -d "@\$SESSION_START" +%Y-%m-%dT%H:%M:%S 2>/dev/null || date -u -r "\$SESSION_START" +%Y-%m-%dT%H:%M:%S 2>/dev/null || echo "")
     if [ -d "\$LEDGER_DIR" ] && [ -n "\$SESSION_ISO" ]; then
         for lf in "\$LEDGER_DIR"/*.jsonl; do
@@ -796,7 +811,7 @@ delimit_exit_screen() {
             COUNT=\$(awk -v start="\$SESSION_ISO" '
                 BEGIN { n=0 }
                 {
-                    if (match(\$0, /"created_at":"([0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2})"/, arr)) {
+                    if (match(\$0, /"created_at"[[:space:]]*:[[:space:]]*"([0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2})Z?"/, arr)) {
                         if (arr[1] >= start) n++
                     }
                 }

package/gateway/ai/agent_dispatch.py

@@ -18,11 +18,38 @@ from typing import Any, Dict, List, Optional
 AGENTS_DIR = Path.home() / ".delimit" / "agents"
 TASKS_FILE = AGENTS_DIR / "tasks.json"
 AUDIT_FILE = AGENTS_DIR / "audit.jsonl"
+PAUSE_FILE = Path.home() / ".delimit" / "pause_dispatch"
 
 VALID_PRIORITIES = {"P0", "P1", "P2"}
 VALID_ASSIGNEES = {"claude", "codex", "gemini", "any"}
 VALID_STATUSES = {"dispatched", "in_progress", "done", "handed_off", "failed"}
 
+# LED-876: auto-pause when dead-letter queue depth (stuck 'dispatched' tasks)
+# hits this threshold. Prevents runaway dispatch when no workers are pulling.
+DLQ_AUTO_PAUSE_THRESHOLD = 20
+
+# LED-878: router table — resolves assignee='any' to a specific model at
+# dispatch time based on task_type. This eliminates the dead-letter 'any'
+# bucket without requiring a worker process to exist yet. The mapping is
+# deliberately conservative: if the task type is unknown, fall through to
+# gemini (cheapest, highest throughput) rather than pile onto claude.
+TASK_TYPE_ROUTER = {
+    # Outreach and social work — Gemini Flash is fast and cheap
+    "outreach": "gemini",
+    "social": "gemini",
+    "content": "gemini",
+    "sensor": "gemini",
+    # Engineering — Claude / Codex for code, Claude for governance
+    "fix": "claude",
+    "feat": "claude",
+    "refactor": "claude",
+    "test": "codex",
+    "research": "gemini",
+    "strategy": "gemini",
+    "deliberation": "claude",
+}
+ROUTER_DEFAULT_ASSIGNEE = "gemini"
+
 
 def _ensure_dir():
     """Create the agents directory if it doesn't exist."""
@@ -74,10 +101,62 @@ def dispatch_task(
     if not title or not title.strip():
         return {"error": "title is required"}
 
+    # LED-876: reject ghost "[VENTURE] Engage:  on x" titles with empty author
+    # slot. The social_target fix drops these at the scanner, but keep this as
+    # a belt-and-suspenders check since agent_dispatch has other callers too.
+    stripped = title.strip()
+    if "Engage:  on " in stripped or "Engage: on " in stripped:
+        return {"error": f"rejected ghost engage task with empty author: {stripped!r}"}
+
+    # LED-876: manual kill switch. Touch ~/.delimit/pause_dispatch to halt all
+    # dispatches instantly without touching loop_config. Remove the file to
+    # resume. Kept deliberately simple so it works from any shell.
+    if PAUSE_FILE.exists():
+        _append_audit({
+            "action": "dispatch_rejected_paused",
+            "title": stripped,
+            "reason": str(PAUSE_FILE),
+        })
+        return {"error": f"dispatch paused: {PAUSE_FILE} exists"}
+
+    # LED-876: automatic circuit breaker. If the DLQ (count of 'dispatched'
+    # tasks that never moved to in_progress/done/failed) exceeds the threshold,
+    # auto-create the pause file and reject. This stops the cycle from growing
+    # the queue unboundedly when workers aren't consuming.
+    existing_tasks = _load_tasks()
+    dlq_depth = sum(1 for t in existing_tasks.values() if t.get("status") == "dispatched")
+    if dlq_depth >= DLQ_AUTO_PAUSE_THRESHOLD:
+        PAUSE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        PAUSE_FILE.write_text(
+            f"auto-paused at {time.strftime('%Y-%m-%dT%H:%M:%SZ')} "
+            f"(dlq_depth={dlq_depth} >= {DLQ_AUTO_PAUSE_THRESHOLD})\n"
+        )
+        _append_audit({
+            "action": "dispatch_auto_paused",
+            "dlq_depth": dlq_depth,
+            "threshold": DLQ_AUTO_PAUSE_THRESHOLD,
+        })
+        return {
+            "error": (
+                f"auto-paused: DLQ depth {dlq_depth} >= {DLQ_AUTO_PAUSE_THRESHOLD}. "
+                f"Clear stuck tasks then delete {PAUSE_FILE} to resume."
+            )
+        }
+
     assignee = assignee.lower().strip() if assignee else "any"
     if assignee not in VALID_ASSIGNEES:
         return {"error": f"assignee must be one of: {', '.join(sorted(VALID_ASSIGNEES))}"}
 
+    # LED-878: resolve 'any' to a specific model via the router table so
+    # tasks never land in a bucket no worker pulls from. The mapping uses
+    # task_type as the primary key; if unknown, falls through to the
+    # default (gemini — cheapest + highest throughput).
+    if assignee == "any":
+        tt = (task_type or "").lower().strip()
+        routed = TASK_TYPE_ROUTER.get(tt, ROUTER_DEFAULT_ASSIGNEE)
+        if routed in VALID_ASSIGNEES and routed != "any":
+            assignee = routed
+
     priority = priority.upper().strip() if priority else "P1"
     if priority not in VALID_PRIORITIES:
         return {"error": f"priority must be one of: {', '.join(sorted(VALID_PRIORITIES))}"}

package/gateway/ai/daily_digest.py

@@ -0,0 +1,386 @@
+"""Daily digest for the Delimit autonomous loop (LED-966).
+
+Produces a structured summary of the last 24h:
+  - Cycle count (sense-only daemon ticks)
+  - Signals ingested (count by platform)
+  - Deliberations held (count + transcript refs)
+  - Ledger deltas (items opened, in_progress, done)
+  - Agent dispatches (by assignee, status)
+  - Pending approvals (drafts awaiting founder)
+  - Critical events (errors, timeouts, guard trips)
+
+Writes:
+  - ~/.delimit/digest/digest-YYYY-MM-DD.md (file artifact, always)
+  - ~/.delimit/digest/digest-YYYY-MM-DD.json (machine-readable)
+  - Email to founder (if DELIMIT_DIGEST_EMAIL=true AND email pipeline healthy)
+
+Call via MCP: delimit_digest(action="run") or scheduled cron.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from collections import Counter
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+DIGEST_DIR = Path.home() / ".delimit" / "digest"
+LEDGER_DIR = Path.home() / ".delimit" / "ledger"
+DELIB_DIR = Path.home() / ".delimit" / "deliberations"
+SIGNALS_DIR = Path.home() / ".delimit" / "intel" / "signals"
+AGENTS_FILE = Path.home() / ".delimit" / "agents" / "tasks.json"
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _ensure_dir():
+    DIGEST_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _count_signals(since: datetime) -> Dict[str, Any]:
+    """Count signals ingested in the window, grouped by platform."""
+    counts: Counter = Counter()
+    total = 0
+    if not SIGNALS_DIR.exists():
+        return {"total": 0, "by_platform": {}}
+    for shard in SIGNALS_DIR.glob("*.jsonl"):
+        if shard.name.startswith("_"):
+            continue
+        try:
+            shard_date = datetime.fromisoformat(shard.stem).date()
+        except ValueError:
+            continue
+        if shard_date < since.date():
+            continue
+        try:
+            for line in shard.read_text().splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    row = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                try:
+                    ts = datetime.fromisoformat(row.get("ingested_at", "").replace("Z", "+00:00"))
+                except Exception:
+                    continue
+                if ts < since:
+                    continue
+                counts[row.get("platform", "?")] += 1
+                total += 1
+        except OSError:
+            continue
+    return {"total": total, "by_platform": dict(counts.most_common())}
+
+
+def _count_deliberations(since: datetime) -> Dict[str, Any]:
+    """Count deliberation transcripts created in the window."""
+    if not DELIB_DIR.exists():
+        return {"total": 0, "unanimous": 0, "no_consensus": 0, "recent": []}
+    total = 0
+    unanimous = 0
+    no_consensus = 0
+    recent = []
+    for f in sorted(DELIB_DIR.glob("deliberation_*.json"), reverse=True)[:50]:
+        try:
+            mtime = datetime.fromtimestamp(f.stat().st_mtime, tz=timezone.utc)
+            if mtime < since:
+                continue
+            d = json.loads(f.read_text())
+            total += 1
+            verdict = (d.get("final_verdict") or "").upper()
+            if "UNANIMOUS" in verdict:
+                unanimous += 1
+            elif "NO CONSENSUS" in verdict or "MAX ROUNDS" in verdict:
+                no_consensus += 1
+            rounds_field = d.get("rounds", 0)
+            rounds_count = len(rounds_field) if isinstance(rounds_field, list) else rounds_field
+            recent.append({
+                "file": f.name,
+                "verdict": (d.get("final_verdict") or "?")[:60],
+                "status": d.get("status", "?"),
+                "rounds": rounds_count,
+            })
+        except Exception:
+            continue
+    return {
+        "total": total,
+        "unanimous": unanimous,
+        "no_consensus": no_consensus,
+        "recent": recent[:10],
+    }
+
+
+def _count_ledger_deltas(since: datetime) -> Dict[str, Any]:
+    """Count ledger items opened / updated / done in the window."""
+    opened = 0
+    done = 0
+    new_items = []
+    done_items = []
+    if not LEDGER_DIR.exists():
+        return {"opened": 0, "done": 0, "new": [], "completed": []}
+    since_iso = since.isoformat().replace("+00:00", "Z")
+    for lf in LEDGER_DIR.glob("*.jsonl"):
+        try:
+            for line in lf.read_text().splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    item = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                created = item.get("created_at", "")
+                updated = item.get("updated_at", created)
+                if created >= since_iso and item.get("type") != "update":
+                    opened += 1
+                    new_items.append({
+                        "id": item.get("id"),
+                        "title": (item.get("title") or "")[:80],
+                        "priority": item.get("priority", "?"),
+                    })
+                if item.get("type") == "update" and item.get("status") == "done" and updated >= since_iso:
+                    done += 1
+                    done_items.append({
+                        "id": item.get("id"),
+                        "note": (item.get("note") or "")[:120],
+                    })
+        except OSError:
+            continue
+    return {
+        "opened": opened,
+        "done": done,
+        "new": new_items[-10:],
+        "completed": done_items[-10:],
+    }
+
+
+def _count_dispatches(since: datetime) -> Dict[str, Any]:
+    """Count swarm dispatches and their current status."""
+    if not AGENTS_FILE.exists():
+        return {"total": 0, "by_status": {}, "by_assignee": {}, "stuck_over_24h": 0}
+    try:
+        tasks = json.loads(AGENTS_FILE.read_text())
+    except Exception:
+        return {"total": 0, "by_status": {}, "by_assignee": {}, "stuck_over_24h": 0}
+    status_counts: Counter = Counter()
+    assignee_counts: Counter = Counter()
+    stuck = 0
+    dispatched_recent = 0
+    since_iso = since.isoformat().replace("+00:00", "Z")
+    for tid, task in tasks.items():
+        status = task.get("status", "?")
+        status_counts[status] += 1
+        if task.get("created_at", "") >= since_iso:
+            dispatched_recent += 1
+        if status == "dispatched":
+            assignee_counts[task.get("assignee", "?")] += 1
+            try:
+                created = datetime.fromisoformat(task.get("created_at", "").replace("Z", "+00:00"))
+                if (_now() - created) > timedelta(hours=24):
+                    stuck += 1
+            except Exception:
+                pass
+    return {
+        "total_tasks": len(tasks),
+        "dispatched_last_24h": dispatched_recent,
+        "by_status": dict(status_counts),
+        "dispatched_by_assignee": dict(assignee_counts),
+        "stuck_over_24h": stuck,
+    }
+
+
+def _check_health(since: datetime) -> Dict[str, Any]:
+    """Check for errors, guard trips, timeouts in the window."""
+    health = {
+        "pause_file_exists": (Path.home() / ".delimit" / "pause_dispatch").exists(),
+        "signal_guard_shadow_hits": 0,
+        "daemon_stopped": False,
+    }
+    # Signal guard shadow log
+    shadow = Path.home() / ".delimit" / "logs" / "signal_guard_shadow.jsonl"
+    if shadow.exists():
+        since_iso = since.isoformat().replace("+00:00", "Z")
+        try:
+            for line in shadow.read_text().splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    row = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if row.get("ts", "") >= since_iso:
+                    health["signal_guard_shadow_hits"] += 1
+        except OSError:
+            pass
+    return health
+
+
+def build_digest(window_hours: int = 24) -> Dict[str, Any]:
+    """Collect all signals for the last window_hours into a single digest dict."""
+    since = _now() - timedelta(hours=window_hours)
+    return {
+        "generated_at": _now().isoformat(),
+        "window_hours": window_hours,
+        "window_start": since.isoformat(),
+        "signals": _count_signals(since),
+        "deliberations": _count_deliberations(since),
+        "ledger": _count_ledger_deltas(since),
+        "dispatches": _count_dispatches(since),
+        "health": _check_health(since),
+    }
+
+
+def render_markdown(digest: Dict[str, Any]) -> str:
+    """Render the digest as a founder-readable markdown document."""
+    g = digest
+    s = g["signals"]
+    d = g["deliberations"]
+    l = g["ledger"]
+    dsp = g["dispatches"]
+    h = g["health"]
+
+    lines = [
+        f"# Delimit Daily Digest — {g['generated_at'][:10]}",
+        "",
+        f"Window: last {g['window_hours']}h (since {g['window_start'][:16]}Z)",
+        "",
+        "## Health",
+        "",
+        f"- Pause file: {'🔴 ACTIVE' if h['pause_file_exists'] else '🟢 clear'}",
+        f"- Signal guard shadow hits: {h['signal_guard_shadow_hits']}",
+        "",
+        "## Signals ingested",
+        "",
+        f"Total: **{s['total']}** signals",
+    ]
+    for platform, count in s.get("by_platform", {}).items():
+        lines.append(f"- {platform}: {count}")
+    lines.extend([
+        "",
+        "## Deliberations",
+        "",
+        f"- Total: **{d['total']}**",
+        f"- Unanimous: {d['unanimous']}",
+        f"- No consensus / max rounds: {d['no_consensus']}",
+    ])
+    if d.get("recent"):
+        lines.append("")
+        lines.append("Recent transcripts:")
+        for r in d["recent"]:
+            lines.append(f"  - `{r['file']}` — {r['verdict']} ({r.get('rounds', '?')} rounds)")
+    lines.extend([
+        "",
+        "## Ledger deltas",
+        "",
+        f"- Items opened: **{l['opened']}**",
+        f"- Items completed: **{l['done']}**",
+    ])
+    if l.get("new"):
+        lines.append("")
+        lines.append("New items:")
+        for item in l["new"]:
+            lines.append(f"  - {item['id']} [{item['priority']}] {item['title']}")
+    if l.get("completed"):
+        lines.append("")
+        lines.append("Completed:")
+        for item in l["completed"]:
+            lines.append(f"  - {item['id']} — {item['note']}")
+    lines.extend([
+        "",
+        "## Swarm dispatches",
+        "",
+        f"- Total tasks ever: {dsp['total_tasks']}",
+        f"- New dispatches last 24h: **{dsp['dispatched_last_24h']}**",
+        f"- Stuck (dispatched >24h): {dsp['stuck_over_24h']}",
+    ])
+    if dsp.get("by_status"):
+        lines.append("")
+        lines.append("By status:")
+        for status, count in dsp["by_status"].items():
+            lines.append(f"  - {status}: {count}")
+    if dsp.get("dispatched_by_assignee"):
+        lines.append("")
+        lines.append("Currently dispatched by assignee:")
+        for who, count in dsp["dispatched_by_assignee"].items():
+            lines.append(f"  - {who}: {count}")
+    lines.extend([
+        "",
+        "## Pending founder actions",
+        "",
+        f"- Stuck dispatches (need worker): {dsp['stuck_over_24h']}",
+        f"- Pause file present: {'yes' if h['pause_file_exists'] else 'no'}",
+        f"- Guard shadow hits (investigate if >0): {h['signal_guard_shadow_hits']}",
+        "",
+        "---",
+        f"Digest generated at {g['generated_at']}",
+    ])
+    return "\n".join(lines)
+
+
+def write_digest(window_hours: int = 24) -> Dict[str, str]:
+    """Generate the digest and write both markdown + json artifacts.
+
+    Returns paths to the created files so the founder can inspect them
+    from the interactive session even without email delivery.
+    """
+    _ensure_dir()
+    digest = build_digest(window_hours=window_hours)
+    date_slug = digest["generated_at"][:10]
+    md_path = DIGEST_DIR / f"digest-{date_slug}.md"
+    json_path = DIGEST_DIR / f"digest-{date_slug}.json"
+    md_path.write_text(render_markdown(digest))
+    json_path.write_text(json.dumps(digest, indent=2))
+    return {
+        "markdown_path": str(md_path),
+        "json_path": str(json_path),
+        "summary": f"{digest['signals']['total']} signals, {digest['deliberations']['total']} deliberations, {digest['ledger']['opened']} new ledger items, {digest['dispatches']['stuck_over_24h']} stuck dispatches",
+    }
+
+
+def send_digest_email(to: str = "", from_account: str = "pro@delimit.ai") -> Dict[str, Any]:
+    """Send the most recent digest via the notify pipeline.
+
+    Gated on environment: returns a no-op result when DMARC is missing
+    and email would be filtered. Set DELIMIT_DIGEST_EMAIL=true to force
+    send attempts regardless. The digest markdown is always written to
+    disk so the founder can inspect it from the interactive session.
+    """
+    import os
+    result = write_digest(window_hours=24)
+    md_path = Path(result["markdown_path"])
+    if not md_path.exists():
+        return {"error": "digest not written", "files": result}
+
+    send_enabled = os.environ.get("DELIMIT_DIGEST_EMAIL", "").lower() in ("true", "1", "yes")
+    if not send_enabled:
+        return {
+            "status": "skipped_email",
+            "reason": "DELIMIT_DIGEST_EMAIL not set to true; digest written to disk only",
+            "files": result,
+        }
+
+    try:
+        from ai.notify import send_notification
+        body = md_path.read_text()
+        send_notification(
+            channel="email",
+            message=body,
+            subject=f"[DIGEST] Delimit — {result['summary']}",
+            to=to or os.environ.get("DELIMIT_SMTP_TO", ""),
+            from_account=from_account,
+            event_type="daily_digest",
+        )
+        return {
+            "status": "sent",
+            "files": result,
+        }
+    except Exception as exc:
+        return {
+            "status": "send_failed",
+            "error": str(exc),
+            "files": result,
+        }

package/gateway/ai/ledger_manager.py

@@ -202,7 +202,39 @@ def add_item(
     LED-189: Items can have acceptance_criteria (testable "done when" conditions).
     LED-190: Items can have context, tools_needed, and estimated_complexity
     for agent-executable task format.
+    LED-877: Signal guard — rejects source='social_scan' writes so sensed
+    observations cannot land in the ledger. Observations belong in the intel
+    signal store (ai/sensing/signal_store.py). Bypass via env var for the
+    promote_to_ledger path: _DELIMIT_SIGNAL_PROMOTED_BY=<who>.
     """
+    _src_norm = (source or "").strip().lower()
+    _promoted_by = os.environ.get("_DELIMIT_SIGNAL_PROMOTED_BY", "")
+    _guard_mode = os.environ.get("DELIMIT_SIGNAL_GUARD", "enforce").lower()
+    if _src_norm.startswith("social_scan") or _src_norm.startswith("social_strategy"):
+        if not _promoted_by:
+            msg = (
+                f"LED-877 guard: source={source!r} is a sensed observation, not "
+                f"a ledger item. Use ai.sensing.signal_store.ingest() instead. "
+                f"Promote explicitly via promote_to_ledger(signal_id=...)."
+            )
+            if _guard_mode == "shadow":
+                try:
+                    _shadow_log = Path.home() / ".delimit" / "logs" / "signal_guard_shadow.jsonl"
+                    _shadow_log.parent.mkdir(parents=True, exist_ok=True)
+                    with _shadow_log.open("a") as _f:
+                        _f.write(json.dumps({
+                            "ts": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                            "title": title,
+                            "source": source,
+                            "ledger": ledger,
+                            "msg": msg,
+                        }) + "\n")
+                except Exception:
+                    pass
+                # fall through
+            else:
+                raise ValueError(msg)
+
     _ensure(project_path)
     venture = _detect_venture(project_path)
     ledger_dir = _project_ledger_dir(project_path)

package/gateway/ai/license_core.py

@@ -37,6 +37,8 @@ PRO_TOOLS = frozenset({
     # Agent orchestration
     "delimit_agent_dispatch", "delimit_agent_status",
     "delimit_agent_complete", "delimit_agent_handoff",
+    # Worker Pool v2 executor (LED-981)
+    "delimit_executor",
 })
 
 # Free trial limits

package/gateway/ai/notify.py

@@ -1044,17 +1044,23 @@ def _enforce_email_protocol(subject: str, message: str, event_type: str) -> tupl
     # 1. Subject must have a valid prefix bracket
     if not any(subject.startswith(p) for p in _VALID_SUBJECT_PREFIXES):
         # Try to infer from event_type
-        prefix_map = {
-            "social_draft": "[APPROVE]",
-            "outreach": "[OUTREACH]",
-            "deploy": "[DEPLOY]",
-            "gate_failure": "[ALERT]",
-            "digest": "[DIGEST]",
-            "info": "[INFO]",
-        }
-        prefix = prefix_map.get(event_type, "[INFO]")
-        subject = f"{prefix} {subject}"
-        warnings.append(f"Subject prefix added: {prefix}")
+        # LED-969: customer-facing emails should not get bracket prefixes.
+        # Any event_type starting with "customer_" is external-facing and
+        # the subject should be sent as-is (clean, professional).
+        if event_type and event_type.startswith("customer_"):
+            pass  # no prefix for customer emails
+        else:
+            prefix_map = {
+                "social_draft": "[APPROVE]",
+                "outreach": "[OUTREACH]",
+                "deploy": "[DEPLOY]",
+                "gate_failure": "[ALERT]",
+                "digest": "[DIGEST]",
+                "info": "[INFO]",
+            }
+            prefix = prefix_map.get(event_type, "[INFO]")
+            subject = f"{prefix} {subject}"
+            warnings.append(f"Subject prefix added: {prefix}")
 
     # 2. Check required sections for this event_type
     required = _EMAIL_PROTOCOL.get(event_type, [])