@agentbridge1/cli 0.0.5 → 0.0.6

package/dist/error-catalog.js

@@ -44,7 +44,7 @@ const CATALOG = {
         title: "No active tracked work session.",
         what: "No active tracked work session was found for this command.",
         why: "Proof, verify, accept, and handoff require a bound work session.",
-        next: 'Run `agentbridge start --summary "<work>" --scope "<path>"` then `agentbridge watch`.',
+        next: "Run `agentbridge watch` beside Cursor for live supervision, or `agentbridge verify -- <test command>` to record proof.",
         blocksAcceptance: true,
     },
     WORK_CONTEXT_BINDING_REQUIRED: {
@@ -53,7 +53,7 @@ const CATALOG = {
         title: "Work session binding required.",
         what: "This command needs a linked local/server work session.",
         why: "The CLI and server must agree on the active change request and session.",
-        next: 'Run `agentbridge start --summary "<task>" --scope "<path>"` to create and bind a new session, or `agentbridge watch --change-request <id>` to bind an existing one.',
+        next: 'Run `agentbridge watch --allow-dirty` for default review, or `agentbridge watch --task "<task>" --scope "<path>"` for strict mode.',
         blocksAcceptance: true,
     },
     PROOF_STALE_AFTER_CHANGE: {
@@ -70,8 +70,8 @@ const CATALOG = {
         category: "SCOPE_DRIFT_ERROR",
         title: "Scope drift detected.",
         what: "The agent changed a file outside the declared scope.",
-        why: "Out-of-scope edits block acceptance until reviewed or rescoped.",
-        next: 'Options: (1) revert the out-of-scope file, (2) restart with an expanded scope via `agentbridge start --scope "<wider-path>"`, or (3) run `agentbridge handoff` before switching to a new scoped job.',
+        why: "Out-of-scope edits are not safe to trust until reviewed or rescoped.",
+        next: 'Options: (1) revert the out-of-scope file, (2) widen strict scope via `agentbridge watch --task "<work>" --scope "<wider-path>"`, or (3) split into a separate task.',
         blocksAcceptance: true,
     },
     HANDOFF_REQUIRED: {
@@ -176,9 +176,12 @@ const CATALOG = {
         code: "START_MISSING_ACTIVE_AGENT",
         category: "IDENTITY_ERROR",
         title: "No active agent configured.",
-        what: "Neither activeAgentId nor --agent was provided for start.",
-        why: "Start must bind work to a WorkIdentity in this project.",
-        next: "Run `agentbridge identity list` then `agentbridge use <agent-id>`, or pass --agent.",
+        what: "Neither activeAgentId nor --agent was provided for strict tracked start.",
+        why: "Strict tracked work (--summary/--scope, --resume, or --change-request) must bind to a WorkIdentity in this project.",
+        next: [
+            "For strict tracked work: run `agentbridge identity list` then `agentbridge use <agent-id>`, or pass --agent.",
+            "For room-level watching only: run `agentbridge start` with no strict flags.",
+        ].join("\n"),
     },
     START_EXECUTION_SURFACE_REQUIRED: {
         code: "START_EXECUTION_SURFACE_REQUIRED",
@@ -237,10 +240,10 @@ const CATALOG = {
     START_CR_OWNERSHIP_MISMATCH: {
         code: "START_CR_OWNERSHIP_MISMATCH",
         category: "START_ERROR",
-        title: "Change request ownership mismatch.",
-        what: "The change request is owned by a different WorkIdentity than this API key.",
-        why: "Start cannot reassign an existing CR to another agent without authorization.",
-        next: "Use an API key bound to the CR owner, or start a new change request.",
+        title: "Tracked task belongs to another connected agent.",
+        what: "AgentBridge found an old tracked task owned by a different connected agent.",
+        why: "AgentBridge will not let one connected agent automatically take over another agent's tracked work.",
+        next: "Run `agentbridge watch` for live supervision, or switch back to the original connected agent if you intend to resume old tracked work.",
     },
     START_CR_NOT_EXECUTABLE: {
         code: "START_CR_NOT_EXECUTABLE",
@@ -293,6 +296,33 @@ const CATALOG = {
         next: "Run `agentbridge verify -- <command>` then `agentbridge check`.",
         blocksAcceptance: true,
     },
+    PROOF_TOO_WEAK: {
+        code: "PROOF_TOO_WEAK",
+        category: "PROOF_ERROR",
+        title: "Proof too weak.",
+        what: "Verification ran, but proof strength is below what this change requires.",
+        why: "High-risk or source changes need stronger proof than file-existence checks.",
+        next: "Rerun with a stronger command from proof guidance (e.g. `agentbridge verify -- npm test`).",
+        blocksAcceptance: true,
+    },
+    PROOF_NOT_RELEVANT: {
+        code: "PROOF_NOT_RELEVANT",
+        category: "PROOF_ERROR",
+        title: "Proof not relevant.",
+        what: "Recorded proof does not cover the files or impact of this change.",
+        why: "Proof must match the changed files — unrelated passing tests do not count.",
+        next: "Rerun verification scoped to the changed files listed in the acceptance report.",
+        blocksAcceptance: true,
+    },
+    PROOF_IMPACT_COVERAGE_GAP: {
+        code: "PROOF_IMPACT_COVERAGE_GAP",
+        category: "PROOF_ERROR",
+        title: "Proof impact coverage gap.",
+        what: "Proof exists but does not cover required impact areas for this work type.",
+        why: "Some change profiles require broader verification than a single lightweight check.",
+        next: "Run the minimum commands listed under proof guidance in `agentbridge check`.",
+        blocksAcceptance: true,
+    },
     PROOF_EVIDENCE_NOT_RECORDED: {
         code: "PROOF_EVIDENCE_NOT_RECORDED",
         category: "PROOF_ERROR",
@@ -341,7 +371,7 @@ const CATALOG = {
         title: "Work already closed.",
         what: "This change request or session is already in a terminal acceptance state.",
         why: "Accept and verify cannot mutate closed work.",
-        next: "Start a new scoped job with `agentbridge start`.",
+        next: "Run `agentbridge watch --allow-dirty` to review new coding work.",
         blocksAcceptance: true,
     },
     WORK_CONTEXT_SESSION_CR_MISMATCH: {
@@ -359,7 +389,7 @@ const CATALOG = {
         title: "Stale local session.",
         what: "Local session id no longer exists on the server.",
         why: "Watch and verify would track orphaned state.",
-        next: 'Local session state has been cleared. Run `agentbridge start --summary "<task>" --scope "<path>"` to begin fresh.',
+        next: 'Local session state has been cleared. Run `agentbridge watch --allow-dirty` to review current work.',
         blocksAcceptance: true,
     },
     WORK_CONTEXT_SCOPE_MISMATCH: {
@@ -368,7 +398,7 @@ const CATALOG = {
         title: "Session scope or task mismatch.",
         what: "The active session was started with a different task or scope than requested.",
         why: "Resuming the wrong session would silently corrupt proof and scope boundaries.",
-        next: 'Finish or abandon the current session (`agentbridge session abandon --reason "..."`) then rerun `agentbridge start --summary "<task>" --scope "<path>"`.',
+        next: 'Finish or abandon the current session (`agentbridge session abandon --reason "..."`) then rerun `agentbridge watch --task "<task>" --scope "<path>"`.',
         blocksAcceptance: true,
     },
     WORK_CONTEXT_AMBIGUOUS_SESSIONS: {
@@ -414,6 +444,9 @@ const SERVER_CODE_ALIASES = {
     proof_stale: "PROOF_STALE_AFTER_CHANGE",
     stale_evidence_after_change: "PROOF_STALE_AFTER_CHANGE",
     evidence_missing: "PROOF_MISSING",
+    proof_too_weak: "PROOF_TOO_WEAK",
+    proof_not_relevant: "PROOF_NOT_RELEVANT",
+    proof_impact_coverage_gap: "PROOF_IMPACT_COVERAGE_GAP",
     scope_drift: "SCOPE_DRIFT_OUT_OF_SCOPE_FILE",
     out_of_scope_file: "SCOPE_DRIFT_OUT_OF_SCOPE_FILE",
     cr_no_owner: "START_OWNER_UNRESOLVED",
@@ -424,11 +457,13 @@ const SERVER_CODE_ALIASES = {
     local_session_not_found: "WORK_CONTEXT_STALE_LOCAL_SESSION",
 };
 function mapServerCodeToCatalog(code) {
+    if (typeof code !== "string" || code.trim().length === 0)
+        return "";
     const normalized = code.toLowerCase();
     return SERVER_CODE_ALIASES[normalized] ?? code;
 }
 function catalogEntryForCode(code) {
-    if (!code)
+    if (!code || typeof code !== "string")
         return null;
     const direct = CATALOG[code];
     if (direct)

package/dist/gates.js

@@ -19,9 +19,9 @@ exports.ensureGatesFile = ensureGatesFile;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 exports.DEFAULT_GATES = {
-    rollout_proof_too_weak: "warn_only",
-    rollout_proof_not_relevant: "warn_only",
-    rollout_impact_coverage_gap: "warn_only",
+    rollout_proof_too_weak: "hard_fail",
+    rollout_proof_not_relevant: "hard_fail",
+    rollout_impact_coverage_gap: "hard_fail",
 };
 exports.STATS_HISTORY_CAP = 20;
 exports.GITIGNORE_SESSION_LINE = ".agentbridge/session.json";

package/dist/git-evidence.js

@@ -23,6 +23,8 @@ const PREFERRED_PREFIXES = [
     "db/",
     "prisma/",
     "supabase/",
+    "backend/",
+    "Hitch/",
     "lib/",
     "services/",
     "modules/",

package/dist/http.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliMissingConfigError = exports.CliHttpError = void 0;
 exports.isCliHttpError = isCliHttpError;
 exports.parseCliHttpErrorBody = parseCliHttpErrorBody;
+exports.extractHttpErrorCode = extractHttpErrorCode;
 exports.postJson = postJson;
 exports.putJson = putJson;
 exports.getJson = getJson;
@@ -33,6 +34,34 @@ function parseCliHttpErrorBody(err) {
     }
     return null;
 }
+/** Extract a string error code from a parsed HTTP error body (handles nested error objects). */
+function extractHttpErrorCode(parsed) {
+    if (!parsed)
+        return "";
+    const topCode = parsed["code"];
+    if (typeof topCode === "string" && topCode.trim().length > 0) {
+        return topCode.trim();
+    }
+    const err = parsed["error"];
+    if (typeof err === "string" && err.trim().length > 0) {
+        return err.trim();
+    }
+    if (err !== null && typeof err === "object" && !Array.isArray(err)) {
+        const nested = err["code"];
+        if (typeof nested === "string" && nested.trim().length > 0) {
+            return nested.trim();
+        }
+        const nestedMessage = err["message"];
+        if (typeof nestedMessage === "string" && nestedMessage.trim().length > 0) {
+            return nestedMessage.trim();
+        }
+    }
+    const message = parsed["message"];
+    if (typeof message === "string" && message.trim().length > 0) {
+        return message.trim();
+    }
+    return "";
+}
 class CliMissingConfigError extends Error {
     code = "CONFIG_INCOMPLETE";
     constructor(message) {

package/dist/index.js

@@ -30,9 +30,10 @@ const bug_1 = require("./commands/bug");
 const autopilot_1 = require("./commands/autopilot");
 const attention_1 = require("./commands/attention");
 const recover_1 = require("./commands/recover");
+const proof_guidance_1 = require("./commands/proof-guidance");
 const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
+const mcp_runtime_1 = require("./mcp-runtime");
 const errors_1 = require("./errors");
 const cli_failure_log_1 = require("./cli-failure-log");
 const session_state_1 = require("./session-state");
@@ -48,15 +49,19 @@ const COMMAND_HELP = {
         "    Run `agentbridge connect` first to save credentials.\n",
     use: "  agentbridge use <agent-id>\n" +
         "    Set the active agent identity used by `watch` and `start`.\n",
-    start: "  agentbridge start [\"intent\"] [\"scope\"]\n" +
-        "  Advanced: agentbridge start --summary \"<summary>\" --scope \"<path-or-glob>\" [--domain <name>] [--agent <id>] [--execution-surface <es_id>] [--change-request <cr_id>] [--resume]\n" +
-        "    Start supervised work. Without flags, proposes a smart work contract and asks for confirmation.\n" +
-        "    --resume  Continue the active change request/session instead of creating a new one.\n",
-    watch: "  agentbridge watch [--change-request <cr_id>] [--execution-surface <es_id>] [--allow-dirty] [--daemon] [--once]\n" +
-        "    Product entrypoint: AgentBridge infers coding context and reviews proof/scope risk.\n" +
-        "    --allow-dirty   Skip the pre-existing dirty-files prompt.\n" +
-        "    --daemon        Non-interactive mode: skip all prompts, auto-deny domain crossings.\n" +
-        "    --once          Run one startup/supervision pass and exit.\n",
+    start: "  agentbridge start [\"intent\"] [--details] [--yes]\n" +
+        "    Open or close a task checkpoint (not the live watcher).\n" +
+        "    For live supervision beside Cursor, run `agentbridge watch`.\n" +
+        "    Record proof: `agentbridge verify -- <test command>`.\n",
+    watch: "  agentbridge watch [--allow-dirty] [--once] [--daemon] [--details] [--task \"<summary>\"] [--scope \"<path>\"]\n" +
+        "    Primary live supervision command — run beside Cursor while the agent codes.\n" +
+        "    Shows MCP-declared intent and disk changes; warns on scope drift.\n" +
+        "    No --task or --scope required for normal use.\n" +
+        "    --task / --scope  Optional strict mode (both required together).\n" +
+        "    --allow-dirty     Skip the pre-existing dirty-files prompt.\n" +
+        "    --once            Run one supervision pass and exit.\n" +
+        "    --daemon          Non-interactive mode: skip prompts, auto-deny domain crossings.\n" +
+        "    --change-request / --execution-surface  Advanced session binding.\n",
     "setup-mcp": "  agentbridge setup-mcp [--editor cursor|windsurf|vscode]\n" +
         "    Print the MCP server configuration snippet to add to your editor.\n",
     mcp: "  agentbridge mcp\n" +
@@ -64,6 +69,8 @@ const COMMAND_HELP = {
     status: "  agentbridge status [--repair] [--json]\n    Show current work session status.\n",
     health: "  agentbridge health [--json]\n    Check project health against server.\n",
     check: "  agentbridge check [--json]\n    Check whether current work session can be accepted.\n",
+    "proof-guidance": "  agentbridge proof-guidance [--work-session <id>] [--change-request <id>] [--rollout-proof-too-weak warn_only|soft_fail|hard_fail]\n" +
+        "    Print deterministic proof guidance JSON for the current or specified session.\n",
     next: "  agentbridge next [--json]\n    Show the recommended next action.\n",
     verify: "  agentbridge verify [--json] -- <command>\n" +
         "    Run a command and verify output meets acceptance criteria.\n",
@@ -103,30 +110,26 @@ function usage(command, opts) {
         "Usage: agentbridge <command> [flags]",
         "",
         "Quick start:",
-        "  New repo:",
-        "    agentbridge doctor",
-        "    agentbridge start",
-        "  Existing repo:",
-        "    agentbridge doctor",
-        "    agentbridge recover",
-        "    agentbridge start",
+        "  agentbridge recover              Understand an existing repo (first time)",
+        "  agentbridge watch                Live supervision beside Cursor (primary watcher)",
+        "  agentbridge start [\"intent\"]     Task checkpoint / close (not the live watcher)",
+        "  agentbridge verify -- <command>  Record verification proof AgentBridge trusts",
         "",
-        "Commands:",
-        "  doctor         Check AgentBridge connection and repo readiness",
-        "  recover        Understand an existing repo before agents continue",
-        "  start          Start or attach to supervised agent work",
+        "Setup:",
+        "  agentbridge doctor               Check connection and repo readiness",
+        "  agentbridge connect              Save credentials (cloud projects)",
         "",
         "Advanced commands:",
-        "  connect        Save credentials and verify connection to a project",
+        "  start --task ... --scope ...     Strict scoped session (both flags required)",
         "  init           Recover domain map from git history and bootstrap the project",
         "  use            Set active agent identity",
-        "  watch          Watch for file changes (advanced/manual)",
-        "  start --summary ... --scope ...  Backward-compatible explicit start mode",
+        "  watch --task ... --scope ...     Strict scope mode (optional flags on watch)",
         "  setup-mcp      Print MCP server config for your editor",
         "  mcp            Start local MCP stdio server",
         "  status         Show current session status",
         "  health         Check project health",
         "  check          Check acceptance readiness",
+        "  proof-guidance Print deterministic proof guidance JSON",
         "  next           Show recommended next action",
         "  verify         Run command and verify output",
         "  handoff        Submit a handoff with proof of work",
@@ -269,27 +272,27 @@ async function main() {
         return;
     }
     if (command === "mcp") {
-        const repoRoot = (0, node_path_1.resolve)(__dirname, "..", "..");
-        const localMcpEntrypoint = (0, node_path_1.resolve)(repoRoot, "mcp", "agentbridge-mcp.ts");
-        if (!(0, node_fs_1.existsSync)(localMcpEntrypoint)) {
+        const runtime = (0, mcp_runtime_1.resolveMcpRuntime)(__dirname);
+        if (!runtime) {
             process.stderr.write([
                 "",
                 "AgentBridge MCP runtime is unavailable in this installation.",
                 "",
                 "Try:",
-                "  npm install -g @agentbridge/cli",
+                "  npm install -g @agentbridge1/cli@latest",
                 "  agentbridge doctor",
                 "",
             ].join("\n"));
             process.exit(2);
             return;
         }
-        const child = (0, node_child_process_1.spawnSync)("npx", ["tsx", localMcpEntrypoint], {
+        const child = (0, node_child_process_1.spawnSync)(runtime.command, runtime.args, {
             stdio: "inherit",
             env: process.env,
         });
         if (child.error) {
-            process.stderr.write(`Failed to start MCP server via npx/tsx: ${child.error.message}\n`);
+            const via = runtime.mode === "bundled" ? "node" : "npx/tsx";
+            process.stderr.write(`Failed to start MCP server via ${via}: ${child.error.message}\n`);
             process.exit(2);
             return;
         }
@@ -336,6 +339,7 @@ async function main() {
             allowDirty: flags["--allow-dirty"] === "true",
             daemon: flags["--daemon"] === "true",
             once: flags["--once"] === "true",
+            details: flags["--details"] === "true",
         });
         return;
     }
@@ -353,6 +357,8 @@ async function main() {
             executionSurfaceId: flags["--execution-surface"],
             changeRequestId: flags["--change-request"],
             resume: flags["--resume"] === "true",
+            details: flags["--details"] === "true",
+            confirmClose: flags["--yes"] === "true",
         });
         return;
     }
@@ -381,6 +387,16 @@ async function main() {
         await (0, check_1.runCheck)({ json: flags["--json"] === "true" });
         return;
     }
+    if (command === "proof-guidance") {
+        await (0, proof_guidance_1.runProofGuidance)({
+            workSessionId: flags["--work-session"],
+            changeRequestId: flags["--change-request"],
+            rolloutProofTooWeak: flags["--rollout-proof-too-weak"],
+            rolloutProofNotRelevant: flags["--rollout-proof-not-relevant"],
+            rolloutImpactCoverageGap: flags["--rollout-impact-coverage-gap"],
+        });
+        return;
+    }
     if (command === "next") {
         await (0, next_1.runNext)({ json: flags["--json"] === "true" });
         return;

package/dist/init.js

@@ -5,6 +5,7 @@ exports.refineRecoveredDomains = refineRecoveredDomains;
 exports.writeLocalRulesArtifacts = writeLocalRulesArtifacts;
 exports.buildBootstrapPayloadFromEvidence = buildBootstrapPayloadFromEvidence;
 exports.runInit = runInit;
+exports.scanRecoveryFromRepo = scanRecoveryFromRepo;
 exports.runBootstrapRecovery = runBootstrapRecovery;
 const promises_1 = require("node:readline/promises");
 const node_child_process_1 = require("node:child_process");
@@ -16,6 +17,7 @@ const git_evidence_1 = require("./git-evidence");
 const config_1 = require("./config");
 const watch_core_1 = require("./watch-core");
 const precommit_1 = require("./precommit");
+const recovery_reconcile_1 = require("./recovery-reconcile");
 const WORKFLOW_SUMMARY = "Recover domains from repository evidence, map ownership boundaries, enforce lane discipline, and require authority requests before cross-domain edits.";
 const KNOWN_DOMAIN_LABELS = {
     communications: "Communications",
@@ -126,9 +128,26 @@ function deriveDomainKeyFromPath(path) {
     if (normalized.startsWith("db/") || normalized.startsWith("prisma/") || normalized.startsWith("supabase/")) {
         return "database";
     }
+    if (normalized.startsWith("backend/supabase/") ||
+        normalized.includes("/supabase/functions/") ||
+        normalized.includes("/supabase/migrations/")) {
+        return "database";
+    }
     if (/^supabase_.*\.sql$/i.test(normalized)) {
         return "database";
     }
+    const xcodeAppMatch = normalized.match(/^([^/]+)\/\1\//);
+    if (xcodeAppMatch) {
+        const appName = normalizeToken(xcodeAppMatch[1] ?? "");
+        if (appName)
+            return appName;
+    }
+    const topLevelMatch = normalized.match(/^([^/]+)\//);
+    if (topLevelMatch) {
+        const top = normalizeToken(topLevelMatch[1] ?? "");
+        if (top === "backend")
+            return "backend";
+    }
     return null;
 }
 function extractDomainPrefix(path) {
@@ -147,8 +166,18 @@ function extractDomainPrefix(path) {
         return "prisma/";
     if (normalized.startsWith("supabase/"))
         return "supabase/";
+    if (normalized.startsWith("backend/supabase/"))
+        return "backend/supabase/";
     if (/^supabase_.*\.sql$/i.test(normalized))
         return "supabase_*.sql";
+    const xcodeAppMatch = normalized.match(/^([^/]+)\/\1\//);
+    if (xcodeAppMatch) {
+        return `${xcodeAppMatch[1]}/${xcodeAppMatch[1]}/`;
+    }
+    const topLevelMatch = normalized.match(/^([^/]+)\//);
+    if (topLevelMatch?.[1] === "backend") {
+        return "backend/";
+    }
     return null;
 }
 function classifyDomainKey(path) {
@@ -218,6 +247,19 @@ function collectWorkspaceDomainSeeds() {
             seeds.add("database");
         }
     }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(process.cwd(), "backend", "supabase"))) {
+        seeds.add("database");
+    }
+    for (const topLevelEntry of (0, node_fs_1.readdirSync)(process.cwd(), { withFileTypes: true })) {
+        if (!topLevelEntry.isDirectory())
+            continue;
+        const nestedSameName = (0, node_path_1.resolve)(process.cwd(), topLevelEntry.name, topLevelEntry.name);
+        if ((0, node_fs_1.existsSync)(nestedSameName)) {
+            const folder = normalizeToken(topLevelEntry.name);
+            if (folder)
+                seeds.add(folder);
+        }
+    }
     return Array.from(seeds);
 }
 function refineRecoveredDomains(inferredClusters, evidence, architectureDomains) {
@@ -366,14 +408,42 @@ function toCursorRule(domains) {
         "",
     ].join("\n");
 }
-function writeLocalRulesArtifacts(domains) {
+function writeLocalRulesArtifacts(domains, opts = {}) {
     const md = toRulesMarkdown(domains);
     const cursorRule = toCursorRule(domains);
     const rootFile = (0, node_path_1.resolve)(process.cwd(), "AGENTBRIDGE.md");
     const cursorRulesDir = (0, node_path_1.resolve)(process.cwd(), ".cursor", "rules");
+    const cursorFile = (0, node_path_1.resolve)(cursorRulesDir, "agentbridge.mdc");
+    const mdTarget = `${md}\n`;
+    const cursorTarget = `${cursorRule}\n`;
+    if ((0, node_fs_1.existsSync)(rootFile) && (0, node_fs_1.existsSync)(cursorFile) && !opts.force) {
+        const existingMd = (0, node_fs_1.readFileSync)(rootFile, "utf8");
+        const existingCursor = (0, node_fs_1.readFileSync)(cursorFile, "utf8");
+        if (existingMd === mdTarget && existingCursor === cursorTarget) {
+            return { wrote: false, skipped: true, reason: "already up to date" };
+        }
+        if (!existingMd.startsWith("# AgentBridge Local Rules") ||
+            !existingCursor.includes("Recovered domains:")) {
+            return { wrote: false, skipped: true, reason: "local edits preserved" };
+        }
+    }
     (0, node_fs_1.mkdirSync)(cursorRulesDir, { recursive: true });
-    (0, node_fs_1.writeFileSync)(rootFile, `${md}\n`, "utf8");
-    (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(cursorRulesDir, "agentbridge.mdc"), `${cursorRule}\n`, "utf8");
+    (0, node_fs_1.writeFileSync)(rootFile, mdTarget, "utf8");
+    (0, node_fs_1.writeFileSync)(cursorFile, cursorTarget, "utf8");
+    return { wrote: true, skipped: false };
+}
+function refsToBootstrapDomains(refs) {
+    return refs.map((ref) => ({
+        name: ref.name,
+        pathPatterns: ref.pathPatterns.length > 0 ? ref.pathPatterns : [`${ref.name.toLowerCase()}/`],
+        files: [],
+        evidenceSource: "git_history",
+        confidence: 0.72,
+        protectionTier: (0, watch_core_1.inferTierFromDomainName)(ref.name),
+        knownTraps: [],
+        relatedDomains: [],
+        openRisks: [],
+    }));
 }
 async function buildBootstrapPayloadFromEvidence(ctx, productSummary, architectureDomains, evidence) {
     const clusterResult = await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/recovery/evidence`, evidence);
@@ -484,16 +554,12 @@ async function runInit(ctx) {
         rl.close();
     }
 }
-async function runBootstrapRecovery(ctx, opts = {}) {
+async function scanRecoveryFromRepo(ctx, opts = {}) {
     assertInsideGitRepo();
-    const runtimeCliPath = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : undefined;
-    const hookCliPath = runtimeCliPath ?? (0, node_path_1.resolve)(__dirname, "index.js");
     const productSummary = opts.productSummary?.trim() || "Recovered existing repository baseline for supervised agent work.";
     const architectureDomains = opts.architectureDomains ?? [];
     const collectedEvidence = (0, git_evidence_1.collectGitEvidence)();
-    const evidence = collectedEvidence.payload;
-    const { inferredClusters, payload: bootstrapPayload } = await buildBootstrapPayloadFromEvidence(ctx, productSummary, architectureDomains, evidence);
-    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/bootstrap`, bootstrapPayload);
+    const { inferredClusters, payload: bootstrapPayload } = await buildBootstrapPayloadFromEvidence(ctx, productSummary, architectureDomains, collectedEvidence.payload);
     const recoveredDomains = inferredClusters
         .filter(isValidAuthorityDomain)
         .map((cluster) => ({
@@ -502,25 +568,65 @@ async function runBootstrapRecovery(ctx, opts = {}) {
         ownerAgentId: `${cluster.suggested_name} Agent`,
         tier: cluster.protection_tier ?? (0, watch_core_1.inferTierFromDomainName)(cluster.suggested_name),
     }));
+    const candidateRefs = recoveredDomains.map((domain) => ({
+        name: domain.domain,
+        pathPatterns: domain.pathPatterns,
+    }));
+    return { inferredClusters, bootstrapPayload, recoveredDomains, candidateRefs };
+}
+async function runBootstrapRecovery(ctx, opts = {}) {
+    assertInsideGitRepo();
+    const runtimeCliPath = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : undefined;
+    const hookCliPath = runtimeCliPath ?? (0, node_path_1.resolve)(__dirname, "index.js");
+    const scan = opts.scan ??
+        (await scanRecoveryFromRepo(ctx, {
+            productSummary: opts.productSummary,
+            architectureDomains: opts.architectureDomains,
+        }));
+    const { inferredClusters, bootstrapPayload, recoveredDomains } = scan;
+    if (opts.reconcilePlan) {
+        const candidateBootstrap = toBootstrapDomains(scan.candidateRefs.map((ref) => ({
+            name: ref.name,
+            files: [],
+            pathPatterns: ref.pathPatterns,
+            confidence: 0.72,
+            protectionTier: (0, watch_core_1.inferTierFromDomainName)(ref.name),
+            knownTraps: [],
+            rationale: "candidate from repository scan",
+        })));
+        const existingBootstrap = refsToBootstrapDomains(opts.reconcilePlan.existingActive);
+        bootstrapPayload.domains = (0, recovery_reconcile_1.mergeBootstrapDomainEntries)(opts.reconcilePlan, candidateBootstrap, existingBootstrap);
+    }
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/bootstrap`, bootstrapPayload);
+    const payloadDomains = Array.isArray(bootstrapPayload.domains)
+        ? bootstrapPayload.domains
+        : [];
+    const payloadDomainKeys = new Set(payloadDomains.map((d) => (d.name ?? "").trim().toLowerCase()).filter(Boolean));
+    const mergedLocalDomains = payloadDomainKeys.size > 0
+        ? recoveredDomains.filter((d) => payloadDomainKeys.has(d.domain.trim().toLowerCase()))
+        : recoveredDomains;
     (0, config_1.updateConfig)({
         apiBaseUrl: ctx.apiBaseUrl,
         projectId: ctx.projectId,
-        domains: recoveredDomains,
+        domains: (0, watch_core_1.toDomainOwnershipInput)(mergedLocalDomains),
         cliPath: runtimeCliPath,
     });
-    writeLocalRulesArtifacts(recoveredDomains.map((domain) => ({
+    writeLocalRulesArtifacts(mergedLocalDomains.map((domain) => ({
         domain: domain.domain,
         owner: domain.ownerAgentId,
         tier: domain.tier,
-    })));
+    })), { force: opts.reconcilePlan?.mode === "force" });
     if (opts.installHook) {
         (0, precommit_1.installPrecommitHookWithPath)(hookCliPath);
         (0, config_1.updateConfig)({ precommitHookInstalled: true, cliPath: runtimeCliPath });
     }
-    node_process_1.stdout.write([
-        "Recovery baseline created.",
-        `Domains mapped: ${recoveredDomains.length}.`,
-        "Project context and local rules are now ready.",
-        "",
-    ].join("\n"));
+    if (!opts.reconcilePlan) {
+        node_process_1.stdout.write([
+            "Recovery baseline created.",
+            `Domains mapped: ${mergedLocalDomains.length}.`,
+            "Project context and local rules are now ready.",
+            "",
+        ].join("\n"));
+    }
+    return { recoveredDomains: mergedLocalDomains };
 }

package/dist/local-memory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLocalMemory = writeLocalMemory;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MEMORY_DIR = (0, node_path_1.resolve)(process.cwd(), ".agentbridge", "memory");
+function summarizeProof(state) {
+    const run = state.lastLocalVerificationRun;
+    if (!run) {
+        return state.changedFiles.length > 0 ? { status: "missing" } : { status: "none" };
+    }
+    if (run.exitCode !== 0) {
+        return { status: "failed", command: run.command, finishedAt: run.finishedAt };
+    }
+    return { status: "ok", command: run.command, finishedAt: run.finishedAt };
+}
+function writeLocalMemory(state, options) {
+    const closedAt = state.closedAt ?? new Date().toISOString();
+    const record = {
+        sessionId: state.id,
+        intent: state.intent?.trim() || "Untitled task",
+        mode: state.mode ?? "local_supervision",
+        changedFiles: [...state.changedFiles].sort(),
+        proofSummary: summarizeProof(state),
+        openedAt: state.startedAt ?? state.createdAt,
+        closedAt,
+        cloudSync: options.cloudSync,
+    };
+    (0, node_fs_1.mkdirSync)(MEMORY_DIR, { recursive: true });
+    const filePath = (0, node_path_1.resolve)(MEMORY_DIR, `${state.id}.json`);
+    (0, node_fs_1.writeFileSync)(filePath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    return filePath;
+}