@agentbridge1/cli 0.0.6 → 0.0.8

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/rules-sync.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_RULES_MARKER = exports.LOCAL_RULES_HEADER = void 0;
+exports.rulesArtifactPaths = rulesArtifactPaths;
+exports.extractProjectIdFromRulesText = extractProjectIdFromRulesText;
+exports.classifyRulesFormat = classifyRulesFormat;
+exports.analyzeRulesArtifacts = analyzeRulesArtifacts;
+exports.fetchProjectRules = fetchProjectRules;
+exports.writeRulesFiles = writeRulesFiles;
+exports.markProjectRulesInstalled = markProjectRulesInstalled;
+exports.extractProjectNameFromRulesResponse = extractProjectNameFromRulesResponse;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const http_1 = require("./http");
+exports.LOCAL_RULES_HEADER = "# AgentBridge Local Rules";
+exports.PROTOCOL_RULES_MARKER = "This repo is coordinated through AgentBridge";
+function rulesArtifactPaths(workspaceRoot) {
+    return {
+        rulesMarkdownPath: (0, node_path_1.resolve)(workspaceRoot, "AGENTBRIDGE.md"),
+        rulesMdcPath: (0, node_path_1.resolve)(workspaceRoot, ".cursor", "rules", "agentbridge.mdc"),
+    };
+}
+function extractProjectIdFromRulesText(content) {
+    const markdownMatch = content.match(/\*\*Project ID:\*\*\s*`([^`]+)`/);
+    if (markdownMatch?.[1]) {
+        return markdownMatch[1].trim();
+    }
+    const inlineMatch = content.match(/project ID:\s*`([^`]+)`/i);
+    if (inlineMatch?.[1]) {
+        return inlineMatch[1].trim();
+    }
+    return null;
+}
+function classifyRulesFormat(markdownContent, mdcContent) {
+    const md = markdownContent ?? "";
+    const mdc = mdcContent ?? "";
+    if (!md.trim() && !mdc.trim()) {
+        return "missing";
+    }
+    if (md.startsWith(exports.LOCAL_RULES_HEADER) || mdc.includes("Recovered domains:")) {
+        return "local";
+    }
+    if (md.includes(exports.PROTOCOL_RULES_MARKER) ||
+        mdc.includes("AgentBridge Protocol Rules") ||
+        mdc.includes("AgentBridge protocol rules")) {
+        return "protocol";
+    }
+    return "unknown";
+}
+function readOptionalFile(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    return (0, node_fs_1.readFileSync)(path, "utf8");
+}
+function analyzeRulesArtifacts(workspaceRoot, expectedProjectId) {
+    const paths = rulesArtifactPaths(workspaceRoot);
+    const markdownContent = readOptionalFile(paths.rulesMarkdownPath);
+    const mdcContent = readOptionalFile(paths.rulesMdcPath);
+    const filesPresent = markdownContent !== null && mdcContent !== null;
+    const format = classifyRulesFormat(markdownContent, mdcContent);
+    const projectIds = new Set();
+    if (markdownContent) {
+        const id = extractProjectIdFromRulesText(markdownContent);
+        if (id)
+            projectIds.add(id);
+    }
+    if (mdcContent) {
+        const id = extractProjectIdFromRulesText(mdcContent);
+        if (id)
+            projectIds.add(id);
+    }
+    const issues = [];
+    let projectIdInRepo = null;
+    if (projectIds.size === 1) {
+        projectIdInRepo = [...projectIds][0] ?? null;
+    }
+    else if (projectIds.size > 1) {
+        issues.push("AGENTBRIDGE.md and .cursor/rules/agentbridge.mdc reference different project IDs.");
+        projectIdInRepo = [...projectIds][0] ?? null;
+    }
+    else if (filesPresent) {
+        issues.push("Rules files are present but no project ID could be parsed.");
+    }
+    let projectIdMatchesConfig = null;
+    if (expectedProjectId) {
+        if (projectIdInRepo) {
+            projectIdMatchesConfig = projectIdInRepo === expectedProjectId;
+            if (!projectIdMatchesConfig) {
+                issues.push(`Rules reference project ${projectIdInRepo}, but configured project is ${expectedProjectId}.`);
+            }
+        }
+        else if (filesPresent) {
+            projectIdMatchesConfig = false;
+        }
+    }
+    if (!filesPresent) {
+        issues.push("Missing AGENTBRIDGE.md or .cursor/rules/agentbridge.mdc.");
+    }
+    else if (format === "local") {
+        issues.push("Rules are in local watch format (from agentbridge init), not server protocol rules.");
+    }
+    else if (format === "unknown") {
+        issues.push("Rules files exist but do not match the expected AgentBridge protocol format.");
+    }
+    const protocolRulesValid = filesPresent &&
+        format === "protocol" &&
+        (projectIdMatchesConfig ?? true) &&
+        issues.length === 0;
+    return {
+        paths,
+        filesPresent,
+        format,
+        projectIdInRepo,
+        projectIdMatchesConfig,
+        protocolRulesValid,
+        issues,
+    };
+}
+async function fetchProjectRules(ctx) {
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/rules`);
+}
+function writeRulesFiles(workspaceRoot, files) {
+    for (const file of files) {
+        const fullPath = (0, node_path_1.resolve)(workspaceRoot, file.path);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(fullPath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(fullPath, file.content, "utf8");
+    }
+}
+async function markProjectRulesInstalled(ctx) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/rules/mark-installed`, {});
+}
+function extractProjectNameFromRulesResponse(files) {
+    const markdown = files.find((file) => file.path === "AGENTBRIDGE.md")?.content;
+    if (!markdown)
+        return null;
+    const match = markdown.match(/^# AgentBridge — (.+)$/m);
+    return match?.[1]?.trim() ?? null;
+}

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");
 }