@agentbridge1/cli 0.0.5 → 0.0.7

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,75 @@ 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);
+    }
+    if (process.env.AGENTBRIDGE_DEBUG_HTTP === "1") {
+        const payloadDomains = Array.isArray(bootstrapPayload.domains)
+            ? bootstrapPayload.domains
+            : [];
+        const mappedPathCount = payloadDomains.reduce((count, domain) => {
+            const paths = domain.files && domain.files.length > 0 ? domain.files : domain.pathPatterns;
+            return count + (Array.isArray(paths) ? paths.length : 0);
+        }, 0);
+        process.stderr.write(`[agentbridge:recover] bootstrap POST project=${ctx.projectId} domains=${payloadDomains.length} mapped_paths=${mappedPathCount} product_summary_len=${String(bootstrapPayload.product_summary ?? "").length}\n`);
+    }
+    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;
+}

package/dist/local-proof.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProofNoiseFile = isProofNoiseFile;
+exports.normalizeProofMatchingFileSet = normalizeProofMatchingFileSet;
+exports.fingerprintSetKeyForPaths = fingerprintSetKeyForPaths;
+exports.evaluateLocalProof = evaluateLocalProof;
+exports.buildLocalProofBlockingIssue = buildLocalProofBlockingIssue;
+exports.isLocalVerificationRun = isLocalVerificationRun;
+const file_fingerprints_1 = require("./file-fingerprints");
+function normalizePath(path) {
+    return path.trim().replaceAll("\\", "/");
+}
+function isProofNoiseFile(file) {
+    const normalized = normalizePath(file).toLowerCase();
+    return (normalized === "agentbridge.md" ||
+        normalized === ".cursor" ||
+        normalized.startsWith(".cursor/"));
+}
+function normalizeProofMatchingFileSet(files) {
+    return [...new Set(files.map(normalizePath).filter((file) => file.length > 0 && !isProofNoiseFile(file)))].sort();
+}
+function fingerprintValue(fingerprint) {
+    if (!fingerprint.exists)
+        return "missing";
+    if (fingerprint.sha256)
+        return `sha:${fingerprint.sha256}`;
+    return `meta:${fingerprint.fileType ?? "unknown"}:${fingerprint.size ?? -1}:${Math.trunc(fingerprint.mtimeMs ?? -1)}`;
+}
+function fingerprintSetKeyForPaths(paths, fingerprints) {
+    const normalizedPaths = normalizeProofMatchingFileSet(paths);
+    if (normalizedPaths.length === 0)
+        return "";
+    const map = new Map(fingerprints.map((fingerprint) => [normalizePath(fingerprint.path), fingerprint]));
+    const entries = [];
+    for (const path of normalizedPaths) {
+        const fingerprint = map.get(path);
+        if (!fingerprint)
+            return null;
+        entries.push(`${path}=>${fingerprintValue(fingerprint)}`);
+    }
+    return entries.join("\n");
+}
+function evaluateLocalProof(changedFiles, lastRun) {
+    const normalizedChanged = normalizeProofMatchingFileSet(changedFiles);
+    if (normalizedChanged.length === 0) {
+        return { decision: "ok", changedFiles: [], staleFiles: [] };
+    }
+    if (!lastRun) {
+        return { decision: "needs_proof", changedFiles: normalizedChanged, staleFiles: [] };
+    }
+    if (lastRun.status !== "passed") {
+        return { decision: "failed", changedFiles: normalizedChanged, staleFiles: normalizedChanged };
+    }
+    const currentKey = fingerprintSetKeyForPaths(normalizedChanged, (0, file_fingerprints_1.computeFileFingerprints)(normalizedChanged));
+    const proofKey = fingerprintSetKeyForPaths(lastRun.proofScopeFiles, lastRun.proofScopeFingerprints);
+    if (currentKey === null || proofKey === null || currentKey !== proofKey) {
+        const proofScopeSet = new Set(normalizeProofMatchingFileSet(lastRun.proofScopeFiles));
+        const staleFiles = normalizedChanged.filter((file) => {
+            if (!proofScopeSet.has(file))
+                return true;
+            const currentFp = (0, file_fingerprints_1.computeFileFingerprints)([file])[0];
+            const proofFp = lastRun.proofScopeFingerprints.find((fp) => normalizePath(fp.path) === file);
+            if (!proofFp)
+                return true;
+            return fingerprintValue(currentFp) !== fingerprintValue(proofFp);
+        });
+        return {
+            decision: "stale_evidence",
+            changedFiles: normalizedChanged,
+            staleFiles: staleFiles.length > 0 ? staleFiles : normalizedChanged,
+        };
+    }
+    return { decision: "ok", changedFiles: normalizedChanged, staleFiles: [] };
+}
+function buildLocalProofBlockingIssue(evaluation) {
+    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)`;
+    };
+    if (evaluation.decision === "ok")
+        return null;
+    if (evaluation.decision === "stale_evidence") {
+        const staleFiles = [...new Set(evaluation.staleFiles)];
+        return {
+            errorCode: "PROOF_STALE_AFTER_CHANGE",
+            whatHappened: "Verification proof is stale because files changed after the last passing verify.",
+            whyItMatters: "Proof must match the final edited files before you can trust the agent is done.",
+            files: staleFiles,
+            suggestedPrompt: [
+                "Your proof is stale because files changed after verification.",
+                "Rerun verification after your final edit: agentbridge verify -- <test command>",
+                `Files: ${summarizePromptFiles(staleFiles)}`,
+            ].join("\n"),
+            nextAction: "Run: agentbridge verify -- <your test command>",
+        };
+    }
+    if (evaluation.decision === "failed") {
+        return {
+            errorCode: "VERIFICATION_FAILED",
+            whatHappened: "The last verification command failed.",
+            whyItMatters: "Failed verification cannot count as proof.",
+            files: evaluation.changedFiles,
+            suggestedPrompt: [
+                "The last verification command failed.",
+                "Fix the failure and rerun verification with a passing result: agentbridge verify -- <test command>",
+            ].join("\n"),
+            nextAction: "Run: agentbridge verify -- <your test command>",
+        };
+    }
+    const files = [...new Set(evaluation.changedFiles)];
+    return {
+        errorCode: "PROOF_MISSING",
+        whatHappened: "Coding changes were detected with no passing verification proof.",
+        whyItMatters: "Changed files need a recorded verify command before they are safe to trust.",
+        files,
+        suggestedPrompt: [
+            `AgentBridge found ${files.length} changed files without proof.`,
+            "Run verification for the changed files: agentbridge verify -- <test command>",
+            `Files: ${summarizePromptFiles(files)}`,
+        ].join("\n"),
+        nextAction: "Run: agentbridge verify -- <your test command>",
+    };
+}
+function isLocalVerificationRun(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const row = value;
+    if (typeof row.command !== "string" || row.command.length === 0)
+        return false;
+    if (typeof row.startedAt !== "string" || row.startedAt.length === 0)
+        return false;
+    if (typeof row.finishedAt !== "string" || row.finishedAt.length === 0)
+        return false;
+    if (typeof row.exitCode !== "number" || !Number.isFinite(row.exitCode))
+        return false;
+    if (typeof row.stdoutExcerpt !== "string")
+        return false;
+    if (typeof row.stderrExcerpt !== "string")
+        return false;
+    if (typeof row.gitHead !== "string")
+        return false;
+    if (!Array.isArray(row.repoDirtySnapshot) || !row.repoDirtySnapshot.every((entry) => typeof entry === "string")) {
+        return false;
+    }
+    if (!Array.isArray(row.proofScopeFiles) || !row.proofScopeFiles.every((entry) => typeof entry === "string")) {
+        return false;
+    }
+    if (!Array.isArray(row.proofScopeFingerprints))
+        return false;
+    if (row.status !== "passed" && row.status !== "failed")
+        return false;
+    return true;
+}

package/dist/local-session-mirror.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAgentActivityMerge = applyAgentActivityMerge;
+exports.mirrorMcpLifecycleEvent = mirrorMcpLifecycleEvent;
+exports.buildMirrorPatchFromMcp = buildMirrorPatchFromMcp;
+exports.mirrorMcpToolSuccess = mirrorMcpToolSuccess;
+const session_1 = require("./session");
+const session_state_1 = require("./session-state");
+function uniquePaths(paths) {
+    return [...new Set(paths.map((p) => p.trim()).filter(Boolean))].sort();
+}
+function truncateSummary(text, max = 120) {
+    const trimmed = text.trim();
+    if (trimmed.length <= max)
+        return trimmed;
+    return `${trimmed.slice(0, max - 1)}…`;
+}
+function mergeClaimedPaths(existing, incoming) {
+    return uniquePaths([...existing, ...incoming]);
+}
+function effectiveClaimedPaths(state, patch) {
+    const base = state.claimedPaths ?? [];
+    const fromActivity = state.agentActivity?.claimedPaths ?? [];
+    const incoming = patch.claimedPaths ?? [];
+    return mergeClaimedPaths(mergeClaimedPaths(base, fromActivity), incoming);
+}
+function buildAgentActivity(state, patch, now) {
+    const claimedPaths = patch.claimedPaths?.length
+        ? mergeClaimedPaths(state.agentActivity?.claimedPaths ?? [], patch.claimedPaths)
+        : state.agentActivity?.claimedPaths;
+    const activity = {
+        source: "mcp",
+        updatedAt: now,
+        lastEvent: patch.event,
+        workSessionId: patch.workSessionId ?? state.agentActivity?.workSessionId ?? state.serverSessionId,
+        changeRequestId: patch.changeRequestId ?? state.agentActivity?.changeRequestId ?? state.changeRequestId,
+        intent: patch.intent ?? state.agentActivity?.intent ?? state.intent,
+        claimedPaths,
+        laneDomain: patch.laneDomain !== undefined ? patch.laneDomain : state.agentActivity?.laneDomain,
+        laneId: patch.laneId ?? state.agentActivity?.laneId,
+        laneType: patch.laneType ?? state.agentActivity?.laneType,
+        laneValue: patch.laneValue ?? state.agentActivity?.laneValue,
+        summary: patch.summary !== undefined ? truncateSummary(patch.summary) : state.agentActivity?.summary,
+        handoffId: patch.handoffId ?? state.agentActivity?.handoffId,
+        closedAt: patch.closeSession ? now : state.agentActivity?.closedAt,
+    };
+    return activity;
+}
+function createShellSession(patch, now) {
+    const baseline = (0, session_1.captureLocalSessionBaseline)();
+    const claimedPaths = uniquePaths(patch.claimedPaths ?? []);
+    return {
+        id: `local_${Date.now().toString(36)}`,
+        agentId: "mcp",
+        laneDomain: patch.laneDomain ?? null,
+        intent: patch.intent?.trim() || undefined,
+        changeRequestId: patch.changeRequestId,
+        claimedPaths,
+        status: "active",
+        changedFiles: [],
+        crossings: [],
+        approvals: [],
+        domains: [],
+        serverSessionId: patch.workSessionId,
+        createdAt: baseline.startedAt,
+        updatedAt: now,
+        startedAt: baseline.startedAt,
+        gitHead: baseline.gitHead,
+        dirtyFilesAtStart: baseline.dirtyFilesAtStart,
+        fingerprintsAtStart: baseline.fingerprintsAtStart,
+    };
+}
+/** Pure merge for tests — does not write disk. */
+function applyAgentActivityMerge(existing, patch, now = new Date().toISOString()) {
+    const needsNew = !existing || existing.status === "closed" || (patch.event === "start_work_session" && existing.status !== "active");
+    let state;
+    if (needsNew && patch.event !== "close_work_session") {
+        state = createShellSession(patch, now);
+    }
+    else if (!existing) {
+        state = createShellSession(patch, now);
+    }
+    else {
+        state = { ...existing };
+    }
+    const agentActivity = buildAgentActivity(state, patch, now);
+    state.agentActivity = agentActivity;
+    state.updatedAt = now;
+    if (patch.workSessionId) {
+        state.serverSessionId = patch.workSessionId;
+    }
+    if (patch.changeRequestId) {
+        state.changeRequestId = patch.changeRequestId;
+    }
+    if (patch.intent?.trim()) {
+        state.intent = patch.intent.trim();
+    }
+    const mergedClaimed = effectiveClaimedPaths(state, patch);
+    if (mergedClaimed.length > 0) {
+        state.claimedPaths = mergedClaimed;
+    }
+    if (patch.laneDomain !== undefined) {
+        state.laneDomain = patch.laneDomain;
+    }
+    if (patch.closeSession) {
+        state.status = "closed";
+        state.closedAt = now;
+    }
+    else if (state.status === "closed" && patch.event === "start_work_session") {
+        state.status = "active";
+        state.closedAt = undefined;
+    }
+    return state;
+}
+/** Mirror MCP lifecycle success into `.agentbridge/session.json`. Never throws. */
+function mirrorMcpLifecycleEvent(patch) {
+    try {
+        const existing = (0, session_state_1.readSessionState)();
+        const now = new Date().toISOString();
+        const next = applyAgentActivityMerge(existing, patch, now);
+        (0, session_state_1.writeSessionState)(next);
+    }
+    catch {
+        // Swallow — MCP tools must not fail on mirror errors.
+    }
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function laneDomainFromArgs(args) {
+    const type = typeof args.type === "string" ? args.type : undefined;
+    const value = typeof args.value === "string" ? args.value : undefined;
+    if (type === "product_area" && value)
+        return value;
+    return null;
+}
+function buildMirrorPatchFromMcp(toolName, args, json) {
+    switch (toolName) {
+        case "start_work_session": {
+            const status = typeof json.status === "string" ? json.status : "";
+            if (status === "pending_boundary_approval" || status === "blocked")
+                return null;
+            const workSessionId = typeof json.id === "string" ? json.id : undefined;
+            const intent = typeof args.intent === "string" ? args.intent : undefined;
+            const changeRequestId = typeof args.change_request_id === "string" ? args.change_request_id : undefined;
+            const claimedPaths = asStringArray(args.claimed_paths);
+            return {
+                event: "start_work_session",
+                workSessionId,
+                changeRequestId,
+                intent,
+                claimedPaths,
+                summary: intent,
+            };
+        }
+        case "start_recovery_bootstrap_session": {
+            const workSessionId = typeof json.work_session_id === "string"
+                ? json.work_session_id
+                : typeof json.id === "string"
+                    ? json.id
+                    : undefined;
+            const intent = typeof args.intent === "string" ? args.intent : "recovery bootstrap";
+            const claimedPaths = asStringArray(args.claimed_paths);
+            return {
+                event: "start_work_session",
+                workSessionId,
+                intent,
+                claimedPaths,
+                summary: intent,
+            };
+        }
+        case "claim_lane": {
+            const workSessionId = typeof args.work_session_id === "string"
+                ? args.work_session_id
+                : typeof json.work_session_id === "string"
+                    ? json.work_session_id
+                    : undefined;
+            const changedFiles = asStringArray(args.changed_files);
+            const type = typeof args.type === "string" ? args.type : undefined;
+            const value = typeof args.value === "string" ? args.value : undefined;
+            const laneId = typeof json.id === "string" ? json.id : undefined;
+            return {
+                event: "claim_lane",
+                workSessionId,
+                claimedPaths: changedFiles,
+                laneDomain: laneDomainFromArgs(args),
+                laneId,
+                laneType: type,
+                laneValue: value,
+                summary: value ? `claimed ${type ?? "lane"}: ${value}` : "claimed lane",
+            };
+        }
+        case "release_lane":
+            return {
+                event: "release_lane",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                laneId: typeof args.lane_id === "string" ? args.lane_id : undefined,
+                summary: "released lane",
+            };
+        case "update_work_session_scope": {
+            const additional = asStringArray(args.additional_paths);
+            return {
+                event: "update_work_session_scope",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                claimedPaths: additional,
+                summary: additional.length > 0 ? `scope +${additional.length} path(s)` : "updated scope",
+            };
+        }
+        case "post_handoff": {
+            const handoffId = typeof json.id === "string" ? json.id : undefined;
+            const summary = typeof args.completed === "string"
+                ? args.completed
+                : typeof args.summary === "string"
+                    ? args.summary
+                    : typeof args.handoff_summary === "string"
+                        ? args.handoff_summary
+                        : "handoff posted";
+            return {
+                event: "post_handoff",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                handoffId,
+                summary,
+            };
+        }
+        case "close_work_session":
+            return {
+                event: "close_work_session",
+                workSessionId: typeof args.work_session_id === "string" ? args.work_session_id : undefined,
+                summary: typeof args.note === "string"
+                    ? args.note
+                    : typeof args.summary === "string"
+                        ? args.summary
+                        : "session closed",
+                closeSession: true,
+            };
+        default:
+            return null;
+    }
+}
+function mirrorMcpToolSuccess(toolName, args, json) {
+    const patch = buildMirrorPatchFromMcp(toolName, args, json);
+    if (!patch)
+        return;
+    mirrorMcpLifecycleEvent(patch);
+}