@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/commands/watch.js

@@ -39,6 +39,8 @@ const test_runner_1 = require("../test-runner");
 const revert_crossing_1 = require("../revert-crossing");
 const local_proof_1 = require("../local-proof");
 const supervision_1 = require("../supervision");
+const contract_intelligence_1 = require("../contract-intelligence");
+const contract_verdict_1 = require("../contract-verdict");
 const preflight_changed_files_1 = require("../preflight-changed-files");
 const http_1 = require("../http");
 const error_catalog_1 = require("../error-catalog");
@@ -50,6 +52,10 @@ const gates_1 = require("../gates");
 const git_status_1 = require("../git-status");
 Object.defineProperty(exports, "getDirtyWorkingTreeFiles", { enumerable: true, get: function () { return git_status_1.getDirtyWorkingTreeFiles; } });
 const IDLE_CLOSE_MS = 5_000;
+const CONTRACT_POLL_MS = 2_000;
+function isLocalFirstMode(cfg) {
+    return !cfg.projectId?.trim();
+}
 const WATCH_STARTUP_TIMEOUT_MS = 12_000;
 const WATCH_START_TASK_TIMEOUT_MS = 60_000;
 function acceptanceRolloutOptionsFromGates(gates) {
@@ -117,8 +123,8 @@ function renderCrossingContext(input) {
         "- required action: approve, handoff, limit, deny, abandon, or revert",
     ].join("\n");
 }
-function shouldRenderSupervisionSummary(lastSignature, snapshot) {
-    const nextSignature = (0, supervision_1.supervisionSignature)(snapshot);
+function shouldRenderSupervisionSummary(lastSignature, snapshot, renderContext) {
+    const nextSignature = (0, supervision_1.supervisionSignature)(snapshot, renderContext);
     return {
         shouldRender: nextSignature !== lastSignature,
         nextSignature,
@@ -461,6 +467,82 @@ function detectInferredDomainDrift(files, domains) {
     };
     return { issue, blocking: highRisk };
 }
+function assessWatchLaneClaim(input) {
+    if (input.files.length === 0) {
+        return {
+            confidence: "high",
+            source: "scope_pattern",
+            laneDomain: input.activeLaneDomain,
+        };
+    }
+    if (input.domains.length === 0) {
+        return {
+            confidence: "high",
+            source: "unresolved",
+            laneDomain: input.activeLaneDomain,
+        };
+    }
+    if ((input.claimedPaths ?? []).length > 0) {
+        return {
+            confidence: "high",
+            source: "active_session_lane",
+            laneDomain: input.activeLaneDomain,
+        };
+    }
+    const inferred = (0, domain_resolution_1.inferLaneFromFiles)(input.files, input.domains).laneDomain ?? null;
+    if (inferred) {
+        return { confidence: "high", source: "scope_pattern", laneDomain: inferred };
+    }
+    if (input.activeLaneDomain) {
+        return {
+            confidence: "high",
+            source: "active_session_lane",
+            laneDomain: input.activeLaneDomain,
+        };
+    }
+    const ownedDomains = input.domains.filter((domain) => domain.ownerAgentId === input.activeAgentId);
+    if (ownedDomains.length === 1) {
+        return {
+            confidence: "medium",
+            source: "active_agent_owner_domain",
+            laneDomain: ownedDomains[0]?.domain ?? null,
+        };
+    }
+    return { confidence: "low", source: "unresolved", laneDomain: null };
+}
+function buildWatchLaneClaimIssue(input) {
+    const files = [...new Set(input.files)];
+    const summarizedFiles = files.length > 5 ? `${files.slice(0, 5).join(", ")} (+${files.length - 5} more)` : files.join(", ");
+    if (input.assessment.confidence === "low") {
+        return {
+            errorCode: "LANE_CLAIM_LOW_CONFIDENCE",
+            whatHappened: "Lane/domain claim is unresolved for current changed files.",
+            whyItMatters: "Without a deterministic lane claim, scope and ownership enforcement are unreliable.",
+            files,
+            suggestedPrompt: [
+                "AgentBridge could not confidently map these changes to a single domain lane.",
+                "Pass an explicit lane/domain context, then rerun watch.",
+                `Files: ${summarizedFiles || "none listed"}`,
+            ].join("\n"),
+            nextAction: "Run with explicit scope/domain context (for example: `agentbridge start --summary \"...\" --scope \"...\" --domain \"...\"`), then rerun watch.",
+        };
+    }
+    if (input.assessment.confidence === "medium" && !input.confirmDomain) {
+        return {
+            errorCode: "LANE_CLAIM_CONFIRM_REQUIRED",
+            whatHappened: `Lane/domain claim is medium confidence (${input.assessment.source}).`,
+            whyItMatters: "Medium-confidence claims require explicit acknowledgment before watch can proceed safely.",
+            files,
+            suggestedPrompt: [
+                `Lane candidate: ${input.assessment.laneDomain ?? "unknown"}`,
+                "Re-run watch with explicit confirmation to proceed on this lane.",
+                `Files: ${summarizedFiles || "none listed"}`,
+            ].join("\n"),
+            nextAction: "Re-run with `agentbridge watch --confirm-domain` (or set explicit domain in start).",
+        };
+    }
+    return null;
+}
 async function resolveCurrentSessionTaskSummary(state) {
     if (!state.changeRequestId)
         return null;
@@ -473,20 +555,24 @@ async function resolveCurrentSessionTaskSummary(state) {
     }
 }
 function renderWatchStartupHeader(input) {
-    const modeLine = input.mode === "explicit"
-        ? "Mode: coding/implementation (scoped policy active)"
-        : "Mode: inferred (brainstorming/planning or coding/implementation)";
     return [
-        "AgentBridge is watching",
-        modeLine,
-        `Task: ${input.task}`,
-        ...(input.scope ? [`Scope: ${input.scope}`] : []),
-        `Current status: ${input.currentStatus}`,
-        `Next guidance: ${input.nextGuidance}`,
+        "AgentBridge watch:",
+        "",
+        "1) Actions performed",
+        `- Watch started for task: ${input.task}`,
+        ...(input.scope ? [`- Scope: ${input.scope}`] : []),
+        `- Mode: ${input.mode === "explicit" ? "strict scoped" : "inferred"}`,
         "",
-        "Live supervision: keep this watch session running beside Cursor.",
-        "Task checkpoint/close: agentbridge start",
-        "Record proof: agentbridge verify -- <test command>",
+        "2) Proof present / missing",
+        "- Present: live monitoring is active",
+        "- Missing: proof not evaluated until changes are checked",
+        "",
+        "3) Next move",
+        `- ${input.nextGuidance}`,
+        "- Live supervision: keep this watch session running beside Cursor.",
+        "- Task checkpoint/close: agentbridge start",
+        "- Keep `agentbridge watch` running while the agent works",
+        "- Record proof with `agentbridge verify -- <test command>`",
         "",
     ].join("\n");
 }
@@ -515,16 +601,115 @@ async function flushStdout() {
     }
     await new Promise((resolveTick) => setImmediate(resolveTick));
 }
-function buildWatchBlockingIssue(report, options) {
-    const summarizePromptFiles = (files) => {
-        const unique = [...new Set(files)];
-        if (unique.length === 0)
-            return "current files";
-        const visible = unique.slice(0, 3);
-        if (unique.length <= 3)
-            return visible.join(", ");
-        return `${visible.join(", ")} (+${unique.length - visible.length} more)`;
+function summarizeWatchPromptFiles(files) {
+    const unique = [...new Set(files)];
+    if (unique.length === 0)
+        return "current files";
+    const visible = unique.slice(0, 3);
+    if (unique.length <= 3)
+        return visible.join(", ");
+    return `${visible.join(", ")} (+${unique.length - visible.length} more)`;
+}
+function isBlockingWatchIssue(issue) {
+    return issue.errorCode !== "AUTO_VERIFIED";
+}
+async function buildAutoVerifyIssueForFiles(files, options) {
+    const uniqueFiles = (0, local_proof_1.normalizeProofMatchingFileSet)(files);
+    if (uniqueFiles.length === 0)
+        return null;
+    const testResult = await (0, test_runner_1.runDetectedTests)({
+        relatedFiles: uniqueFiles,
+        timeoutMs: 3 * 60 * 1000,
+    });
+    if (testResult !== null) {
+        const coherence = (0, test_runner_1.analyzeCoherence)({
+            intent: options.intent ?? null,
+            changedFiles: uniqueFiles,
+            claimedPaths: options.claimedPaths ?? [],
+            testResult,
+        });
+        const driftWarning = coherence.verdict === "drift" && coherence.suspiciousFiles.length > 0
+            ? `\nNote: ${coherence.suspiciousFiles.length} file(s) may not match your declared intent ("${options.intent}"). Check: ${coherence.suspiciousFiles.slice(0, 3).join(", ")}`
+            : "";
+        if (testResult.passed) {
+            return {
+                errorCode: "AUTO_VERIFIED",
+                whatHappened: `AgentBridge ran tests and they passed (${testResult.command}).` + driftWarning,
+                whyItMatters: coherence.verdict === "drift"
+                    ? "Tests passed, but some changed files look unrelated to your stated intent — review the scope."
+                    : "Automated verification confirms the changes are safe.",
+                files: uniqueFiles,
+                suggestedPrompt: "",
+                nextAction: coherence.verdict === "drift"
+                    ? `Review suspicious files: ${coherence.suspiciousFiles.slice(0, 3).join(", ")}`
+                    : "No action required — changes are verified.",
+                testResult,
+                intent: options.intent,
+                coherence,
+            };
+        }
+        const failedNames = (0, test_runner_1.extractFailedTestNames)(testResult.stdout + "\n" + testResult.stderr);
+        const failureSummary = failedNames.length > 0
+            ? `Failing: ${failedNames.slice(0, 3).join(", ")}${failedNames.length > 3 ? ` (+${failedNames.length - 3} more)` : ""}`
+            : "Check test output for details.";
+        return {
+            errorCode: "TEST_FAILED",
+            whatHappened: `AgentBridge ran \`${testResult.command}\` and ${testResult.timedOut ? "it timed out" : "tests failed"}.` +
+                driftWarning,
+            whyItMatters: "These test failures must be fixed before the changes can be trusted.",
+            files: uniqueFiles,
+            suggestedPrompt: [
+                "AgentBridge ran tests and found failures.",
+                failureSummary,
+                options.intent ? `Your declared intent: "${options.intent}"` : "",
+                "Fix the failing tests, then rerun AgentBridge watch.",
+                `Files changed: ${summarizeWatchPromptFiles(uniqueFiles)}`,
+            ]
+                .filter(Boolean)
+                .join("\n"),
+            nextAction: "Fix the failing tests listed above, then rerun: agentbridge watch",
+            testResult,
+            intent: options.intent,
+            coherence,
+        };
+    }
+    const inferredWorkType = options.detectedWorkType &&
+        options.detectedWorkType !== "general" &&
+        options.detectedWorkType !== "unknown"
+        ? options.detectedWorkType
+        : (0, supervision_1.inferSupervisionWorkType)(uniqueFiles);
+    const tailoredHints = (0, supervision_1.requiredProofHints)(inferredWorkType).slice(0, 2);
+    const hintLine = tailoredHints.length > 0
+        ? `Suggested proof: ${tailoredHints.join("; ")}`
+        : "Suggested proof: run a verification command for changed files.";
+    const isUiCopy = inferredWorkType === "ui_copy";
+    return {
+        errorCode: "PROOF_MISSING",
+        whatHappened: proofMissingReason(uniqueFiles, inferredWorkType),
+        whyItMatters: proofMissingWhyItMatters(inferredWorkType),
+        files: uniqueFiles,
+        suggestedPrompt: [
+            `AgentBridge found ${uniqueFiles.length} changed files without proof.`,
+            hintLine,
+            "Run verification for the changed files, then rerun AgentBridge watch.",
+            `Files: ${summarizeWatchPromptFiles(uniqueFiles)}`,
+        ].join("\n"),
+        nextAction: isUiCopy
+            ? "Capture visual confirmation (screenshot) for the UI copy change, then rerun watch."
+            : "Run a verification command for the changed files.",
+        intent: options.intent,
     };
+}
+async function buildLocalProofWatchIssue(evaluation, options) {
+    const staticIssue = (0, local_proof_1.buildLocalProofBlockingIssue)(evaluation);
+    if (!staticIssue)
+        return null;
+    if (staticIssue.errorCode === "PROOF_MISSING") {
+        return buildAutoVerifyIssueForFiles(evaluation.changedFiles, options);
+    }
+    return staticIssue;
+}
+async function buildWatchBlockingIssue(report, options) {
     if (options.strictScope && (report.out_of_scope_files ?? []).length > 0) {
         const files = [...new Set(report.out_of_scope_files ?? [])];
         return {
@@ -535,7 +720,7 @@ function buildWatchBlockingIssue(report, options) {
             suggestedPrompt: [
                 "You changed files outside the allowed scope.",
                 "Revert them, justify why they are required and ask to expand scope, or split them into a separate task.",
-                `Out-of-scope files: ${summarizePromptFiles(files)}`,
+                `Out-of-scope files: ${summarizeWatchPromptFiles(files)}`,
             ].join("\n"),
             nextAction: "Revert out-of-scope files, then rerun: agentbridge watch",
         };
@@ -550,7 +735,7 @@ function buildWatchBlockingIssue(report, options) {
             suggestedPrompt: [
                 "Your proof is stale because files changed after verification.",
                 "Rerun verification after your final edit, then rerun AgentBridge watch.",
-                `Files: ${summarizePromptFiles(staleFiles)}`,
+                `Files: ${summarizeWatchPromptFiles(staleFiles)}`,
             ].join("\n"),
             nextAction: "Run a verification command for the final changed files.",
         };
@@ -573,45 +758,49 @@ function buildWatchBlockingIssue(report, options) {
         return (0, proof_obligations_1.buildWatchBlockingIssueFromObligation)(report, blockingObligation);
     }
     if (report.decision === "needs_proof") {
-        const files = [...new Set(report.changed_files)];
-        return {
-            errorCode: "PROOF_MISSING",
-            whatHappened: "No valid verification proof is attached to the current work.",
-            whyItMatters: "Coding changes need AgentBridge-recorded proof before they are safe to trust.",
-            files,
-            suggestedPrompt: [
-                `AgentBridge found ${files.length} changed files without proof.`,
-                "Run verification for the changed files, then rerun AgentBridge watch.",
-                `Files: ${summarizePromptFiles(files)}`,
-            ].join("\n"),
-            nextAction: "Run a verification command for the changed files.",
-        };
+        return buildAutoVerifyIssueForFiles([...new Set(report.changed_files)], {
+            intent: options.intent ?? null,
+            claimedPaths: options.claimedPaths ?? [],
+            detectedWorkType: report.detected_work_type,
+        });
     }
     return null;
 }
-function buildFallbackWatchBlockingIssue(supervision) {
-    const summarizePromptFiles = (files) => {
-        const unique = [...new Set(files)];
-        if (unique.length === 0)
-            return "current files";
-        const visible = unique.slice(0, 3);
-        if (unique.length <= 3)
-            return visible.join(", ");
-        return `${visible.join(", ")} (+${unique.length - visible.length} more)`;
-    };
+function proofMissingReason(files, workType) {
+    const fileList = files.slice(0, 3).join(", ") + (files.length > 3 ? ` (+${files.length - 3} more)` : "");
+    if (workType === "ui_copy") {
+        return `${files.length} UI file${files.length === 1 ? "" : "s"} changed (${fileList}) with no visual confirmation recorded.`;
+    }
+    if (workType === "documentation") {
+        return `${files.length} doc file${files.length === 1 ? "" : "s"} changed (${fileList}) with no verification recorded.`;
+    }
+    if (workType === "cli_git_enforcement") {
+        return `${files.length} CLI enforcement file${files.length === 1 ? "" : "s"} changed (${fileList}) — these need passing tests before they can be trusted.`;
+    }
+    return `${files.length} file${files.length === 1 ? "" : "s"} changed (${fileList}) with no verification run recorded for this session.`;
+}
+function proofMissingWhyItMatters(workType) {
+    if (workType === "ui_copy") {
+        return "Without a screenshot or visual check, there's no record that the UI looks correct.";
+    }
+    if (workType === "documentation") {
+        return "Without a check, there's no record that the docs are accurate and complete.";
+    }
+    if (workType === "cli_git_enforcement") {
+        return "CLI enforcement logic is critical — untested changes here can silently break agent supervision.";
+    }
+    return "Without a verification run, there's no record that the changes work correctly.";
+}
+async function buildFallbackWatchBlockingIssue(supervision, options) {
     if (supervision.decision === "needs_proof") {
-        return {
-            errorCode: "PROOF_MISSING",
-            whatHappened: "No valid verification proof is attached to the current work.",
-            whyItMatters: "Coding changes need AgentBridge-recorded proof before they are safe to trust.",
-            files: [],
-            suggestedPrompt: [
-                `AgentBridge found ${supervision.changedFiles.length} changed files without proof.`,
-                "Run verification for the changed files, then rerun AgentBridge watch.",
-                `Files: ${summarizePromptFiles(supervision.changedFiles)}`,
-            ].join("\n"),
-            nextAction: "Run a verification command for the changed files.",
-        };
+        const meaningfulFiles = (0, local_proof_1.normalizeProofMatchingFileSet)(supervision.changedFiles);
+        if (meaningfulFiles.length === 0)
+            return null;
+        return buildAutoVerifyIssueForFiles(meaningfulFiles, {
+            intent: options.intent ?? null,
+            claimedPaths: options.claimedPaths ?? [],
+            detectedWorkType: supervision.workType,
+        });
     }
     if (supervision.decision === "failed") {
         return {
@@ -621,7 +810,7 @@ function buildFallbackWatchBlockingIssue(supervision) {
             files: supervision.changedFiles,
             suggestedPrompt: [
                 "Resolve the verification or scope problem, then rerun AgentBridge watch.",
-                `Files in current blocked state: ${summarizePromptFiles(supervision.changedFiles)}`,
+                `Files in current blocked state: ${summarizeWatchPromptFiles(supervision.changedFiles)}`,
             ].join("\n"),
             nextAction: "Resolve proof/scope problems, then rerun watch.",
         };
@@ -629,22 +818,161 @@ function buildFallbackWatchBlockingIssue(supervision) {
     return null;
 }
 function renderWatchBlockingIssue(issue) {
+    const sep = "─".repeat(52);
+    // ── Auto-verified: tests passed ──────────────────────────────────────────
+    if (issue.errorCode === "AUTO_VERIFIED" && issue.testResult) {
+        const dur = (issue.testResult.durationMs / 1000).toFixed(1);
+        const hasDrift = issue.coherence?.verdict === "drift";
+        const fileList = issue.files.slice(0, 8).join("\n    ");
+        const moreFiles = issue.files.length > 8 ? `\n    (+${issue.files.length - 8} more)` : "";
+        const suspiciousLines = hasDrift && issue.coherence
+            ? issue.coherence.suspiciousFiles.map((f) => `    ⚠ ${f}`).join("\n")
+            : "";
+        return [
+            sep,
+            "  AgentBridge Verification Report",
+            sep,
+            "",
+            "📋  YOUR SCOPE",
+            `    Intent : ${issue.intent ?? "(no intent declared)"}`,
+            `    Files  : ${issue.files.length} changed`,
+            `    ${fileList}${moreFiles}`,
+            ...(hasDrift ? ["", `    ⚠ Scope drift — these files may not match your intent:`] : []),
+            ...(suspiciousLines ? [suspiciousLines] : []),
+            "",
+            "🔬  WHAT WE RAN",
+            `    Command : ${issue.testResult.command}`,
+            `    Duration: ${dur}s`,
+            `    Outcome : ✓ All tests passed`,
+            "",
+            "✅  WHAT WE FOUND",
+            hasDrift
+                ? `    Tests passed, but ${issue.coherence.suspiciousFiles.length} file(s) look outside your stated intent.`
+                : "    All changed files are consistent with your intent. No issues found.",
+            "",
+            "➡   NEXT STEPS",
+            hasDrift
+                ? `    1. Review suspicious files — are they intentional?\n    2. Update your intent if scope has expanded.\n    3. Re-run: agentbridge watch`
+                : "    You're good. Share this result with your team or merge when ready.",
+            "",
+            sep,
+        ].join("\n");
+    }
+    // ── Test run failed ───────────────────────────────────────────────────────
+    if (issue.errorCode === "TEST_FAILED" && issue.testResult) {
+        const dur = (issue.testResult.durationMs / 1000).toFixed(1);
+        const failedNames = (0, test_runner_1.extractFailedTestNames)(issue.testResult.stdout + "\n" + issue.testResult.stderr);
+        const failureLines = failedNames.length > 0
+            ? failedNames.slice(0, 5).map((n) => `    ✗ ${n}`).join("\n")
+            : "    (check test output above for details)";
+        const moreFailures = failedNames.length > 5 ? `\n    (+${failedNames.length - 5} more)` : "";
+        const hasDrift = issue.coherence?.verdict === "drift";
+        const fileList = issue.files.slice(0, 8).join("\n    ");
+        const moreFiles = issue.files.length > 8 ? `\n    (+${issue.files.length - 8} more)` : "";
+        const timedOutNote = issue.testResult.timedOut
+            ? `\n    ⚠ Timed out after ${(issue.testResult.durationMs / 1000).toFixed(0)}s — increase verify.timeoutMs in .agentbridge.json`
+            : "";
+        return [
+            sep,
+            "  AgentBridge Verification Report",
+            sep,
+            "",
+            "📋  YOUR SCOPE",
+            `    Intent : ${issue.intent ?? "(no intent declared)"}`,
+            `    Files  : ${issue.files.length} changed`,
+            `    ${fileList}${moreFiles}`,
+            ...(hasDrift
+                ? [
+                    "",
+                    `    ⚠ Scope drift — ${issue.coherence.suspiciousFiles.length} file(s) may be outside your intent:`,
+                    ...issue.coherence.suspiciousFiles.slice(0, 3).map((f) => `      ${f}`),
+                ]
+                : []),
+            "",
+            "🔬  WHAT WE RAN",
+            `    Command : ${issue.testResult.command}`,
+            `    Duration: ${dur}s${timedOutNote}`,
+            `    Outcome : ✗ Tests failed`,
+            "",
+            "❌  WHAT WE FOUND",
+            failureLines + moreFailures,
+            ...(hasDrift ? ["", `    Scope note: ${issue.whyItMatters}`] : []),
+            "",
+            "➡   NEXT STEPS",
+            "    1. Fix the failing tests listed above.",
+            ...(hasDrift ? ["    2. Review the out-of-scope files — are they intentional?"] : []),
+            `    ${hasDrift ? "3" : "2"}. Re-run: agentbridge watch`,
+            "",
+            ...(issue.suggestedPrompt
+                ? [
+                    "  ── Agent prompt ──",
+                    `    ${issue.suggestedPrompt.replaceAll("\n", "\n    ")}`,
+                    "",
+                ]
+                : []),
+            sep,
+        ].join("\n");
+    }
+    // ── Proof missing (auto-verify could not run tests) ───────────────────────
+    if (issue.errorCode === "PROOF_MISSING") {
+        const sep = "─".repeat(52);
+        const fileList = issue.files.slice(0, 8).join("\n    ");
+        const moreFiles = issue.files.length > 8 ? `\n    (+${issue.files.length - 8} more)` : "";
+        return [
+            sep,
+            "  AgentBridge Verification Report",
+            sep,
+            "",
+            "📋  YOUR SCOPE",
+            `    Intent : ${issue.intent ?? "(no intent declared)"}`,
+            `    Files  : ${issue.files.length} changed`,
+            `    ${fileList}${moreFiles}`,
+            "",
+            "🔬  WHAT WE RAN",
+            "    Command : (none — no test command detected for these files)",
+            "    Outcome : ⚠ Verification not run automatically",
+            "",
+            "❌  WHAT WE FOUND",
+            `    ${issue.whatHappened}`,
+            `    ${issue.whyItMatters}`,
+            "",
+            "➡   NEXT STEPS",
+            `    1. ${issue.nextAction}`,
+            "    2. Or run: agentbridge verify -- <your test command>",
+            "    3. Re-run: agentbridge watch",
+            "",
+            ...(issue.suggestedPrompt
+                ? [
+                    "  ── Agent prompt ──",
+                    `    ${issue.suggestedPrompt.replaceAll("\n", "\n    ")}`,
+                    "",
+                ]
+                : []),
+            sep,
+        ].join("\n");
+    }
+    // ── Default blocking-issue format ─────────────────────────────────────────
     const files = [...new Set(issue.files)];
     const visibleFiles = files.slice(0, 10);
     const hiddenCount = Math.max(0, files.length - visibleFiles.length);
     const filesLine = visibleFiles.length > 0 ? visibleFiles.join(", ") : "none listed";
     return [
-        "AgentBridge caught an issue",
-        `What happened: ${issue.whatHappened}`,
-        `Why it matters: ${issue.whyItMatters}`,
-        `Files: ${filesLine}`,
-        ...(hiddenCount > 0 ? [`+ ${hiddenCount} more files hidden (run \`agentbridge watch --details\`).`] : []),
-        `Error code: ${issue.errorCode}`,
-        "Suggested prompt to send back to agent:",
-        "```text",
-        issue.suggestedPrompt,
-        "```",
-        `Next action: ${issue.nextAction}`,
+        "AgentBridge watch:",
+        "",
+        "1) Actions performed",
+        "- Evaluated changed files against scope and proof rules",
+        `- Files checked: ${filesLine}`,
+        ...(hiddenCount > 0 ? [`- + ${hiddenCount} more files hidden (use \`agentbridge watch --details\`)`] : []),
+        "",
+        "2) Proof present / missing",
+        `- Missing/blocked: ${issue.whatHappened}`,
+        `- Why it matters: ${issue.whyItMatters}`,
+        `- Error code: ${issue.errorCode}`,
+        "",
+        "3) Next move",
+        `- ${issue.nextAction}`,
+        "- Optional agent prompt:",
+        `  ${issue.suggestedPrompt.replaceAll("\n", " ")}`,
         "",
     ].join("\n");
 }
@@ -652,7 +980,7 @@ function overlayLocalChangedFilesOnSupervision(supervision, localChangedFiles) {
     if (supervision.changedFiles.length > 0 || localChangedFiles.length === 0) {
         return supervision;
     }
-    const nextChangedFiles = [...new Set(localChangedFiles)].sort();
+    const nextChangedFiles = (0, local_proof_1.normalizeProofMatchingFileSet)(localChangedFiles);
     const nextWorkType = supervision.workType === "unknown" ? (0, supervision_1.inferSupervisionWorkType)(nextChangedFiles) : supervision.workType;
     return {
         ...supervision,
@@ -805,6 +1133,8 @@ function normalizeDirtyWorkingTreeFiles(files) {
                 continue;
             if (flat === ".agentbridge" || flat.startsWith(".agentbridge/"))
                 continue;
+            if ((0, local_proof_1.isProofNoiseFile)(flat))
+                continue;
             if (seen.has(flat))
                 continue;
             seen.add(flat);
@@ -844,7 +1174,7 @@ function fileWithinScopedPaths(file, scopedPaths) {
     });
 }
 function startupDirtyClassification(input) {
-    const workspaceDirtySnapshot = [...new Set(input.dirtyFiles)].sort();
+    const workspaceDirtySnapshot = (0, local_proof_1.normalizeProofMatchingFileSet)(input.dirtyFiles);
     const localChanged = new Set(input.localState?.changedFiles ?? []);
     const localClaimedPaths = input.serverReportedEmptyScope
         ? []
@@ -1003,7 +1333,7 @@ function currentGitHead() {
  * the local session is left active for subsequent verify/follow-up.
  */
 async function runWatchOnceFastPath(input) {
-    const { cfg, activeAgentId, task, scope, changeRequestId, allowDirty, timing } = input;
+    const { cfg, activeAgentId, task, scope, changeRequestId, allowDirty, timing, confirmDomain } = input;
     const ignoredDirtyFiles = input.ignoredDirtyFiles ?? new Set();
     let ctx;
     try {
@@ -1092,6 +1422,28 @@ async function runWatchOnceFastPath(input) {
     const lane = (0, domain_resolution_1.inferLaneFromFiles)(classification.acceptanceCandidateFiles.length > 0
         ? classification.acceptanceCandidateFiles
         : changedFiles, cfg.domains ?? []);
+    const laneAssessment = assessWatchLaneClaim({
+        files: classification.acceptanceCandidateFiles.length > 0
+            ? classification.acceptanceCandidateFiles
+            : changedFiles,
+        domains: cfg.domains ?? [],
+        activeLaneDomain: lane.laneDomain ?? null,
+        activeAgentId,
+        claimedPaths,
+    });
+    const laneIssue = buildWatchLaneClaimIssue({
+        assessment: laneAssessment,
+        files: classification.acceptanceCandidateFiles.length > 0
+            ? classification.acceptanceCandidateFiles
+            : changedFiles,
+        confirmDomain: confirmDomain === true,
+    });
+    if (laneIssue) {
+        timing.trackSync("render_output", () => {
+            process.stdout.write(renderWatchBlockingIssue(laneIssue));
+        });
+        return { handled: true, hadBlockingIssue: true };
+    }
     const persistedClaimed = result.claimed_paths.length > 0 ? result.claimed_paths : claimedPaths;
     (0, session_1.openLocalSession)({
         agentId: activeAgentId,
@@ -1114,15 +1466,30 @@ async function runWatchOnceFastPath(input) {
     const supervision = persistedState
         ? finalizeWatchSupervision(persistedState, (0, supervision_1.supervisionFromAcceptance)(acceptance, cfg.domains ?? []))
         : (0, supervision_1.supervisionFromAcceptance)(acceptance, cfg.domains ?? []);
+    const startupSupervision = (0, supervision_1.resolveWatchStartupSupervision)({
+        workspaceRoot: (0, node_process_1.cwd)(),
+        cliProjectId: cfg.projectId,
+    });
+    const onceRenderContext = (0, supervision_1.buildWatchSupervisionRenderContext)({
+        baseStatus: startupSupervision.supervisionStatus,
+        mcpConfigured: startupSupervision.mcpConfigured,
+        agentDeclaredUpdatedAt: supervision.agentDeclared?.updatedAt,
+    });
     timing.trackSync("render_output", () => {
-        process.stdout.write(`${(0, supervision_1.renderSupervisionSummary)(supervision)}\n`);
+        process.stdout.write(`${(0, supervision_1.renderSupervisionSummary)(supervision, onceRenderContext)}\n`);
     });
-    const blockingIssue = timing.trackSync("proof_fingerprint_comparison", () => buildWatchBlockingIssue(acceptance, { strictScope: true }));
+    const blockingIssue = await timing.trackAsync("proof_fingerprint_comparison", () => buildWatchBlockingIssue(acceptance, {
+        strictScope: true,
+        intent: persistedState?.intent ?? null,
+        claimedPaths: persistedClaimed,
+    }));
     if (blockingIssue) {
         timing.trackSync("render_output", () => {
             process.stdout.write(renderWatchBlockingIssue(blockingIssue));
         });
-        hadBlockingIssue = true;
+        if (isBlockingWatchIssue(blockingIssue)) {
+            hadBlockingIssue = true;
+        }
     }
     // Surface scope drift from out-of-scope startup dirt unless the acceptance
     // report already raised the same scope-drift issue (avoid double render).
@@ -1144,6 +1511,7 @@ async function runWatchOnceFastPath(input) {
 async function runWatch(options = {}) {
     const timing = createWatchTimingTracker();
     const cfg = timing.trackSync("config_load", () => (0, config_1.readConfig)());
+    const localFirstMode = isLocalFirstMode(cfg);
     const repoRoot = (0, node_process_1.cwd)();
     const gitignoreSessionEntry = (0, gates_1.ensureGitignoreSessionEntry)(repoRoot);
     const ignoredDirtyFiles = new Set();
@@ -1222,14 +1590,30 @@ async function runWatch(options = {}) {
             });
         }
     });
-    if (!explicitStrictMode && !cfg.activeAgentId) {
+    if (!explicitStrictMode && !cfg.activeAgentId && !localFirstMode) {
         process.stdout.write("Startup note: no active internal agent selected. Inferred mode will continue using room-level connection and local supervision.\n");
         await flushStdout();
     }
-    if (!hasRecoveredDomainMap) {
+    if (!hasRecoveredDomainMap && !localFirstMode) {
         process.stdout.write("Startup note: domain map is not fully recovered yet. AgentBridge will keep watching with best-effort drift checks.\n");
         await flushStdout();
     }
+    // Non-blocking supervision context check: warn if MCP or rules are missing or mismatched.
+    // Hoisted so every render call (live loop, --once handoff) shares the same startup decision.
+    let watchMcpConfigured = false;
+    let watchSupervisionStatus = "blind";
+    {
+        const startup = (0, supervision_1.resolveWatchStartupSupervision)({
+            workspaceRoot: (0, node_process_1.cwd)(),
+            cliProjectId: cfg.projectId,
+        });
+        watchMcpConfigured = startup.mcpConfigured;
+        watchSupervisionStatus = startup.supervisionStatus;
+        if (startup.warningBanner && !localFirstMode) {
+            process.stdout.write(`${startup.warningBanner}\n`);
+            await flushStdout();
+        }
+    }
     let activeAgentId = cfg.activeAgentId ?? "inferred-room-connection";
     if (options.changeRequestId || options.executionSurfaceId) {
         (0, config_1.updateConfig)({
@@ -1287,6 +1671,7 @@ async function runWatch(options = {}) {
                 ? options.changeRequestId ?? cfg.activeChangeRequestId ?? null
                 : options.changeRequestId ?? null,
             allowDirty: Boolean(options.allowDirty) || Boolean(options.daemon),
+            confirmDomain: options.confirmDomain === true,
             timing,
             ignoredDirtyFiles,
         });
@@ -1310,6 +1695,7 @@ async function runWatch(options = {}) {
             await timing.trackAsync("start_or_resume", async () => withTimeout((0, start_1.runStart)({
                 summary: taskScopeInput.task,
                 scope: taskScopeInput.scope,
+                ...(options.confirmDomain === true ? { confirmDomain: true } : {}),
             }), WATCH_START_TASK_TIMEOUT_MS, () => new errors_1.SafeCliError({
                 code: "WATCH_STARTUP_TIMEOUT",
                 category: "WATCH_ERROR",
@@ -1397,8 +1783,61 @@ async function runWatch(options = {}) {
     let lastSupervisionSignature = null;
     let lastBlockingIssueSignature = null;
     let lastDriftIssueSignature = null;
+    let lastLaneClaimIssueSignature = null;
     let hadBlockingIssue = false;
+    let onceModeVerificationIssue = null;
+    let lastAutoVerifyTestResult = null;
+    let verdictInProgress = false;
+    const waitForContract = async () => {
+        let session = (0, session_state_1.readSessionState)();
+        if (!(0, session_state_1.isActiveLocalSession)(session)) {
+            process.stdout.write("AgentBridge watching — waiting for contract...\n");
+            await flushStdout();
+        }
+        while (!(0, session_state_1.isActiveLocalSession)(session)) {
+            await new Promise((resolve) => setTimeout(resolve, CONTRACT_POLL_MS));
+            session = (0, session_state_1.readSessionState)();
+        }
+        process.stdout.write((0, contract_intelligence_1.renderLiveContractBanner)(session));
+        await flushStdout();
+        return session;
+    };
+    const printVerdictAndReset = async (opts) => {
+        if (verdictInProgress)
+            return;
+        verdictInProgress = true;
+        try {
+            const session = (0, session_state_1.readSessionState)();
+            if (!session || session.id === "none")
+                return;
+            const changedFiles = (0, preflight_changed_files_1.computeCurrentWorkFiles)(session);
+            const proofRun = session.lastLocalVerificationRun ?? null;
+            process.stdout.write(`${(0, contract_verdict_1.renderContractVerdict)(session, changedFiles, proofRun, cfg.domains ?? [])}\n`);
+            await flushStdout();
+            if (session.status !== "closed") {
+                (0, session_1.closeLocalSession)(session);
+            }
+            (0, session_state_2.clearSessionState)();
+            if (localFirstMode && !options.once && opts?.waitForNext !== false) {
+                process.stdout.write("\nAgentBridge watching — waiting for next contract...\n");
+                await flushStdout();
+                await waitForContract();
+            }
+        }
+        finally {
+            verdictInProgress = false;
+        }
+    };
+    const rememberAutoVerifyTestResult = (issue) => {
+        if (issue?.testResult) {
+            lastAutoVerifyTestResult = issue.testResult;
+        }
+    };
     const closeIdleSession = async () => {
+        if (localFirstMode) {
+            await printVerdictAndReset();
+            return;
+        }
         const state = (0, session_state_1.readSessionState)();
         if (!state || state.status === "closed" || state.id === "none")
             return;
@@ -1459,7 +1898,9 @@ async function runWatch(options = {}) {
                 process.stdout.write(`${renderIdleCloseFailure(err)}\n`);
             }
         }
-        const testRun = await (0, test_runner_1.runDetectedTests)();
+        const testRun = lastAutoVerifyTestResult ??
+            onceModeVerificationIssue?.testResult ??
+            (await (0, test_runner_1.runDetectedTests)());
         process.stdout.write(`${(0, briefing_1.renderSessionBriefing)({ state, testRun })}\n`);
     };
     const resetIdle = () => {
@@ -1474,12 +1915,26 @@ async function runWatch(options = {}) {
             const file = (0, node_path_1.relative)((0, node_process_1.cwd)(), absolutePath).replaceAll("\\", "/");
             if (!file || file.startsWith(".."))
                 return;
+            if ((0, local_proof_1.isProofNoiseFile)(file))
+                return;
             // Fix D: Don't reset the idle timer in --once mode.  Only accept/abandon/done
             // should close the session; --once should leave it open for follow-up commands.
             if (!options.once)
                 resetIdle();
             let state = (0, session_state_1.readSessionState)();
+            if (localFirstMode) {
+                if (state?.status === "closed" && state.id !== "none") {
+                    await printVerdictAndReset();
+                    return;
+                }
+                if (!(0, session_state_1.isActiveLocalSession)(state)) {
+                    return;
+                }
+            }
             if (!state || state.status === "closed" || state.id === "none") {
+                if (localFirstMode) {
+                    return;
+                }
                 const lane = (0, domain_resolution_1.inferLaneFromFiles)([file], cfg.domains ?? []);
                 let serverSessionId;
                 const changeRequestId = explicitStrictMode
@@ -1535,6 +1990,32 @@ async function runWatch(options = {}) {
                 sessionBannerLines.push("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━", "");
                 process.stdout.write(sessionBannerLines.join("\n"));
             }
+            const laneAssessment = assessWatchLaneClaim({
+                files: [...state.changedFiles, file],
+                domains: cfg.domains ?? [],
+                activeLaneDomain: state.laneDomain ?? null,
+                activeAgentId,
+                claimedPaths: state.claimedPaths,
+            });
+            const laneIssue = buildWatchLaneClaimIssue({
+                assessment: laneAssessment,
+                files: [...state.changedFiles, file],
+                confirmDomain: options.confirmDomain === true,
+            });
+            const laneIssueSignature = laneIssue ? JSON.stringify(laneIssue) : null;
+            if (laneIssue && laneIssueSignature && laneIssueSignature !== lastLaneClaimIssueSignature) {
+                timing.trackSync("render_output", () => {
+                    process.stdout.write(renderWatchBlockingIssue(laneIssue));
+                });
+                lastLaneClaimIssueSignature = laneIssueSignature;
+            }
+            else if (!laneIssueSignature) {
+                lastLaneClaimIssueSignature = null;
+            }
+            if (laneIssue) {
+                hadBlockingIssue = true;
+                return;
+            }
             const outcome = (0, watch_core_1.applyFileChange)(state, file);
             (0, session_state_1.writeSessionState)(state);
             const unresolvedProtectedCrossing = state.crossings.some((crossing) => crossing.status === "unresolved" &&
@@ -1563,29 +2044,38 @@ async function runWatch(options = {}) {
                 process.stdout.write(`Observed-diff sync failed: ${supervisionResult.syncError}\n`);
             }
             const supervision = supervisionResult.supervision;
-            const nextSummary = shouldRenderSupervisionSummary(lastSupervisionSignature, supervision);
+            const watchRenderContext = (0, supervision_1.buildWatchSupervisionRenderContext)({
+                baseStatus: watchSupervisionStatus,
+                mcpConfigured: watchMcpConfigured,
+                agentDeclaredUpdatedAt: supervision.agentDeclared?.updatedAt,
+            });
+            const nextSummary = shouldRenderSupervisionSummary(lastSupervisionSignature, supervision, watchRenderContext);
             if (nextSummary.shouldRender) {
                 timing.trackSync("render_output", () => {
                     process.stdout.write(`${(0, supervision_1.renderSupervisionSummary)(supervision, {
                         compact: !explicitStrictMode && !options.details,
+                        ...watchRenderContext,
                     })}\n`);
                 });
                 lastSupervisionSignature = nextSummary.nextSignature;
             }
             const renderSupervisionProofIssue = explicitStrictMode || !options.once;
             if (supervisionResult.acceptanceReport) {
-                const blockingIssue = timing.trackSync("proof_fingerprint_comparison", () => buildWatchBlockingIssue(supervisionResult.acceptanceReport, {
+                const blockingIssue = await timing.trackAsync("proof_fingerprint_comparison", () => buildWatchBlockingIssue(supervisionResult.acceptanceReport, {
                     strictScope: explicitStrictMode,
+                    intent: state?.intent ?? null,
+                    claimedPaths: state?.claimedPaths ?? [],
                 }));
                 const issueSignature = blockingIssue ? JSON.stringify(blockingIssue) : null;
                 if (blockingIssue &&
                     issueSignature &&
                     issueSignature !== lastBlockingIssueSignature &&
                     renderSupervisionProofIssue) {
+                    rememberAutoVerifyTestResult(blockingIssue);
                     timing.trackSync("render_output", () => {
                         process.stdout.write(renderWatchBlockingIssue(blockingIssue));
                     });
-                    if (explicitStrictMode) {
+                    if (explicitStrictMode || isBlockingWatchIssue(blockingIssue)) {
                         hadBlockingIssue = true;
                     }
                     lastBlockingIssueSignature = issueSignature;
@@ -1595,16 +2085,20 @@ async function runWatch(options = {}) {
                 }
             }
             else {
-                const blockingIssue = timing.trackSync("proof_fingerprint_comparison", () => buildFallbackWatchBlockingIssue(supervision));
+                const blockingIssue = await timing.trackAsync("proof_fingerprint_comparison", () => buildFallbackWatchBlockingIssue(supervision, {
+                    intent: state?.intent ?? null,
+                    claimedPaths: state?.claimedPaths ?? [],
+                }));
                 const issueSignature = blockingIssue ? JSON.stringify(blockingIssue) : null;
                 if (blockingIssue &&
                     issueSignature &&
                     issueSignature !== lastBlockingIssueSignature &&
                     renderSupervisionProofIssue) {
+                    rememberAutoVerifyTestResult(blockingIssue);
                     timing.trackSync("render_output", () => {
                         process.stdout.write(renderWatchBlockingIssue(blockingIssue));
                     });
-                    if (explicitStrictMode) {
+                    if (explicitStrictMode || isBlockingWatchIssue(blockingIssue)) {
                         hadBlockingIssue = true;
                     }
                     lastBlockingIssueSignature = issueSignature;
@@ -1881,6 +2375,29 @@ async function runWatch(options = {}) {
             inferredMode: !explicitStrictMode,
             serverReportedEmptyScope,
         }));
+        const startupLaneAssessment = assessWatchLaneClaim({
+            files: startupClassification.acceptanceCandidateFiles.length > 0
+                ? startupClassification.acceptanceCandidateFiles
+                : startupClassification.workspaceDirtySnapshot,
+            domains: cfg.domains ?? [],
+            activeLaneDomain: startupState?.laneDomain ?? null,
+            activeAgentId,
+            claimedPaths: startupClaimedPaths,
+        });
+        const startupLaneIssue = buildWatchLaneClaimIssue({
+            assessment: startupLaneAssessment,
+            files: startupClassification.acceptanceCandidateFiles.length > 0
+                ? startupClassification.acceptanceCandidateFiles
+                : startupClassification.workspaceDirtySnapshot,
+            confirmDomain: options.confirmDomain === true,
+        });
+        if (startupLaneIssue) {
+            timing.trackSync("render_output", () => {
+                process.stdout.write(renderWatchBlockingIssue(startupLaneIssue));
+            });
+            hadBlockingIssue = true;
+            return;
+        }
         if (startupClassification.workspaceDirtySnapshot.length === 0 && !explicitStrictMode) {
             process.stdout.write(renderBrainstormingStatus());
         }
@@ -1962,13 +2479,21 @@ async function runWatch(options = {}) {
             }
         }
         if (options.once && !explicitStrictMode && startupClassification.acceptanceCandidateFiles.length > 0) {
-            const localProofEvaluation = timing.trackSync("local_proof_evaluation", () => (0, local_proof_1.evaluateLocalProof)(startupClassification.acceptanceCandidateFiles, (0, session_state_1.readSessionState)()?.lastLocalVerificationRun));
-            const localProofIssue = (0, local_proof_1.buildLocalProofBlockingIssue)(localProofEvaluation);
+            const sessionForProof = (0, session_state_1.readSessionState)();
+            const localProofEvaluation = timing.trackSync("local_proof_evaluation", () => (0, local_proof_1.evaluateLocalProof)(startupClassification.acceptanceCandidateFiles, sessionForProof?.lastLocalVerificationRun));
+            const localProofIssue = await timing.trackAsync("local_proof_auto_verify", () => buildLocalProofWatchIssue(localProofEvaluation, {
+                intent: sessionForProof?.intent ?? null,
+                claimedPaths: startupClaimedPaths,
+            }));
+            onceModeVerificationIssue = localProofIssue;
             if (localProofIssue) {
+                rememberAutoVerifyTestResult(localProofIssue);
                 timing.trackSync("render_output", () => {
                     process.stdout.write(renderWatchBlockingIssue(localProofIssue));
                 });
-                hadBlockingIssue = true;
+                if (isBlockingWatchIssue(localProofIssue)) {
+                    hadBlockingIssue = true;
+                }
             }
             const domainDrift = detectInferredDomainDrift(startupClassification.acceptanceCandidateFiles, cfg.domains ?? []);
             if (domainDrift) {
@@ -1984,7 +2509,7 @@ async function runWatch(options = {}) {
             const finalState = (0, session_state_1.readSessionState)();
             if (finalState && (0, session_state_1.isActiveLocalSession)(finalState)) {
                 const postBaseline = timing.trackSync("baseline_classification", () => (0, preflight_changed_files_1.computeCurrentWorkFiles)(finalState));
-                const supervision = finalizeWatchSupervision(finalState, (0, supervision_1.fallbackSupervisionSnapshot)({
+                let supervision = finalizeWatchSupervision(finalState, (0, supervision_1.fallbackSupervisionSnapshot)({
                     workSessionId: finalState.serverSessionId ?? finalState.id,
                     changeRequestId: finalState.changeRequestId ?? changeRequestId ?? null,
                     changedFiles: postBaseline.length > 0 ? postBaseline : [...(finalState.changedFiles ?? [])],
@@ -1992,9 +2517,35 @@ async function runWatch(options = {}) {
                     unresolvedProtectedCrossing: false,
                     blocked: finalState.status === "blocked",
                 }));
-                timing.trackSync("render_output", () => {
-                    process.stdout.write(`${(0, supervision_1.renderSupervisionSummary)(supervision, { compact: true })}\n`);
+                if (onceModeVerificationIssue?.errorCode === "AUTO_VERIFIED" &&
+                    onceModeVerificationIssue.testResult?.passed) {
+                    supervision = {
+                        ...supervision,
+                        decision: "accepted",
+                        requiredProof: [],
+                        nextAction: onceModeVerificationIssue.nextAction,
+                    };
+                }
+                else if (onceModeVerificationIssue?.errorCode === "TEST_FAILED") {
+                    supervision = {
+                        ...supervision,
+                        decision: "failed",
+                        nextAction: onceModeVerificationIssue.nextAction,
+                    };
+                }
+                const handoffRenderContext = (0, supervision_1.buildWatchSupervisionRenderContext)({
+                    baseStatus: watchSupervisionStatus,
+                    mcpConfigured: watchMcpConfigured,
+                    agentDeclaredUpdatedAt: supervision.agentDeclared?.updatedAt,
                 });
+                if (!onceModeVerificationIssue) {
+                    timing.trackSync("render_output", () => {
+                        process.stdout.write(`${(0, supervision_1.renderSupervisionSummary)(supervision, {
+                            compact: true,
+                            ...handoffRenderContext,
+                        })}\n`);
+                    });
+                }
             }
         }
     };
@@ -2015,6 +2566,18 @@ async function runWatch(options = {}) {
     await processStartupDirty();
     process.stdout.write("[startup] ready: watch runtime is live.\n");
     await flushStdout();
+    if (localFirstMode && !options.once) {
+        if (!(0, session_state_1.isActiveLocalSession)((0, session_state_1.readSessionState)())) {
+            await waitForContract();
+        }
+        else {
+            const active = (0, session_state_1.readSessionState)();
+            if (active) {
+                process.stdout.write((0, contract_intelligence_1.renderLiveContractBanner)(active));
+                await flushStdout();
+            }
+        }
+    }
     if (options.once) {
         if (idleTimer)
             clearTimeout(idleTimer);
@@ -2027,6 +2590,13 @@ async function runWatch(options = {}) {
         if (idleTimer)
             clearTimeout(idleTimer);
         stop?.();
+        if (localFirstMode) {
+            void printVerdictAndReset({ waitForNext: false }).finally(() => {
+                process.stdout.write("\nagentbridge watch stopped.\n");
+                process.exit(0);
+            });
+            return;
+        }
         process.stdout.write("\nagentbridge watch stopped.\n");
         process.exit(0);
     });