@agentbridge1/cli 0.0.7 → 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/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");
 }

package/dist/test-runner.js

@@ -1,44 +1,152 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectTestCommand = detectTestCommand;
+exports.buildScopedCommand = buildScopedCommand;
+exports.extractFailedTestNames = extractFailedTestNames;
 exports.runDetectedTests = runDetectedTests;
+exports.extractIntentKeywords = extractIntentKeywords;
+exports.tokenizePath = tokenizePath;
+exports.analyzeCoherence = analyzeCoherence;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
+/**
+ * Detect the appropriate test command for the project rooted at `cwd`.
+ * Checks config override first, then language-specific conventions.
+ */
 function detectTestCommand(cwd = process.cwd()) {
+    // 1. Check .agentbridge.json for an explicit verify.command override
+    const abConfigPath = (0, node_path_1.resolve)(cwd, ".agentbridge.json");
+    if ((0, node_fs_1.existsSync)(abConfigPath)) {
+        try {
+            const cfg = JSON.parse((0, node_fs_1.readFileSync)(abConfigPath, "utf8"));
+            if (cfg.verify?.command)
+                return cfg.verify.command;
+        }
+        catch {
+            // malformed config — fall through
+        }
+    }
+    // 2. Node / npm — prefer test:unit for speed
     const packageJsonPath = (0, node_path_1.resolve)(cwd, "package.json");
-    if (!(0, node_fs_1.existsSync)(packageJsonPath))
-        return null;
-    const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
-    if (!pkg.scripts)
-        return null;
-    if (pkg.scripts["test:unit"])
-        return "npm run test:unit";
-    if (pkg.scripts.test)
-        return "npm run test";
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+            if (pkg.scripts?.["test:unit"])
+                return "npm run test:unit";
+            if (pkg.scripts?.["test"])
+                return "npm run test";
+        }
+        catch {
+            // malformed package.json — fall through
+        }
+    }
+    // 3. Python
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "pytest.ini")) || (0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "pyproject.toml"))) {
+        return "pytest";
+    }
+    // 4. Rust
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "Cargo.toml"))) {
+        return "cargo test";
+    }
+    // 5. Go
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, "go.mod"))) {
+        return "go test ./...";
+    }
+    // 6. Makefile with a `test` target
+    const makefilePath = (0, node_path_1.resolve)(cwd, "Makefile");
+    if ((0, node_fs_1.existsSync)(makefilePath)) {
+        try {
+            const contents = (0, node_fs_1.readFileSync)(makefilePath, "utf8");
+            if (/^test:/m.test(contents))
+                return "make test";
+        }
+        catch {
+            // unreadable Makefile — fall through
+        }
+    }
     return null;
 }
-async function runDetectedTests(timeoutMs = 5 * 60 * 1000) {
-    const command = detectTestCommand();
-    if (!command)
+/**
+ * Build a scoped version of the base command that only runs tests related to
+ * the provided files. Falls back to the full command if scoping is not
+ * supported for the detected runner.
+ */
+function buildScopedCommand(base, relatedFiles) {
+    if (!relatedFiles.length)
+        return base;
+    // vitest / jest both support --testPathPattern (regex)
+    if (/vitest|jest/.test(base)) {
+        // Build a pattern that matches the test files corresponding to the changed source files.
+        // e.g. "src/foo.ts" → look for "src/foo" anywhere in test paths.
+        const stems = relatedFiles.map((f) => f.replace(/\.[^/.]+$/, "").replace(/\//g, "\\/"));
+        const pattern = stems.join("|");
+        return `${base} --testPathPattern="${pattern}"`;
+    }
+    // pytest supports positional file/dir args (best effort)
+    if (base.startsWith("pytest")) {
+        const pyFiles = relatedFiles
+            .map((f) => f.replace(/\.ts$/, ".py"))
+            .filter((f) => (0, node_fs_1.existsSync)(f));
+        if (pyFiles.length)
+            return `${base} ${pyFiles.join(" ")}`;
+    }
+    // Everything else: full run
+    return base;
+}
+/**
+ * Extract failed test names from stdout/stderr output of vitest, jest, or pytest.
+ */
+function extractFailedTestNames(output) {
+    const lines = [];
+    for (const line of output.split("\n")) {
+        const trimmed = line.trim();
+        // vitest / jest: lines starting with × or ✗ or containing "● " (jest describe block)
+        if (/^[×✗]/.test(trimmed) || /^\s*●\s+/.test(line)) {
+            lines.push(trimmed.replace(/^[×✗●\s]+/, "").trim());
+            continue;
+        }
+        // pytest: lines like "FAILED src/foo_test.py::test_name"
+        if (/^FAILED\s+/.test(trimmed)) {
+            lines.push(trimmed.replace(/^FAILED\s+/, "").trim());
+        }
+    }
+    return [...new Set(lines)].filter(Boolean).slice(0, 10);
+}
+/**
+ * Run the detected (or configured) test suite and return the result.
+ * Returns null if no test command could be detected.
+ */
+async function runDetectedTests(optionsOrTimeout = {}) {
+    // Accept the legacy `timeoutMs` number signature for backwards compatibility.
+    const options = typeof optionsOrTimeout === "number" ? { timeoutMs: optionsOrTimeout } : optionsOrTimeout;
+    const cwd = options.cwd ?? process.cwd();
+    const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
+    const baseCommand = detectTestCommand(cwd);
+    if (!baseCommand)
         return null;
+    const command = options.relatedFiles?.length
+        ? buildScopedCommand(baseCommand, options.relatedFiles)
+        : baseCommand;
     const started = Date.now();
     return new Promise((resolveResult) => {
         const child = (0, node_child_process_1.spawn)(command, {
             shell: true,
-            cwd: process.cwd(),
+            cwd,
             env: process.env,
             stdio: ["ignore", "pipe", "pipe"],
         });
         let stdout = "";
         let stderr = "";
+        let didTimeout = false;
         child.stdout?.on("data", (chunk) => {
             stdout += chunk.toString();
         });
         child.stderr?.on("data", (chunk) => {
             stderr += chunk.toString();
         });
-        const timeout = setTimeout(() => {
+        const timer = setTimeout(() => {
+            didTimeout = true;
             child.kill("SIGTERM");
             resolveResult({
                 command,
@@ -46,17 +154,95 @@ async function runDetectedTests(timeoutMs = 5 * 60 * 1000) {
                 stdout,
                 stderr: `${stderr}\nTimed out after ${timeoutMs}ms`,
                 durationMs: Date.now() - started,
+                timedOut: true,
             });
         }, timeoutMs);
         child.on("close", (code) => {
-            clearTimeout(timeout);
+            clearTimeout(timer);
+            if (didTimeout)
+                return; // already resolved
             resolveResult({
                 command,
                 passed: code === 0,
                 stdout,
                 stderr,
                 durationMs: Date.now() - started,
+                timedOut: false,
             });
         });
     });
 }
+/** Common English stop words to strip from intent before keyword extraction. */
+const STOP_WORDS = new Set([
+    "a", "an", "the", "and", "or", "of", "to", "in", "for", "on", "with",
+    "at", "by", "from", "as", "is", "was", "are", "were", "be", "been",
+    "it", "this", "that", "these", "those", "we", "i", "you", "they",
+    "add", "fix", "update", "change", "make", "get", "set", "use",
+    "all", "some", "any", "new", "old", "via", "into", "also", "should",
+]);
+/**
+ * Extract meaningful tokens from an intent string.
+ * Splits on non-alphanumeric characters and removes stop words.
+ */
+function extractIntentKeywords(intent) {
+    return intent
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+}
+/**
+ * Extract tokens from a file path (useful for overlap scoring).
+ * e.g. "src/middleware/userAuth.ts" → ["src","middleware","userauth","ts"]
+ */
+function tokenizePath(filePath) {
+    return filePath
+        .toLowerCase()
+        .split(/[/\\._\-]+/)
+        .filter((t) => t.length >= 2);
+}
+/**
+ * Analyse whether the changed files are coherent with the declared intent.
+ * Returns a CoherenceResult with a verdict and list of suspicious files.
+ *
+ * Does NOT require an LLM — purely keyword/token overlap heuristics.
+ */
+function analyzeCoherence(ctx) {
+    const { intent, changedFiles } = ctx;
+    if (!intent || intent.trim().length === 0) {
+        return {
+            score: 0,
+            suspiciousFiles: [],
+            intentKeywords: [],
+            verdict: "unknown",
+        };
+    }
+    const intentKeywords = extractIntentKeywords(intent);
+    if (intentKeywords.length === 0) {
+        return {
+            score: 0,
+            suspiciousFiles: [],
+            intentKeywords: [],
+            verdict: "unknown",
+        };
+    }
+    if (changedFiles.length === 0) {
+        return {
+            score: 1,
+            suspiciousFiles: [],
+            intentKeywords,
+            verdict: "coherent",
+        };
+    }
+    const suspiciousFiles = [];
+    for (const file of changedFiles) {
+        const pathTokens = tokenizePath(file);
+        const hasOverlap = intentKeywords.some((kw) => pathTokens.some((pt) => pt.includes(kw) || kw.includes(pt)));
+        if (!hasOverlap) {
+            suspiciousFiles.push(file);
+        }
+    }
+    const score = (changedFiles.length - suspiciousFiles.length) / changedFiles.length;
+    const driftThreshold = 0.4;
+    const verdict = suspiciousFiles.length / changedFiles.length > driftThreshold ? "drift" : "coherent";
+    return { score, suspiciousFiles, intentKeywords, verdict };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentbridge1/cli",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "CLI for AgentBridge — structured AI agent work sessions with domain authority and approval gates",
   "type": "commonjs",
   "bin": {