@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/mcp-config.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_SERVER_NAME = void 0;
+exports.buildLocalMcpServerEntry = buildLocalMcpServerEntry;
+exports.buildServerMcpServerEntry = buildServerMcpServerEntry;
+exports.mergeAgentbridgeIntoCursorMcp = mergeAgentbridgeIntoCursorMcp;
+exports.writeLocalMcpConfig = writeLocalMcpConfig;
+exports.writeServerMcpConfig = writeServerMcpConfig;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
+const mcp_runtime_1 = require("./mcp-runtime");
+exports.MCP_SERVER_NAME = "agentbridge";
+function buildLocalMcpServerEntry(cliDistDir) {
+    const runtime = (0, mcp_runtime_1.resolveMcpRuntime)(cliDistDir);
+    const repoRoot = (0, node_path_1.resolve)((0, node_process_1.cwd)());
+    const entry = runtime
+        ? { command: runtime.command, args: runtime.args }
+        : { command: "agentbridge", args: ["mcp"] };
+    entry.env = { AGENTBRIDGE_REPO_ROOT: repoRoot };
+    return entry;
+}
+function buildServerMcpServerEntry(projectId, apiKey, apiBaseUrl) {
+    return {
+        command: "agentbridge",
+        args: ["mcp"],
+        env: {
+            AGENTBRIDGE_PROJECT_ID: projectId,
+            AGENTBRIDGE_API_KEY: apiKey,
+            AGENTBRIDGE_BASE_URL: apiBaseUrl,
+            AGENTBRIDGE_REPO_ROOT: (0, node_path_1.resolve)((0, node_process_1.cwd)()),
+        },
+    };
+}
+/** Merge AgentBridge into project-level `.cursor/mcp.json` (preserves other servers). */
+function mergeAgentbridgeIntoCursorMcp(entry) {
+    const cursorDir = (0, node_path_1.join)((0, node_process_1.cwd)(), ".cursor");
+    const mcpPath = (0, node_path_1.join)(cursorDir, "mcp.json");
+    let existing = {};
+    if ((0, node_fs_1.existsSync)(mcpPath)) {
+        try {
+            existing = JSON.parse((0, node_fs_1.readFileSync)(mcpPath, "utf8"));
+        }
+        catch {
+            // Malformed file — start fresh
+        }
+    }
+    const mcpServers = existing.mcpServers && typeof existing.mcpServers === "object"
+        ? existing.mcpServers
+        : {};
+    mcpServers[exports.MCP_SERVER_NAME] = entry;
+    const updated = { ...existing, mcpServers };
+    if (!(0, node_fs_1.existsSync)(cursorDir)) {
+        (0, node_fs_1.mkdirSync)(cursorDir, { recursive: true });
+    }
+    (0, node_fs_1.writeFileSync)(mcpPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+    return mcpPath;
+}
+function writeLocalMcpConfig(cliDistDir) {
+    return mergeAgentbridgeIntoCursorMcp(buildLocalMcpServerEntry(cliDistDir));
+}
+function writeServerMcpConfig(projectId, apiKey, apiBaseUrl) {
+    return mergeAgentbridgeIntoCursorMcp(buildServerMcpServerEntry(projectId, apiKey, apiBaseUrl));
+}

package/dist/proof-parser.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Proof output parser — reads proofRun.stdoutExcerpt for structured test results.
+ * Supports vitest, jest, mocha. All logic is deterministic regex.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProofOutput = parseProofOutput;
+exports.proofEvidenceString = proofEvidenceString;
+const DOMAIN_TEST_KEYWORDS = {
+    auth: ["auth", "login", "logout", "session", "token", "password", "oauth", "signin", "signup"],
+    database: ["db", "database", "prisma", "migration", "schema", "query", "model"],
+    api: ["api", "route", "endpoint", "handler", "request", "response"],
+    payments: ["payment", "billing", "stripe", "invoice", "webhook", "subscription"],
+    mcp: ["mcp", "setup", "rules", "config", "agentbridge"],
+    ui: ["component", "render", "view", "style", "page", "layout"],
+    tests: ["test", "spec"],
+};
+// Vitest / Jest summary: "12 passed", "Tests: 5 passed", "5 failed"
+const PASSED_RE = /(\d+)\s+passed/i;
+const FAILED_RE = /(\d+)\s+failed/i;
+const SKIPPED_RE = /(\d+)\s+skipped/i;
+// Jest alternative: "Tests: 5 passed, 1 failed, 6 total"
+const JEST_SUMMARY_RE = /Tests:\s+(?:(\d+)\s+skipped,\s*)?(?:(\d+)\s+passed)?(?:,\s*(\d+)\s+failed)?/i;
+// Test name lines — vitest uses ✓/✗, jest uses ✓/×/✕, some use √
+const PASS_NAME_RE = /^\s*[✓√]\s+(.+)/;
+const FAIL_NAME_RE = /^\s*[✗×✕✘]\s+(.+)/;
+// Vitest detection: output contains "Test Files" or "Duration" or vitest version header
+const VITEST_DETECT_RE = /Test Files|vitest|v\d+\.\d+\.\d+.*vitest/i;
+// Jest detection
+const JEST_DETECT_RE = /PASS|FAIL|jest|Tests:/;
+// Mocha
+const MOCHA_DETECT_RE = /passing|failing|pending.*mocha/i;
+function detectRunner(stdout) {
+    if (VITEST_DETECT_RE.test(stdout))
+        return "vitest";
+    if (JEST_DETECT_RE.test(stdout))
+        return "jest";
+    if (MOCHA_DETECT_RE.test(stdout))
+        return "mocha";
+    return "unknown";
+}
+function extractDomainKeywords(testNames) {
+    const found = new Set();
+    const lower = testNames.join(" ").toLowerCase();
+    for (const [domain, keywords] of Object.entries(DOMAIN_TEST_KEYWORDS)) {
+        if (keywords.some((kw) => lower.includes(kw)))
+            found.add(domain);
+    }
+    return [...found];
+}
+function hasDomainCoverage(domain, domainKeywordsInPassed) {
+    const aliases = {
+        auth: ["auth"],
+        database: ["database"],
+        api: ["api"],
+        payments: ["payments"],
+        mcp: ["mcp"],
+        ui: ["ui"],
+    };
+    const check = aliases[domain] ?? [domain];
+    return check.some((alias) => domainKeywordsInPassed.includes(alias));
+}
+function parseProofOutput(proofRun) {
+    const stdout = proofRun.stdoutExcerpt ?? "";
+    const lines = stdout.split("\n");
+    const runner = detectRunner(stdout);
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const test_names_passed = [];
+    const test_names_failed = [];
+    for (const line of lines) {
+        // Count summary
+        const pm = PASSED_RE.exec(line);
+        if (pm)
+            passed = Math.max(passed, parseInt(pm[1], 10));
+        const fm = FAILED_RE.exec(line);
+        if (fm)
+            failed = Math.max(failed, parseInt(fm[1], 10));
+        const sm = SKIPPED_RE.exec(line);
+        if (sm)
+            skipped = Math.max(skipped, parseInt(sm[1], 10));
+        // Named test lines
+        const passName = PASS_NAME_RE.exec(line);
+        if (passName)
+            test_names_passed.push(passName[1].trim());
+        const failName = FAIL_NAME_RE.exec(line);
+        if (failName)
+            test_names_failed.push(failName[1].trim());
+    }
+    const domain_keywords_in_passed = extractDomainKeywords(test_names_passed);
+    return {
+        runner,
+        passed,
+        failed,
+        skipped,
+        test_names_passed,
+        test_names_failed,
+        domain_keywords_in_passed,
+        has_domain_coverage: (domain) => hasDomainCoverage(domain, domain_keywords_in_passed),
+    };
+}
+/**
+ * Builds a human-readable evidence string from a parsed proof, for use in criterion evaluation.
+ */
+function proofEvidenceString(parsed, domain) {
+    const total = parsed.passed + parsed.failed + parsed.skipped;
+    const base = `Proof run ${parsed.failed > 0 ? "failed" : "passed"} (${parsed.passed}/${total} tests passed).`;
+    if (domain && parsed.passed > 0) {
+        if (parsed.has_domain_coverage(domain)) {
+            const covering = parsed.domain_keywords_in_passed.join(", ");
+            return `${base} Tests covering: ${covering}.`;
+        }
+        const keywords = DOMAIN_TEST_KEYWORDS[domain]?.slice(0, 3).join(", ") ?? domain;
+        return `${base} No passed tests mention ${keywords} — domain coverage unconfirmed.`;
+    }
+    return base;
+}

package/dist/session-state.js

@@ -130,6 +130,21 @@ function isLocalSessionState(value) {
         return false;
     if (value.claimedPaths !== undefined && !isStringArray(value.claimedPaths))
         return false;
+    if (value.createdBy !== undefined && value.createdBy !== "user_start" && value.createdBy !== "agent_hello") {
+        return false;
+    }
+    if (value.contractProfiles !== undefined && !isStringArray(value.contractProfiles))
+        return false;
+    if (value.expectedSurfaces !== undefined && !isStringArray(value.expectedSurfaces))
+        return false;
+    if (value.expectedFileAreas !== undefined && !isStringArray(value.expectedFileAreas))
+        return false;
+    if (value.completionCriteria !== undefined && !isStringArray(value.completionCriteria))
+        return false;
+    if (value.proofNeeded !== undefined && !isStringArray(value.proofNeeded))
+        return false;
+    if (value.riskyOmissions !== undefined && !isStringArray(value.riskyOmissions))
+        return false;
     if (value.lastLocalVerificationRun !== undefined &&
         !(0, local_proof_1.isLocalVerificationRun)(value.lastLocalVerificationRun)) {
         return false;

package/dist/session.js

@@ -6,6 +6,7 @@ exports.openLocalSession = openLocalSession;
 exports.closeLocalSession = closeLocalSession;
 const node_child_process_1 = require("node:child_process");
 const http_1 = require("./http");
+const contract_intelligence_1 = require("./contract-intelligence");
 const session_state_1 = require("./session-state");
 const watch_core_1 = require("./watch-core");
 const file_fingerprints_1 = require("./file-fingerprints");
@@ -54,11 +55,20 @@ function openLocalSession(input) {
     const claimedPaths = [...new Set((input.claimedPaths ?? []).map((path) => path.trim()).filter(Boolean))];
     const baseline = captureLocalSessionBaseline();
     const now = baseline.startedAt;
+    const createdBy = input.createdBy ?? (input.agentId?.trim() === "local" ? "user_start" : "agent_hello");
+    const contract = (0, contract_intelligence_1.buildContractIntelligence)(input.intent?.trim(), createdBy);
     const state = {
         id: `local_${Date.now().toString(36)}`,
         agentId: input.agentId?.trim() || "local",
         laneDomain: input.laneDomain,
         intent: input.intent?.trim() || undefined,
+        createdBy,
+        contractProfiles: contract.contractProfiles,
+        expectedSurfaces: contract.expectedSurfaces,
+        expectedFileAreas: contract.expectedFileAreas,
+        completionCriteria: contract.completionCriteria,
+        proofNeeded: contract.proofNeeded,
+        riskyOmissions: contract.riskyOmissions,
         mode: input.mode,
         changeRequestId: input.changeRequestId,
         claimedPaths,

package/dist/supervision.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.STALE_MCP_ACTIVITY_MINUTES = void 0;
+exports.resolveWatchStartupSupervision = resolveWatchStartupSupervision;
+exports.computeMcpActivityStaleMinutes = computeMcpActivityStaleMinutes;
+exports.effectiveWatchSupervisionStatus = effectiveWatchSupervisionStatus;
+exports.buildWatchSupervisionRenderContext = buildWatchSupervisionRenderContext;
 exports.inferSupervisionWorkType = inferSupervisionWorkType;
 exports.requiredProofHints = requiredProofHints;
 exports.computeScopeDriftAlerts = computeScopeDriftAlerts;
@@ -8,10 +13,113 @@ exports.fallbackSupervisionSnapshot = fallbackSupervisionSnapshot;
 exports.enrichSupervisionWithLocalState = enrichSupervisionWithLocalState;
 exports.supervisionSignature = supervisionSignature;
 exports.renderSupervisionSummary = renderSupervisionSummary;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const claimed_paths_1 = require("./claimed-paths");
 const domain_resolution_1 = require("./domain-resolution");
 const preflight_changed_files_1 = require("./preflight-changed-files");
 const memory_context_render_1 = require("./memory-context-render");
+/** Minutes without MCP activity before watch downgrades READY → DEGRADED. */
+exports.STALE_MCP_ACTIVITY_MINUTES = 15;
+function readWatchMcpConfig(workspaceRoot) {
+    const mcpConfigPath = (0, node_path_1.resolve)(workspaceRoot, ".cursor", "mcp.json");
+    if (!(0, node_fs_1.existsSync)(mcpConfigPath)) {
+        return { configured: false, projectId: null };
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(mcpConfigPath, "utf8"));
+        const entry = parsed?.mcpServers?.["agentbridge"] ?? parsed?.mcpServers?.["agentbridge-mcp"];
+        return {
+            configured: Boolean(entry),
+            projectId: entry?.env?.AGENTBRIDGE_PROJECT_ID ?? null,
+        };
+    }
+    catch {
+        return { configured: false, projectId: null };
+    }
+}
+function watchRulesInstalled(workspaceRoot) {
+    return ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(workspaceRoot, "AGENTBRIDGE.md")) ||
+        (0, node_fs_1.existsSync)((0, node_path_1.resolve)(workspaceRoot, ".cursor", "rules", "agentbridge.mdc")));
+}
+/** Startup decision tree for watch's four-state supervision model. */
+function resolveWatchStartupSupervision(input) {
+    const mcp = readWatchMcpConfig(input.workspaceRoot);
+    const rulesInstalled = watchRulesInstalled(input.workspaceRoot);
+    const credentialMismatch = mcp.configured && mcp.projectId !== null && input.cliProjectId !== undefined
+        ? mcp.projectId !== input.cliProjectId
+        : false;
+    const base = {
+        mcpConfigured: mcp.configured,
+        rulesInstalled,
+        mcpProjectId: mcp.projectId,
+        credentialMismatch,
+    };
+    if (credentialMismatch) {
+        return {
+            ...base,
+            supervisionStatus: "broken",
+            warningBanner: "\n⚠  SUPERVISION BROKEN: CLI and MCP are using different project identities.\n" +
+                `   CLI project id: ${input.cliProjectId ?? "?"}\n` +
+                `   MCP project id: ${mcp.projectId ?? "?"}\n` +
+                "   watch cannot reliably correlate CLI sessions with MCP evidence.\n" +
+                "   Fix: run `agentbridge connect` to re-write the MCP config with the correct credentials.\n",
+        };
+    }
+    if (!mcp.configured && !rulesInstalled) {
+        return {
+            ...base,
+            supervisionStatus: "blind",
+            warningBanner: "\n⚠  SUPERVISION BLIND: MCP is not configured and no AgentBridge rules are installed.\n" +
+                "   watch can observe filesystem changes only — agent actions inside Cursor are invisible.\n" +
+                "   Fix: run `agentbridge connect` to configure MCP and install rules automatically.\n",
+        };
+    }
+    if (!mcp.configured) {
+        return {
+            ...base,
+            supervisionStatus: "degraded",
+            warningBanner: "\n⚠  SUPERVISION DEGRADED: MCP is not configured.\n" +
+                "   watch cannot see MCP-recorded evidence, implementation packets, or agent tool usage.\n" +
+                "   Fix: run `agentbridge connect` or `agentbridge setup-mcp` then restart Cursor.\n",
+        };
+    }
+    if (!rulesInstalled) {
+        return {
+            ...base,
+            supervisionStatus: "degraded",
+            warningBanner: "\n⚠  SUPERVISION DEGRADED: AgentBridge rules are not installed in this project.\n" +
+                "   The agent is not operating under AgentBridge protocol — no task discipline enforced.\n" +
+                "   Fix: run `agentbridge install-rules` to add rules to this project.\n",
+        };
+    }
+    return { ...base, supervisionStatus: "ready" };
+}
+function computeMcpActivityStaleMinutes(updatedAt, nowMs = Date.now()) {
+    if (updatedAt == null)
+        return undefined;
+    const updatedMs = new Date(updatedAt).getTime();
+    if (Number.isNaN(updatedMs))
+        return undefined;
+    return Math.floor((nowMs - updatedMs) / 60_000);
+}
+function effectiveWatchSupervisionStatus(baseStatus, mcpConfigured, mcpActivityStaleMinutes) {
+    if (baseStatus === "ready" &&
+        mcpConfigured &&
+        mcpActivityStaleMinutes != null &&
+        mcpActivityStaleMinutes > exports.STALE_MCP_ACTIVITY_MINUTES) {
+        return "degraded";
+    }
+    return baseStatus;
+}
+function buildWatchSupervisionRenderContext(input) {
+    const mcpActivityStaleMinutes = computeMcpActivityStaleMinutes(input.agentDeclaredUpdatedAt, input.nowMs);
+    return {
+        supervisionStatus: effectiveWatchSupervisionStatus(input.baseStatus, input.mcpConfigured, mcpActivityStaleMinutes),
+        mcpConfigured: input.mcpConfigured,
+        mcpActivityStaleMinutes,
+    };
+}
 const CLI_GIT_REQUIRED_PROOF = [
     "tracked modified file handled",
     "untracked new file handled",
@@ -28,6 +136,20 @@ function inferSupervisionWorkType(changedFiles) {
     if (changedFiles.length === 0)
         return "unknown";
     const lower = changedFiles.map((file) => file.toLowerCase());
+    const isUiSurfaceFile = (file) => {
+        if (file.endsWith(".html") ||
+            file.endsWith(".css") ||
+            file.endsWith(".scss") ||
+            file.endsWith(".sass") ||
+            file.endsWith(".less") ||
+            file.endsWith(".tsx") ||
+            file.endsWith(".jsx")) {
+            return true;
+        }
+        // Keep this narrow: only treat plain .ts/.js as UI when clearly in public assets.
+        return ((file.endsWith(".ts") || file.endsWith(".js")) &&
+            (file.startsWith("src/public/") || file.includes("/public/")));
+    };
     const cliSignal = lower.some((file) => file.includes("cli/src/") &&
         (file.includes("watch") || file.includes("precommit") || file.includes("revert-crossing")));
     if (cliSignal)
@@ -35,6 +157,9 @@ function inferSupervisionWorkType(changedFiles) {
     const docsOnly = lower.every((file) => file.startsWith("docs/") || file.endsWith(".md") || file.endsWith(".mdx") || file.includes("/docs/"));
     if (docsOnly)
         return "documentation";
+    const uiSurfaceOnly = lower.every(isUiSurfaceFile);
+    if (uiSurfaceOnly)
+        return "ui_copy";
     return "general";
 }
 function requiredProofHints(workType) {
@@ -42,6 +167,12 @@ function requiredProofHints(workType) {
         return [...CLI_GIT_REQUIRED_PROOF];
     if (workType === "documentation")
         return ["explicit verification evidence for changed docs/files"];
+    if (workType === "ui_copy") {
+        return [
+            "visual confirmation/screenshot of updated UI copy",
+            "optional quick smoke command: agentbridge verify -- npm run build",
+        ];
+    }
     return [
         "explicit verification evidence for changed files",
         "run agentbridge verify, then rerun agentbridge watch",
@@ -210,7 +341,7 @@ function enrichSupervisionWithLocalState(state, supervision) {
                 : supervision.scopeStatus,
     };
 }
-function supervisionSignature(snapshot) {
+function supervisionSignature(snapshot, renderContext) {
     return JSON.stringify({
         workSessionId: snapshot.workSessionId,
         changedFiles: snapshot.changedFiles,
@@ -225,52 +356,81 @@ function supervisionSignature(snapshot) {
             ? `${snapshot.agentDeclared.intent ?? ""}:${snapshot.agentDeclared.lastEvent ?? ""}`
             : "",
         declaredDrift: snapshot.declaredDriftFiles?.join(",") ?? "",
+        supervisionStatus: renderContext?.supervisionStatus ?? "",
+        mcpConfigured: renderContext?.mcpConfigured ?? false,
+        mcpActivityStale: renderContext?.mcpActivityStaleMinutes != null
+            ? renderContext.mcpActivityStaleMinutes > exports.STALE_MCP_ACTIVITY_MINUTES
+            : false,
     });
 }
+const SUPERVISION_STATUS_LABEL = {
+    ready: "✓ READY",
+    degraded: "⚠ DEGRADED",
+    blind: "⚠ BLIND",
+    broken: "✗ BROKEN",
+};
 function renderSupervisionSummary(snapshot, options) {
     const lines = [];
-    lines.push(options?.compact ? "AgentBridge watch:" : "AgentBridge supervision:");
+    lines.push("AgentBridge watch:");
+    lines.push("");
+    lines.push("1) Actions performed");
+    lines.push(`- Reviewed ${snapshot.changedFiles.length} changed file(s)`);
+    lines.push(`- Work type detected: ${snapshot.workType}`);
+    lines.push(`- Scope status: ${snapshot.scopeStatus}`);
+    lines.push(`- Boundary status: ${snapshot.boundaryStatus}`);
+    lines.push(`- Files (disk): ${snapshot.diskObserved?.postBaselineFiles.length ?? snapshot.changedFiles.length} changed since session start`);
     if (!options?.compact) {
-        lines.push(`Current run: ${snapshot.workSessionId}${snapshot.changeRequestId ? ` / task ${snapshot.changeRequestId}` : ""}`);
+        lines.push(`- Active run: ${snapshot.workSessionId}${snapshot.changeRequestId ? ` (task ${snapshot.changeRequestId})` : ""}`);
+    }
+    if (options?.supervisionStatus) {
+        lines.push(`- Supervision: ${SUPERVISION_STATUS_LABEL[options.supervisionStatus] ?? options.supervisionStatus}`);
     }
     const declared = snapshot.agentDeclared;
     if (declared) {
         const intentLabel = declared.intent?.trim() || declared.summary?.trim() || "(no intent text)";
-        const eventSuffix = declared.lastEvent && declared.updatedAt
-            ? ` [${declared.lastEvent} @ ${formatMcpEventTime(declared.updatedAt)}]`
-            : declared.lastEvent
-                ? ` [${declared.lastEvent}]`
-                : "";
-        lines.push(`Agent (MCP): ${intentLabel}${eventSuffix}`);
+        lines.push(`- Agent (MCP): ${intentLabel}`);
         if (declared.claimedPaths.length > 0) {
             const scopePreview = declared.claimedPaths.length > 6
                 ? `${declared.claimedPaths.slice(0, 6).join(", ")} (+${declared.claimedPaths.length - 6} more)`
                 : declared.claimedPaths.join(", ");
-            lines.push(`Declared scope: ${scopePreview}`);
-        }
-        else {
-            lines.push("Declared scope: (none yet)");
+            lines.push(`- Declared scope: ${scopePreview}`);
         }
     }
-    const diskCount = snapshot.diskObserved?.postBaselineFiles.length ?? snapshot.changedFiles.length;
-    lines.push(`Files (disk): ${diskCount} changed since session start`);
-    if (snapshot.declaredVsObservedDrift === "warn" && snapshot.declaredDriftFiles?.length) {
-        const preview = snapshot.declaredDriftFiles.length > 4
-            ? `${snapshot.declaredDriftFiles.slice(0, 4).join(", ")} (+${snapshot.declaredDriftFiles.length - 4} more)`
-            : snapshot.declaredDriftFiles.join(", ");
-        lines.push(`Note: ${snapshot.declaredDriftFiles.length} file(s) outside declared scope (${preview}) — warn only, not blocked`);
+    else if (options?.mcpConfigured) {
+        lines.push("- Agent (MCP): not yet active");
+    }
+    lines.push(`- Changed files: ${snapshot.changedFiles.length}`);
+    lines.push("");
+    lines.push("2) Proof present / missing");
+    if (snapshot.decision === "accepted") {
+        lines.push("- Present: proof accepted for current changes");
+    }
+    else if (snapshot.serverAcceptanceUnavailable) {
+        lines.push(`- Unknown: proof check unavailable (${snapshot.serverAcceptanceUnavailable})`);
+    }
+    else {
+        lines.push(`- Missing/blocked: watch result is ${snapshot.decision}`);
     }
-    lines.push(`Changed files: ${snapshot.changedFiles.length}`);
-    lines.push(`Detected work type: ${snapshot.workType}`);
-    lines.push(`Scope: ${snapshot.scopeStatus}`);
-    lines.push(`Boundary: ${snapshot.boundaryStatus}`);
-    lines.push(`Watch result: ${snapshot.decision}`);
     if (snapshot.requiredProof.length > 0) {
-        lines.push("");
-        lines.push("Likely required proof:");
-        for (const proof of snapshot.requiredProof) {
-            lines.push(`- ${proof}`);
-        }
+        lines.push(`- Still needed: ${snapshot.requiredProof.slice(0, 3).join("; ")}`);
+    }
+    if (snapshot.declaredVsObservedDrift === "warn" && snapshot.declaredDriftFiles?.length) {
+        lines.push(`- Scope warning: ${snapshot.declaredDriftFiles.length} file(s) appear outside declared scope`);
+        lines.push("- Note: warn only, not blocked");
+    }
+    if (snapshot.serverAcceptanceUnavailable) {
+        lines.push(`- Watch result unavailable: ${snapshot.serverAcceptanceUnavailable}`);
+    }
+    lines.push("");
+    lines.push("3) Next move");
+    lines.push(`- ${snapshot.nextAction}`);
+    if (snapshot.driftAlerts.length > 0) {
+        lines.push("- Resolve out-of-scope files or explicitly update scope before continuing");
+    }
+    if (options?.mcpActivityStaleMinutes != null &&
+        options.mcpActivityStaleMinutes > exports.STALE_MCP_ACTIVITY_MINUTES) {
+        lines.push("- Reconnect or wake MCP activity so supervision returns to ready state");
+        lines.push(`- MCP activity stale — last update ${options.mcpActivityStaleMinutes}m ago`);
     }
     if (snapshot.knownTraps.length > 0) {
         lines.push("");
@@ -282,25 +442,8 @@ function renderSupervisionSummary(snapshot, options) {
     const watchMemoryLines = (0, memory_context_render_1.renderWatchMemoryContext)(snapshot.memoryContext);
     if (watchMemoryLines.length > 0) {
         lines.push("");
+        lines.push("Context:");
         lines.push(...watchMemoryLines);
     }
-    if (snapshot.driftAlerts.length > 0) {
-        for (const alert of snapshot.driftAlerts) {
-            lines.push("");
-            lines.push("Files outside scope detected:");
-            lines.push(`- file: ${alert.file}`);
-            lines.push(`- claimed paths: [${alert.claimedPaths.join(", ")}]`);
-            lines.push(`- likely domain: ${alert.likelyDomain}`);
-            lines.push(`- severity: ${alert.severity}`);
-            lines.push("- suggested action: update scope or confirm this belongs to the current work");
-        }
-    }
-    if (snapshot.serverAcceptanceUnavailable) {
-        lines.push("");
-        lines.push(`Watch result unavailable: ${snapshot.serverAcceptanceUnavailable}`);
-    }
-    lines.push("");
-    lines.push("Before saying done:");
-    lines.push(`- ${snapshot.nextAction}`);
     return lines.join("\n");
 }