delimit-cli 3.14.16 → 3.14.18

package/bin/delimit-cli.js

@@ -760,6 +760,9 @@ const hookCmd = program
                 case 'pre-commit':
                     await crossModelHooks.hookPreCommit();
                     break;
+                case 'deploy-gate':
+                    await crossModelHooks.hookDeployGate();
+                    break;
                 default:
                     // Legacy: fall back to agent-based hook evaluation
                     await ensureAgent();

package/gateway/ai/agent_dispatch.py

@@ -0,0 +1,458 @@
+"""Multi-agent orchestration — dispatch, track, and govern engineering tasks.
+
+Agents are tracked via a local task store. Each dispatched task gets a unique
+ID with status tracking. The dispatcher doesn't spawn actual AI processes
+(that's the host AI's job) — it provides the governance layer:
+assignment, tracking, policy enforcement, and handoff protocol.
+
+Storage: ~/.delimit/agents/tasks.json
+Audit trail: ~/.delimit/agents/audit.jsonl
+"""
+
+import json
+import time
+import uuid
+from pathlib import Path
+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"
+
+VALID_PRIORITIES = {"P0", "P1", "P2"}
+VALID_ASSIGNEES = {"claude", "codex", "gemini", "any"}
+VALID_STATUSES = {"dispatched", "in_progress", "done", "handed_off", "failed"}
+
+
+def _ensure_dir():
+    """Create the agents directory if it doesn't exist."""
+    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _load_tasks() -> Dict[str, Any]:
+    """Load all tasks from the tasks file."""
+    if not TASKS_FILE.exists():
+        return {}
+    try:
+        return json.loads(TASKS_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save_tasks(tasks: Dict[str, Any]):
+    """Write all tasks back to the tasks file."""
+    _ensure_dir()
+    TASKS_FILE.write_text(json.dumps(tasks, indent=2))
+
+
+def _append_audit(entry: Dict[str, Any]):
+    """Append an entry to the audit trail."""
+    _ensure_dir()
+    entry["ts"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+    with open(AUDIT_FILE, "a") as f:
+        f.write(json.dumps(entry) + "\n")
+
+
+def dispatch_task(
+    title: str,
+    description: str = "",
+    assignee: str = "any",
+    priority: str = "P1",
+    tools_needed: Optional[List[str]] = None,
+    constraints: Optional[List[str]] = None,
+    context: str = "",
+) -> Dict[str, Any]:
+    """Create a tracked agent task.
+
+    Returns:
+        Dict with task_id, task details, and a structured prompt for the host AI.
+    """
+    if not title or not title.strip():
+        return {"error": "title is required"}
+
+    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))}"}
+
+    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))}"}
+
+    task_id = f"AGT-{uuid.uuid4().hex[:8].upper()}"
+
+    task = {
+        "id": task_id,
+        "title": title.strip(),
+        "description": description.strip(),
+        "assignee": assignee,
+        "priority": priority,
+        "tools_needed": tools_needed or [],
+        "constraints": constraints or [],
+        "context": context.strip(),
+        "status": "dispatched",
+        "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "updated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "files_changed": [],
+        "result": "",
+        "handoffs": [],
+    }
+
+    tasks = _load_tasks()
+    tasks[task_id] = task
+    _save_tasks(tasks)
+
+    _append_audit({
+        "action": "dispatch",
+        "task_id": task_id,
+        "title": title.strip(),
+        "assignee": assignee,
+        "priority": priority,
+    })
+
+    # Build a structured prompt that the host AI can pass to a subagent
+    prompt = _build_agent_prompt(task)
+
+    return {
+        "status": "dispatched",
+        "task_id": task_id,
+        "task": task,
+        "agent_prompt": prompt,
+        "message": f"Task {task_id} dispatched to {assignee} ({priority})",
+    }
+
+
+def _build_agent_prompt(task: Dict[str, Any]) -> str:
+    """Build a structured prompt for a subagent to execute the task."""
+    lines = [
+        f"## Agent Task: {task['id']}",
+        f"**Title:** {task['title']}",
+    ]
+    if task.get("description"):
+        lines.append(f"**Description:** {task['description']}")
+    lines.append(f"**Priority:** {task['priority']}")
+    lines.append(f"**Assignee:** {task['assignee']}")
+
+    if task.get("context"):
+        lines.append(f"\n**Context:**\n{task['context']}")
+
+    if task.get("tools_needed"):
+        lines.append(f"\n**Tools needed:** {', '.join(task['tools_needed'])}")
+
+    if task.get("constraints"):
+        lines.append(f"\n**Constraints:**")
+        for c in task["constraints"]:
+            lines.append(f"- {c}")
+
+    lines.append(f"\n**When done:** Call `delimit_agent_complete` with task_id='{task['id']}' and your result.")
+
+    return "\n".join(lines)
+
+
+def get_agent_status(task_id: str = "") -> Dict[str, Any]:
+    """Get the status of a specific task, or list all active tasks."""
+    tasks = _load_tasks()
+
+    if not task_id or not task_id.strip():
+        return list_active_agents()
+
+    task_id = task_id.strip().upper()
+    if task_id not in tasks:
+        return {"error": f"Task {task_id} not found"}
+
+    return {
+        "status": "ok",
+        "task": tasks[task_id],
+    }
+
+
+def list_active_agents() -> Dict[str, Any]:
+    """Return all tasks that are not done or failed."""
+    tasks = _load_tasks()
+    active = {
+        tid: t for tid, t in tasks.items()
+        if t.get("status") in ("dispatched", "in_progress", "handed_off")
+    }
+    completed = {
+        tid: t for tid, t in tasks.items()
+        if t.get("status") in ("done", "failed")
+    }
+
+    return {
+        "status": "ok",
+        "active_count": len(active),
+        "completed_count": len(completed),
+        "active_tasks": list(active.values()),
+        "summary": [
+            {"id": t["id"], "title": t["title"], "status": t["status"],
+             "assignee": t["assignee"], "priority": t["priority"]}
+            for t in active.values()
+        ],
+    }
+
+
+def complete_task(
+    task_id: str,
+    result: str = "",
+    files_changed: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """Mark a dispatched task as done."""
+    if not task_id or not task_id.strip():
+        return {"error": "task_id is required"}
+
+    task_id = task_id.strip().upper()
+    tasks = _load_tasks()
+
+    if task_id not in tasks:
+        return {"error": f"Task {task_id} not found"}
+
+    task = tasks[task_id]
+    if task["status"] == "done":
+        return {"error": f"Task {task_id} is already marked done"}
+
+    task["status"] = "done"
+    task["result"] = result.strip()
+    task["files_changed"] = files_changed or []
+    task["completed_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+    task["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    tasks[task_id] = task
+    _save_tasks(tasks)
+
+    _append_audit({
+        "action": "complete",
+        "task_id": task_id,
+        "result": result.strip()[:200],
+        "files_changed": files_changed or [],
+    })
+
+    return {
+        "status": "completed",
+        "task_id": task_id,
+        "task": task,
+        "message": f"Task {task_id} marked as done",
+    }
+
+
+def handoff_task(
+    task_id: str,
+    to_model: str,
+    context: str = "",
+) -> Dict[str, Any]:
+    """Transfer a task from one AI model to another."""
+    if not task_id or not task_id.strip():
+        return {"error": "task_id is required"}
+    if not to_model or not to_model.strip():
+        return {"error": "to_model is required"}
+
+    task_id = task_id.strip().upper()
+    to_model = to_model.lower().strip()
+
+    if to_model not in VALID_ASSIGNEES - {"any"}:
+        return {"error": f"to_model must be one of: {', '.join(sorted(VALID_ASSIGNEES - {'any'}))}"}
+
+    tasks = _load_tasks()
+    if task_id not in tasks:
+        return {"error": f"Task {task_id} not found"}
+
+    task = tasks[task_id]
+    if task["status"] == "done":
+        return {"error": f"Task {task_id} is already done, cannot hand off"}
+
+    from_model = task["assignee"]
+    task["handoffs"].append({
+        "from": from_model,
+        "to": to_model,
+        "context": context.strip(),
+        "ts": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+    })
+    task["assignee"] = to_model
+    task["status"] = "handed_off"
+    task["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    # Rebuild the prompt with handoff context
+    if context.strip():
+        task["context"] = (task.get("context", "") + "\n\n---\n**Handoff context from " +
+                          from_model + ":**\n" + context.strip()).strip()
+
+    tasks[task_id] = task
+    _save_tasks(tasks)
+
+    _append_audit({
+        "action": "handoff",
+        "task_id": task_id,
+        "from": from_model,
+        "to": to_model,
+        "context_snippet": context.strip()[:200],
+    })
+
+    prompt = _build_agent_prompt(task)
+
+    return {
+        "status": "handed_off",
+        "task_id": task_id,
+        "from_model": from_model,
+        "to_model": to_model,
+        "task": task,
+        "agent_prompt": prompt,
+        "message": f"Task {task_id} handed off from {from_model} to {to_model}",
+    }
+
+
+def enforce_constraints(task_id: str, action: str) -> Dict[str, Any]:
+    """Check if an action is allowed given the task's constraints.
+
+    Returns:
+        Dict with 'allowed' (bool) and 'reason' if denied.
+    """
+    if not task_id or not task_id.strip():
+        return {"allowed": True, "reason": "No task_id provided, no constraints to check"}
+
+    task_id = task_id.strip().upper()
+    tasks = _load_tasks()
+
+    if task_id not in tasks:
+        return {"allowed": True, "reason": f"Task {task_id} not found, defaulting to allow"}
+
+    task = tasks[task_id]
+    constraints = task.get("constraints", [])
+
+    if not constraints:
+        return {"allowed": True, "reason": "No constraints on this task"}
+
+    action_lower = action.lower().strip() if action else ""
+
+    # Check each constraint against the action
+    for constraint in constraints:
+        c = constraint.lower().strip()
+
+        if c == "read-only":
+            write_keywords = ["write", "edit", "create", "delete", "modify", "deploy", "push", "commit"]
+            if any(kw in action_lower for kw in write_keywords):
+                return {
+                    "allowed": False,
+                    "reason": f"Constraint 'read-only' blocks action: {action}",
+                    "constraint": constraint,
+                }
+
+        elif c == "no-deploy" or c == "no-deploys":
+            deploy_keywords = ["deploy", "publish", "release", "rollback"]
+            if any(kw in action_lower for kw in deploy_keywords):
+                return {
+                    "allowed": False,
+                    "reason": f"Constraint '{constraint}' blocks action: {action}",
+                    "constraint": constraint,
+                }
+
+        elif c == "must-lint" or c == "must_lint":
+            # This is an affirmative constraint — doesn't block, just flags
+            pass
+
+        elif c.startswith("no-"):
+            # Generic "no-X" constraint
+            blocked = c[3:]
+            if blocked in action_lower:
+                return {
+                    "allowed": False,
+                    "reason": f"Constraint '{constraint}' blocks action: {action}",
+                    "constraint": constraint,
+                }
+
+    return {"allowed": True, "reason": "All constraints passed"}
+
+
+def link_ledger_item(task_id: str, ledger_item_id: str) -> Dict[str, Any]:
+    """Link a dispatched agent task to a ledger item (LED-xxx or STR-xxx).
+
+    This creates a bidirectional relationship so the dashboard can show
+    which agent is working on which ledger item.
+    """
+    if not task_id or not task_id.strip():
+        return {"error": "task_id is required"}
+    if not ledger_item_id or not ledger_item_id.strip():
+        return {"error": "ledger_item_id is required"}
+
+    task_id = task_id.strip().upper()
+    ledger_item_id = ledger_item_id.strip().upper()
+
+    tasks = _load_tasks()
+    if task_id not in tasks:
+        return {"error": f"Task {task_id} not found"}
+
+    task = tasks[task_id]
+    linked = task.get("linked_ledger_items", [])
+    if ledger_item_id not in linked:
+        linked.append(ledger_item_id)
+    task["linked_ledger_items"] = linked
+    task["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    tasks[task_id] = task
+    _save_tasks(tasks)
+
+    _append_audit({
+        "action": "link_ledger",
+        "task_id": task_id,
+        "ledger_item_id": ledger_item_id,
+    })
+
+    return {
+        "status": "linked",
+        "task_id": task_id,
+        "ledger_item_id": ledger_item_id,
+        "all_linked": linked,
+        "message": f"Task {task_id} linked to {ledger_item_id}",
+    }
+
+
+def get_agent_dashboard() -> Dict[str, Any]:
+    """Return a full dashboard view of all agent activity.
+
+    Groups tasks by status and assignee, includes audit trail summary,
+    and handoff history.
+    """
+    tasks = _load_tasks()
+
+    by_assignee: Dict[str, List[Dict]] = {}
+    by_status: Dict[str, int] = {}
+    handoff_count = 0
+
+    for t in tasks.values():
+        assignee = t.get("assignee", "unknown")
+        status = t.get("status", "unknown")
+        by_assignee.setdefault(assignee, []).append(t)
+        by_status[status] = by_status.get(status, 0) + 1
+        handoff_count += len(t.get("handoffs", []))
+
+    # Recent audit entries
+    recent_audit: List[Dict] = []
+    if AUDIT_FILE.exists():
+        try:
+            lines = AUDIT_FILE.read_text().strip().split("\n")
+            for line in lines[-20:]:
+                try:
+                    recent_audit.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass
+        except OSError:
+            pass
+
+    return {
+        "status": "ok",
+        "total_tasks": len(tasks),
+        "by_status": by_status,
+        "by_assignee": {
+            model: {
+                "total": len(model_tasks),
+                "active": sum(1 for t in model_tasks if t["status"] in ("dispatched", "in_progress", "handed_off")),
+                "done": sum(1 for t in model_tasks if t["status"] == "done"),
+                "tasks": [
+                    {"id": t["id"], "title": t["title"], "status": t["status"],
+                     "priority": t.get("priority", "P1"),
+                     "linked_ledger": t.get("linked_ledger_items", [])}
+                    for t in model_tasks
+                ],
+            }
+            for model, model_tasks in by_assignee.items()
+        },
+        "handoff_count": handoff_count,
+        "recent_audit": recent_audit,
+    }

package/gateway/ai/agent_policy.py

@@ -0,0 +1,230 @@
+"""Per-model policy scoping — agent-level governance.
+
+Allows setting different permissions per AI model:
+- Which tools each model can call
+- Read-only vs read-write access to ledger/memory
+- Deploy permissions per model
+- Custom constraints per agent identity
+
+Storage: ~/.delimit/agents/policies.json
+
+Feedback origin: Accurate_Mistake_398 on r/ClaudeAI (2026-03-28)
+identified that governance was session-level, not agent-level.
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+AGENTS_DIR = Path.home() / ".delimit" / "agents"
+POLICIES_FILE = AGENTS_DIR / "policies.json"
+
+# Default permissions — what each model gets if no policy is set
+DEFAULT_PERMISSIONS = {
+    "ledger": "read-write",
+    "memory": "read-write",
+    "deploy": False,
+    "lint": True,
+    "deliberate": True,
+    "security_audit": True,
+    "evidence": "read-write",
+    "secrets": False,
+}
+
+VALID_MODELS = {"claude", "codex", "gemini", "cursor", "any"}
+VALID_ACCESS = {"read-only", "read-write", "none"}
+
+
+def _ensure_dir():
+    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _load_policies() -> Dict[str, Any]:
+    if not POLICIES_FILE.exists():
+        return {}
+    try:
+        return json.loads(POLICIES_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save_policies(policies: Dict[str, Any]):
+    _ensure_dir()
+    POLICIES_FILE.write_text(json.dumps(policies, indent=2))
+
+
+def set_agent_policy(
+    model: str,
+    ledger: str = "",
+    memory: str = "",
+    deploy: Optional[bool] = None,
+    lint: Optional[bool] = None,
+    deliberate: Optional[bool] = None,
+    security_audit: Optional[bool] = None,
+    evidence: str = "",
+    secrets: Optional[bool] = None,
+    custom_constraints: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """Set permissions for a specific AI model.
+
+    Example: set_agent_policy("codex", ledger="read-only", deploy=False)
+    means Codex can read the ledger but not write, and cannot deploy.
+    """
+    model = model.lower().strip()
+    if model not in VALID_MODELS:
+        return {"error": f"model must be one of: {', '.join(sorted(VALID_MODELS))}"}
+
+    policies = _load_policies()
+    existing = policies.get(model, dict(DEFAULT_PERMISSIONS))
+
+    if ledger and ledger in VALID_ACCESS:
+        existing["ledger"] = ledger
+    if memory and memory in VALID_ACCESS:
+        existing["memory"] = memory
+    if evidence and evidence in VALID_ACCESS:
+        existing["evidence"] = evidence
+    if deploy is not None:
+        existing["deploy"] = deploy
+    if lint is not None:
+        existing["lint"] = lint
+    if deliberate is not None:
+        existing["deliberate"] = deliberate
+    if security_audit is not None:
+        existing["security_audit"] = security_audit
+    if secrets is not None:
+        existing["secrets"] = secrets
+    if custom_constraints is not None:
+        existing["custom_constraints"] = custom_constraints
+
+    existing["updated_at"] = time.strftime("%Y-%m-%dT%H:%M:%SZ")
+    policies[model] = existing
+    _save_policies(policies)
+
+    return {
+        "status": "updated",
+        "model": model,
+        "policy": existing,
+        "message": f"Policy updated for {model}",
+    }
+
+
+def get_agent_policy(model: str = "") -> Dict[str, Any]:
+    """Get permissions for a specific model, or all models."""
+    policies = _load_policies()
+
+    if not model or not model.strip():
+        # Return all policies with defaults filled in
+        all_policies = {}
+        for m in VALID_MODELS - {"any"}:
+            all_policies[m] = policies.get(m, dict(DEFAULT_PERMISSIONS))
+        return {
+            "status": "ok",
+            "policies": all_policies,
+            "default": DEFAULT_PERMISSIONS,
+        }
+
+    model = model.lower().strip()
+    if model not in VALID_MODELS:
+        return {"error": f"model must be one of: {', '.join(sorted(VALID_MODELS))}"}
+
+    policy = policies.get(model, dict(DEFAULT_PERMISSIONS))
+    return {
+        "status": "ok",
+        "model": model,
+        "policy": policy,
+        "is_default": model not in policies,
+    }
+
+
+def check_agent_permission(
+    model: str,
+    action: str,
+    resource: str = "",
+) -> Dict[str, Any]:
+    """Check if a model is allowed to perform an action.
+
+    Actions: ledger_write, ledger_read, memory_write, memory_read,
+             deploy, lint, deliberate, security_audit, evidence_write,
+             evidence_read, secrets_read, secrets_write.
+
+    Returns: {"allowed": bool, "reason": str}
+    """
+    model = model.lower().strip() if model else "any"
+    policies = _load_policies()
+    policy = policies.get(model, dict(DEFAULT_PERMISSIONS))
+
+    action = action.lower().strip()
+
+    # Parse action into category + operation
+    if "_" in action:
+        parts = action.split("_", 1)
+        category = parts[0]
+        operation = parts[1] if len(parts) > 1 else "read"
+    else:
+        category = action
+        operation = "read"
+
+    # Check access-level permissions (ledger, memory, evidence)
+    if category in ("ledger", "memory", "evidence"):
+        access = policy.get(category, "read-write")
+        if access == "none":
+            return {
+                "allowed": False,
+                "model": model,
+                "action": action,
+                "reason": f"{model} has no access to {category}",
+            }
+        if operation == "write" and access == "read-only":
+            return {
+                "allowed": False,
+                "model": model,
+                "action": action,
+                "reason": f"{model} has read-only access to {category}",
+            }
+        return {"allowed": True, "model": model, "action": action, "reason": "permitted"}
+
+    # Check boolean permissions (deploy, lint, etc.)
+    if category in ("deploy", "lint", "deliberate", "security_audit", "secrets"):
+        key = category.replace("security_", "security_")
+        allowed = policy.get(key, DEFAULT_PERMISSIONS.get(key, True))
+        if not allowed:
+            return {
+                "allowed": False,
+                "model": model,
+                "action": action,
+                "reason": f"{model} is not permitted to {category}",
+            }
+        return {"allowed": True, "model": model, "action": action, "reason": "permitted"}
+
+    # Check custom constraints
+    constraints = policy.get("custom_constraints", [])
+    for c in constraints:
+        c_lower = c.lower().strip()
+        if c_lower.startswith("no-") and c_lower[3:] in action:
+            return {
+                "allowed": False,
+                "model": model,
+                "action": action,
+                "reason": f"Custom constraint: {c}",
+            }
+
+    return {"allowed": True, "model": model, "action": action, "reason": "no restrictions"}
+
+
+def remove_agent_policy(model: str) -> Dict[str, Any]:
+    """Remove custom policy for a model, reverting to defaults."""
+    model = model.lower().strip()
+    policies = _load_policies()
+
+    if model not in policies:
+        return {"status": "ok", "message": f"No custom policy for {model} (already using defaults)"}
+
+    del policies[model]
+    _save_policies(policies)
+
+    return {
+        "status": "removed",
+        "model": model,
+        "message": f"Custom policy removed for {model}. Now using defaults.",
+    }