delimit-cli 4.5.1 → 4.5.2

package/gateway/ai/server.py

@@ -7302,7 +7302,8 @@ def delimit_social_post(text: str = "", category: str = "", platform: str = "twi
     Categories: tip, changelog, insight, engagement.
     Leave text empty to auto-generate from templates.
     Every post provides value - tips, insights, governance wisdom.
-    Max 2 posts per day to stay authentic.
+    Rate cap: 2 original posts per hour, 24 per day (founder-approved
+    2026-04-30). Override via DELIMIT_HOURLY_TWEETS / DELIMIT_DAILY_TWEETS.
 
     IMPORTANT - Platform tone rules (these are DIFFERENT per platform):
     - Twitter: confident technical brand. Direct, professional, ALWAYS POSITIVE.
@@ -7323,10 +7324,10 @@ def delimit_social_post(text: str = "", category: str = "", platform: str = "twi
         draft: If True, save as draft for approval instead of posting immediately.
         context: WHY this post should be made. Strategic reasoning shown in the approval email.
     """
-    from ai.social import generate_post, post_tweet, should_post_today, save_draft
+    from ai.social import generate_post, post_tweet, should_post_now, save_draft
 
-    if not draft and not should_post_today():
-        return {"status": "skipped", "reason": "Already posted twice today. Authenticity > volume."}
+    if not draft and not should_post_now():
+        return {"status": "skipped", "reason": "Rate cap hit (2/hr or 24/day). Wait or pass draft=True for email-approval flow."}
 
     post = generate_post(category, text)
 
@@ -7443,9 +7444,16 @@ def delimit_social_post(text: str = "", category: str = "", platform: str = "twi
                 _lines.append("Reply APPROVED to approve, CANCEL to reject.")
 
                 _handle = f"u/{_acct}"
+                # LED-1129 Phase 2 — append [draft_id:<8>] token to subject so
+                # the inbox daemon's draft_id fallback can match the approval
+                # reply even when no LED/STR token is present.
+                _reddit_subject = f"[Reddit Post] {_handle}: {_reddit_title[:60]}..."
+                _reg_id = entry.get("registry_draft_id")
+                if _reg_id:
+                    _reddit_subject = f"{_reddit_subject} [draft_id:{_reg_id[:8]}]"
                 email_result = send_email(
                     message="\n".join(_lines),
-                    subject=f"[Reddit Post] {_handle}: {_reddit_title[:60]}...",
+                    subject=_reddit_subject,
                     event_type="social_draft",
                 )
                 if email_result.get("delivered") and email_result.get("message_id"):
@@ -7487,9 +7495,16 @@ def delimit_social_post(text: str = "", category: str = "", platform: str = "twi
             _subject_type = "Tweet"
 
         _handle = f"u/{_acct}" if platform == "reddit" else f"@{_acct}"
+        # LED-1129 Phase 2 — append [draft_id:<8>] token to subject so the
+        # inbox daemon's draft_id fallback can match the approval reply even
+        # when no LED/STR token is present.
+        _social_subject = f"[{_subject_type}] {_handle}: {post['text'][:60]}..."
+        _reg_id = entry.get("registry_draft_id")
+        if _reg_id:
+            _social_subject = f"{_social_subject} [draft_id:{_reg_id[:8]}]"
         email_result = send_email(
             message="\n".join(_lines),
-            subject=f"[{_subject_type}] {_handle}: {post['text'][:60]}...",
+            subject=_social_subject,
             event_type="social_draft",
         )
         # Store the outbound Message-ID on the draft record so the
@@ -7529,6 +7544,55 @@ def delimit_social_accounts() -> Dict[str, Any]:
     return _with_next_steps("social_accounts", {"accounts": accounts, "count": len(accounts)})
 
 
+@mcp.tool()
+def delimit_x_fetch(id_or_url: str = "", ids: str = "") -> Dict[str, Any]:
+    """LED-825: fetch tweets from X by id or URL via twttr241 (RapidAPI).
+
+    Inherits the LRU + SQLite cache + budget gate already wired for the
+    social-target scanner, so repeated reads of the same tweet are free.
+
+    Args:
+        id_or_url: A single status id ("2048825010371039648") OR a full
+            x.com / twitter.com URL — the id is extracted automatically.
+            Mutually exclusive with `ids`.
+        ids: Comma-separated list of status ids OR URLs for a batch fetch.
+            Each is normalized to a status id and fetched independently.
+
+    Returns:
+        Single-fetch shape: {id, text, author, author_name, created_at,
+            metrics: {favorite_count, retweet_count, reply_count,
+            quote_count, bookmark_count, view_count}, url, from_cache}
+        Batch shape: {tweets: [<single-shape>, ...], count}
+        Errors: {error: <reason>}
+
+    Why this exists: WebFetch hits 402 on x.com (auth-walled), and going
+    around to tweepy + the X API direct creds skips the cache + budget
+    gate. This tool is the cheap, cached, governable read path.
+    """
+    from ai.social_target import fetch_tweet_by_id, fetch_tweets_by_ids, extract_status_id
+
+    if ids:
+        # Batch mode — accept commas, newlines, or whitespace as separators
+        raw = [r.strip() for r in ids.replace("\n", ",").split(",") if r.strip()]
+        normalized: List[str] = []
+        for item in raw:
+            sid = extract_status_id(item)
+            if sid:
+                normalized.append(sid)
+        if not normalized:
+            return _with_next_steps("x_fetch", {"error": "no valid ids/URLs in `ids`"})
+        results = fetch_tweets_by_ids(normalized)
+        return _with_next_steps("x_fetch", {"tweets": results, "count": len(results)})
+
+    if not id_or_url:
+        return _with_next_steps("x_fetch", {"error": "provide either id_or_url or ids"})
+
+    sid = extract_status_id(id_or_url)
+    if not sid:
+        return _with_next_steps("x_fetch", {"error": f"could not parse status id from {id_or_url!r}"})
+    return _with_next_steps("x_fetch", fetch_tweet_by_id(sid))
+
+
 @mcp.tool()
 def delimit_social_history(limit: int = 20, platform: str = "",
                            user: str = "", subreddit: str = "") -> Dict[str, Any]:
@@ -7985,6 +8049,64 @@ def delimit_social_daemon(action: str = "status") -> Dict[str, Any]:
     else:
         return _with_next_steps("social_daemon", get_daemon_status())
 
+
+@mcp.tool()
+def delimit_self_repair_daemon(action: str = "status") -> Dict[str, Any]:
+    """Control the self-repair watcher daemon (LED-191, internal).
+
+    Polls function KPIs on a cadence (default 1h) and emits founder
+    alerts on fresh breaches. Higher modes (diagnose/deliberate/apply/
+    verify) chain through the watcher when configured per-function in
+    ~/.delimit/self_repair.yaml.
+
+    Idempotent start; circuit-breakered stop after 3 consecutive
+    pass failures. Honors DELIMIT_SELF_REPAIR_PAUSE=1 at every pass
+    without requiring a daemon restart.
+
+    Args:
+        action: 'start' (begin polling), 'stop' (halt polling),
+                'status' (running / last_pass / breaches_emitted /
+                consecutive_failures).
+    """
+    from ai.self_repair_daemon import (
+        start_daemon as _sr_start,
+        stop_daemon as _sr_stop,
+        get_daemon_status as _sr_status,
+    )
+
+    if action == "start":
+        return _with_next_steps("self_repair_daemon", _sr_start())
+    elif action == "stop":
+        return _with_next_steps("self_repair_daemon", _sr_stop())
+    else:
+        return _with_next_steps("self_repair_daemon", _sr_status())
+
+
+# ═══════════════════════════════════════════════════════════════════════
+#  LED-189: Corp dashboard — single-call session-start synthesis
+# ═══════════════════════════════════════════════════════════════════════
+
+
+@mcp.tool()
+def delimit_corp_dashboard() -> Dict[str, Any]:
+    """One-call corp status — replaces the 6-call session-start ritual (LED-189).
+
+    Returns daemon states (systemd + in-process), self-repair status,
+    social/inbox activity, ledger pending counts, agent queue (audit-only),
+    latest session, and a synthesized one-line summary like:
+
+        "Corp status: 3 daemons active (self-repair, inbox, social),
+        12 ledger open, 2 approvals waiting, 4 breaches in 24h."
+
+    Every sub-section is failure-isolated: a partial failure returns
+    {"error": "..."} for that key only and never crashes the whole call.
+    Gateway-only — not shipped in the npm bundle.
+    """
+    from ai.corp_dashboard import get_corp_dashboard
+    result = get_corp_dashboard()
+    return _with_next_steps("corp_dashboard", result)
+
+
 # ═══════════════════════════════════════════════════════════════════════
 #  LED-187: Shareable Governance Config - export / import
 # ═══════════════════════════════════════════════════════════════════════

package/gateway/ai/social_capability/__init__.py

@@ -0,0 +1,6 @@
+"""Social outreach capability-currency module (LED-216 Phase 1).
+
+Curated capability inventory + draft-emit validator. Lives outside
+``ai/social.py`` so the existing module stays focused on draft generation
+and Python doesn't get a package/module name collision.
+"""

package/gateway/ai/social_capability/capability_validator.py

@@ -0,0 +1,273 @@
+"""Capability-currency validator (LED-216 Phase 1).
+
+Validates social drafts against ``current_capabilities.yaml``. The validator
+hard-fails any draft that names a banned surface (literal or regex), and
+warns when a draft references the Delimit product but no canonical phrase
+appears.
+
+Wiring: ``ai.social.save_draft`` calls :func:`validate_draft` after the
+existing tone/length checks but BEFORE the file is appended. On hard-fail
+the draft's ``quality`` is overridden to ``"rejected_capability_drift"`` and
+the entry MUST NOT be enqueued for notify. On warn the quality becomes
+``"ready_with_warnings"``. Both outcomes are logged to
+``~/.delimit/social_drafts_validation.jsonl`` for audit / replay.
+
+Governance: the underlying ``current_capabilities.yaml`` is gated by the
+LED-1037 banned-vocabulary contract — edits require a unanimous
+``delimit_deliberate`` verdict. This module only consumes the file; it does
+not mutate it.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    import yaml as _yaml
+except ImportError:  # pragma: no cover
+    _yaml = None  # type: ignore[assignment]
+
+logger = logging.getLogger("delimit.ai.social_capability.capability_validator")
+
+# Default capabilities path — co-located with this module so the file ships
+# (or doesn't) with the same npm exclusion rule as the rest of
+# ai/social_capability/. The package name is `social_capability` rather
+# than `social` because `ai/social.py` already exists as a top-level
+# module and Python forbids a package with the same name as a sibling
+# module.
+DEFAULT_CAPABILITIES_PATH = Path(__file__).parent / "current_capabilities.yaml"
+
+# Audit log for every validator decision (pass / warn / fail). One JSONL
+# line per draft. Used by self-repair to detect over- or under-firing.
+VALIDATION_LOG = Path.home() / ".delimit" / "social_drafts_validation.jsonl"
+
+# ── product-mention detection ────────────────────────────────────────
+
+# Case-insensitive match for "Delimit" as a standalone word OR the
+# @delimit_ai twitter handle. Avoid false positives on hostnames like
+# "delimit.ai/methodology/..." by NOT requiring word boundaries — the URL
+# itself is a product reference, which is exactly the case where we want
+# to nudge the canonical phrase.
+_PRODUCT_MENTION_RE = re.compile(
+    r"(?:\bDelimit\b|@delimit_ai|delimit\.ai)",
+    re.IGNORECASE,
+)
+
+
+def _load_capabilities(path: Path) -> Dict[str, Any]:
+    """Load and parse the capabilities YAML.
+
+    Returns an empty config (no banned, no claims) if the file is missing
+    or YAML is unavailable, so the validator fails open in degraded
+    environments rather than crashing draft generation. The fail-open is
+    intentional: a missing capability file should NOT block legitimate
+    drafts; the worst outcome is the draft passes through without
+    capability-currency enforcement, which we'll catch via the audit log.
+    """
+    if _yaml is None:
+        logger.warning(
+            "capability_validator: PyYAML not available; validator is a no-op"
+        )
+        return {}
+    if not path.exists():
+        logger.warning(
+            "capability_validator: capabilities file missing at %s; "
+            "validator is a no-op",
+            path,
+        )
+        return {}
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = _yaml.safe_load(f) or {}
+    except Exception as exc:  # pragma: no cover — corrupt yaml
+        logger.error(
+            "capability_validator: failed to load %s: %s", path, exc
+        )
+        return {}
+    if not isinstance(data, dict):
+        logger.error(
+            "capability_validator: %s did not parse to a mapping", path
+        )
+        return {}
+    return data
+
+
+def _matched_claims(text: str, claims: List[Dict[str, Any]]) -> List[str]:
+    """Return IDs of allowed_claims whose surface_name appears in text."""
+    out: List[str] = []
+    lower = text.lower()
+    for claim in claims:
+        if not isinstance(claim, dict):
+            continue
+        surface = (claim.get("surface_name") or "").strip()
+        cid = (claim.get("id") or "").strip()
+        if not surface or not cid:
+            continue
+        if surface.lower() in lower:
+            out.append(cid)
+    return out
+
+
+def _matched_banned_literal(
+    text: str, banned: List[str]
+) -> List[str]:
+    """Return banned surface literals (case-insensitive) found in text."""
+    lower = text.lower()
+    return [b for b in banned if isinstance(b, str) and b and b.lower() in lower]
+
+
+def _matched_banned_pattern(
+    text: str, patterns: List[str]
+) -> List[str]:
+    """Return banned regex patterns that match somewhere in text.
+
+    Compilation errors on individual patterns are logged and the pattern is
+    skipped so one bad regex does not break the whole validator.
+    """
+    out: List[str] = []
+    for pat in patterns:
+        if not isinstance(pat, str) or not pat:
+            continue
+        try:
+            if re.search(pat, text, flags=re.IGNORECASE):
+                out.append(pat)
+        except re.error as exc:
+            logger.warning(
+                "capability_validator: bad banned_surface_pattern %r: %s",
+                pat, exc,
+            )
+            continue
+    return out
+
+
+def _has_canonical_phrase(text: str, phrases: List[str]) -> bool:
+    lower = text.lower()
+    for p in phrases:
+        if isinstance(p, str) and p and p.lower() in lower:
+            return True
+    return False
+
+
+def _mentions_product(text: str) -> bool:
+    return bool(_PRODUCT_MENTION_RE.search(text or ""))
+
+
+def _append_audit(record: Dict[str, Any]) -> None:
+    """Append a validation decision to the audit log. Best-effort."""
+    try:
+        VALIDATION_LOG.parent.mkdir(parents=True, exist_ok=True)
+        with open(VALIDATION_LOG, "a", encoding="utf-8") as f:
+            f.write(json.dumps(record) + "\n")
+    except Exception as exc:  # pragma: no cover — disk full, etc.
+        logger.debug("capability_validator: audit write failed: %s", exc)
+
+
+def validate_draft(
+    text: str,
+    capabilities_path: Optional[Path] = None,
+    *,
+    audit_meta: Optional[Dict[str, Any]] = None,
+    log: bool = True,
+) -> Dict[str, Any]:
+    """Validate a social draft against ``current_capabilities.yaml``.
+
+    Args:
+        text: The candidate draft text.
+        capabilities_path: Override path to the capabilities YAML. Defaults
+            to the bundled ``current_capabilities.yaml`` next to this
+            module.
+        audit_meta: Optional fields to embed in the audit log entry
+            (e.g. ``{"draft_id": ..., "platform": ...}``). Never required
+            for validation logic.
+        log: When False, skip the audit log write. Used by tests.
+
+    Returns:
+        Dict with:
+          - ``ok`` (bool): False iff a banned surface (literal or pattern)
+            appeared.
+          - ``errors`` (list[str]): Hard-fail reasons.
+          - ``warnings`` (list[str]): Soft-fail reasons (e.g. product
+            mentioned without canonical phrase).
+          - ``matched_claims`` (list[str]): IDs of allowed_claims found.
+          - ``matched_banned`` (list[str]): Banned surfaces / patterns hit.
+          - ``mentions_product`` (bool): Whether the draft references
+            Delimit by name or handle.
+          - ``has_canonical_phrase`` (bool): Whether at least one canonical
+            phrase appears.
+    """
+    text = text or ""
+    path = capabilities_path or DEFAULT_CAPABILITIES_PATH
+    cfg = _load_capabilities(path)
+
+    allowed_claims = cfg.get("allowed_claims") or []
+    banned_literals = cfg.get("banned_surfaces") or []
+    banned_patterns = cfg.get("banned_surface_patterns") or []
+    required_phrases = cfg.get("required_canonical_phrases") or []
+
+    matched_claims = _matched_claims(text, allowed_claims)
+    matched_literal = _matched_banned_literal(text, banned_literals)
+    matched_patterns = _matched_banned_pattern(text, banned_patterns)
+    matched_banned = matched_literal + matched_patterns
+
+    errors: List[str] = []
+    for hit in matched_literal:
+        errors.append(
+            f"banned surface literal: {hit!r} — see ai/social_capability/current_capabilities.yaml"
+        )
+    for pat in matched_patterns:
+        errors.append(
+            f"banned surface pattern matched: {pat!r} (tool-count hero "
+            f"language is forbidden in social copy)"
+        )
+
+    mentions_product = _mentions_product(text)
+    has_canonical = _has_canonical_phrase(text, required_phrases)
+
+    warnings: List[str] = []
+    if mentions_product and not has_canonical and required_phrases:
+        warnings.append(
+            "draft mentions Delimit but does not include a canonical phrase "
+            "(merge gate / signed, replayable attestation / AI-written code "
+            "/ AI-assisted merge). Founder review recommended."
+        )
+
+    ok = not errors
+
+    result: Dict[str, Any] = {
+        "ok": ok,
+        "errors": errors,
+        "warnings": warnings,
+        "matched_claims": matched_claims,
+        "matched_banned": matched_banned,
+        "mentions_product": mentions_product,
+        "has_canonical_phrase": has_canonical,
+    }
+
+    if log:
+        record = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "ok": ok,
+            "errors": errors,
+            "warnings": warnings,
+            "matched_claims": matched_claims,
+            "matched_banned": matched_banned,
+            "mentions_product": mentions_product,
+            "has_canonical_phrase": has_canonical,
+            "text_len": len(text),
+            "capabilities_path": str(path),
+        }
+        if audit_meta:
+            # Don't let audit_meta clobber computed fields.
+            for k, v in audit_meta.items():
+                record.setdefault(k, v)
+        _append_audit(record)
+
+    return result
+
+
+__all__ = ["validate_draft", "DEFAULT_CAPABILITIES_PATH", "VALIDATION_LOG"]

package/gateway/ai/social_capability/current_capabilities.yaml

@@ -0,0 +1,95 @@
+# LED-216 Phase 1 — Capability Currency
+#
+# This file is the single source of truth for what Delimit is allowed to
+# claim in any social draft. The capability_validator.py module reads it
+# at draft emit time and hard-fails any draft that:
+#
+#   * names a banned surface (literal substring), OR
+#   * matches a banned surface regex (e.g. tool-count hero language).
+#
+# Drafts that mention "Delimit" / "@delimit_ai" but reference NO canonical
+# phrase are warned (not failed) so the founder can still review.
+#
+# ──────────────────────────────────────────────────────────────────────
+# GOVERNANCE (mirror of LED-1037 banned-vocabulary gate)
+# ──────────────────────────────────────────────────────────────────────
+# Edits to this file MUST be gated by `delimit_deliberate` unanimous
+# verdict. Same governance contract as the LED-1037 banned-vocabulary
+# list: any change requires a multi-model panel sign-off (Claude +
+# Gemini + Codex + Grok) before it lands. Silent edits are a policy
+# violation and will be reverted.
+#
+# 30-day review cadence: capabilities rot fast. The `last_reviewed`
+# field below MUST be bumped on every panel-approved edit, and the
+# orchestrator should re-deliberate if `now - last_reviewed >
+# review_cadence_days`.
+# ──────────────────────────────────────────────────────────────────────
+
+version: 1
+last_reviewed: 2026-05-02
+review_cadence_days: 30
+
+allowed_claims:
+  # Each entry: {id, surface_name, description, since_version, evidence_link}
+  - id: attest_mcp
+    surface_name: "delimit attest mcp"
+    description: "Local CLI subcommand that runs the 5-check methodology preview."
+    since_version: 4.5.0
+    evidence_link: https://delimit.ai/methodology/mcp-attestation
+  - id: self_repair_v1
+    surface_name: "self-repair v1 closed loop"
+    description: "Sensor → diagnose → deliberate → apply → verify with founder approval gate."
+    since_version: gateway-2026-05-01
+    evidence_link: https://delimit.ai/methodology/mcp-attestation
+  - id: merge_gate
+    surface_name: "merge gate for AI-written code"
+    description: "Signed, replayable attestation for every AI-assisted merge."
+    since_version: "1.0"
+    evidence_link: https://delimit.ai
+  - id: multi_model_deliberation
+    surface_name: "multi-model deliberation panel"
+    description: "delimit_deliberate runs Claude + Gemini + Codex + Grok to consensus."
+    since_version: "1.0"
+  - id: persistent_context
+    surface_name: "persistent context across sessions"
+    description: "Memory + ledger survive across sessions and models via delimit_revive / delimit_session_handoff."
+  - id: governance_kernel
+    surface_name: "fail-closed governance kernel"
+    description: "Audit trail + evidence_collect at every gate."
+  - id: diff_engine
+    surface_name: "27 breaking-change types"
+    description: "Deterministic diff engine for OpenAPI spec changes."
+  - id: github_action
+    surface_name: "delimit-ai/delimit-action GitHub Action"
+    description: "On Marketplace, breaking-change detection on PRs."
+  - id: corp_dashboard
+    surface_name: "delimit_corp_dashboard"
+    description: "Single-call corp status synthesis."
+    since_version: gateway-2026-05-01
+  - id: methodology_v1
+    surface_name: "MCP attestation methodology v1"
+    description: "Public methodology document at delimit.ai/methodology/mcp-attestation."
+
+banned_surfaces:
+  # Strings that MUST NOT appear in any social draft. Validator hard-fails.
+  - "AI OS"
+  - "governance platform"
+  - "one workspace for every AI coding assistant"
+  - "5 capability domains"
+  - "Jamsons OS"
+  - "Delimit OS"
+  - "186 tools"
+
+banned_surface_patterns:
+  # Tool-count hero language patterns — match by regex in validator.
+  - "\\d+ tools"
+  - "\\d+ capability domains"
+
+required_canonical_phrases:
+  # At least one of these MUST appear in any draft that mentions Delimit's
+  # product. If draft mentions Delimit by name and references no canonical
+  # phrase, validator warns (does not hard-fail).
+  - "merge gate"
+  - "signed, replayable attestation"
+  - "AI-written code"
+  - "AI-assisted merge"