@miraland-labs/conduit-bridge 0.16.3 → 0.16.4

package/dist/execution.js

@@ -12,7 +12,8 @@ import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
 import { ensureLandCommit } from "./ensure-land-commit.js";
-import { AgentNoLandCommitError, requiresLandCommit } from "./land-contract.js";
+import { AgentNoLandCommitError, agentNoLandCommitMessage, requiresLandCommit } from "./land-contract.js";
+import { agentClaimsRepositoryWork, claimsVsGitMismatch, isLandTreeEmpty, reportClaimsRepositoryWork, } from "./land-git-reality.js";
 const execFileAsync = promisify(execFile);
 import { captureVerificationFailure, ensureTestEvidence } from "./ensure-test-evidence.js";
 /** Keep a Mac awake only while an assignment is active; display sleep remains allowed. */
@@ -871,105 +872,251 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             }
         }
         let agentSessionId = result.sessionId ?? undefined;
-        let report;
         let reportText = result.resultText ?? "";
+        let landContinuationUsed = false;
+        if (await claimsVsGitMismatch({
+            workspace: attemptWorkspace,
+            spec,
+            grants,
+            agentReply: reportText,
+        })) {
+            const continuation = await runLandContinuationTurn({
+                client,
+                taskId,
+                attemptId: active.attemptId,
+                workspace: attemptWorkspace,
+                spec,
+                grants,
+                driver,
+                capabilities: spec.required_capabilities ?? [],
+                verificationCommands: attemptBrief?.verification ?? [],
+                objective: task.objective,
+                selection,
+                fuel,
+                fuelSource,
+                timeoutMs,
+                resumeSessionId: agentSessionId,
+                reason: "Agent claimed repository work but git shows none on the attempt branch; starting one land-only continuation turn instead of report-only repair.",
+                idempotencyKey: `bridge:progress:${active.attemptId}:claims-git-gate`,
+            });
+            landContinuationUsed = true;
+            if (continuation.sessionId) {
+                config.sessions = { ...config.sessions, [taskId]: continuation.sessionId };
+                agentSessionId = continuation.sessionId;
+            }
+            reportText = continuation.resultText;
+        }
+        let report;
         try {
             report = parseAgentReport(reportText, spec.acceptance ?? []);
         }
         catch (error) {
-            // Pump fuel keeps one repair turn. Local-fuel Experimental lanes (Pi et al.) get a second
-            // read-only repair — truncated JSON fences are common there and re-implementing is wasteful.
-            const maxRepairs = fuelSource === "local" ? 2 : 1;
-            let parseError = error instanceof Error ? error.message : "Agent delivery report was invalid";
-            let previousReply = reportText;
-            let resumeSessionId = result.sessionId ?? undefined;
-            let repaired = null;
-            let parsed = null;
-            for (let repairTurn = 1; repairTurn <= maxRepairs; repairTurn++) {
-                const replyDigest = createHash("sha256").update(previousReply).digest("hex");
-                await client.attemptRequest(taskId, "progress", {
-                    phase: "preparing_delivery",
-                    message: `Delivery envelope invalid (${redactSecrets(parseError)}); starting report-only repair turn ${repairTurn}/${maxRepairs} without rerunning implementation. Original reply: ${previousReply.length} characters, sha256:${replyDigest}.`,
-                    idempotency_key: `bridge:progress:${active.attemptId}:delivery-repair:${repairTurn}`,
-                });
-                try {
-                    repaired = await driver.run({
-                        prompt: buildDeliveryRepairPrompt(parseError, previousReply, spec.acceptance ?? []),
+            const gitEmpty = await isLandTreeEmpty({ workspace: attemptWorkspace, spec, grants });
+            const claimsWork = agentClaimsRepositoryWork(reportText);
+            if (requiresLandCommit({ grants, spec }) && gitEmpty && claimsWork) {
+                if (!landContinuationUsed) {
+                    const continuation = await runLandContinuationTurn({
+                        client,
+                        taskId,
+                        attemptId: active.attemptId,
                         workspace: attemptWorkspace,
-                        // Preserve only existing read authority. No write, test, branch, or push
-                        // capability is available while the agent repairs the response envelope.
-                        grants: grants.filter((grant) => grant === "repo_read"),
-                        capabilities: [],
-                        verificationCommands: [],
-                        // Envelope repair is read-only observe authority regardless of the original class.
-                        executionClass: "observe",
-                        resumeSessionId,
-                        timeoutMs,
-                        model: selection.model,
+                        spec,
+                        grants,
+                        driver,
+                        capabilities: spec.required_capabilities ?? [],
+                        verificationCommands: attemptBrief?.verification ?? [],
+                        objective: task.objective,
+                        selection,
                         fuel,
                         fuelSource,
+                        timeoutMs,
+                        resumeSessionId: agentSessionId,
+                        reason: "Agent claimed repository work but git shows none; starting land-only continuation instead of read-only report repair.",
+                        idempotencyKey: `bridge:progress:${active.attemptId}:claims-git-gate-parse`,
                     });
-                }
-                catch (repairError) {
-                    const message = repairError instanceof Error ? repairError.message : "Delivery report repair failed";
-                    await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair failed: ${message}`, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
-                    console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
-                    return;
-                }
-                if (repaired.sessionId) {
-                    config.sessions = { ...config.sessions, [taskId]: repaired.sessionId };
-                    resumeSessionId = repaired.sessionId;
-                    agentSessionId = repaired.sessionId;
-                }
-                if (repaired.status === "failed") {
-                    const message = repaired.error ?? "Delivery report repair failed";
-                    await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
-                    console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
-                    return;
-                }
-                previousReply = repaired.resultText ?? "";
-                try {
-                    parsed = parseAgentReport(previousReply, spec.acceptance ?? []);
-                    break;
-                }
-                catch (repairError) {
-                    parseError = repairError instanceof Error ? repairError.message : "Repaired delivery report was invalid";
-                    if (repairTurn >= maxRepairs) {
-                        const detail = `Delivery report repair exhausted: ${parseError}`;
-                        // Implementation finished; only its response envelope is invalid. Preserve the exact
-                        // tree and identify this narrow condition so the control plane can prepare repair
-                        // guidance instead of discarding the work and asking the owner to debug JSON.
-                        retainAttemptWorktree = true;
+                    landContinuationUsed = true;
+                    if (continuation.sessionId) {
+                        config.sessions = { ...config.sessions, [taskId]: continuation.sessionId };
+                        agentSessionId = continuation.sessionId;
+                    }
+                    reportText = continuation.resultText;
+                    try {
+                        report = parseAgentReport(reportText, spec.acceptance ?? []);
+                    }
+                    catch {
+                        const base = spec.repository?.base_commit ?? "unknown";
+                        const classified = classifyFinalizeFailure(agentNoLandCommitMessage(base));
                         const response = await queueTerminal(client, taskId, {
                             action: "fail",
                             body: {
-                                error: detail,
-                                retryable: false,
-                                failure: {
-                                    code: "delivery_report_invalid",
-                                    class: "contract",
-                                    disposition: "rework",
-                                    responsible_party: "conduit",
-                                    message: "Conduit could not prepare a valid delivery report from the completed agent run.",
-                                    next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
-                                    diagnostic_detail: detail,
-                                },
-                                idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}`,
+                                error: classified.error,
+                                retryable: classified.retryable,
+                                idempotency_key: `bridge:claims-git-gate:${active.attemptId}`,
                             },
                         });
                         retainAttemptWorktree = retainDiagnosticWorktree(response);
-                        console.error(`Assignment ${taskId} exhausted its report-only repair: ${redactSecrets(parseError)}`);
-                        const replyTail = previousReply.slice(-8_000);
-                        console.error(`Assignment ${taskId} repaired reply tail (${previousReply.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);
+                        console.error(`Assignment ${taskId} claims-vs-git gate failed after land continuation: ${redactSecrets(classified.error)}`);
+                        return;
+                    }
+                }
+                else {
+                    const base = spec.repository?.base_commit ?? "unknown";
+                    const classified = classifyFinalizeFailure(agentNoLandCommitMessage(base));
+                    const response = await queueTerminal(client, taskId, {
+                        action: "fail",
+                        body: {
+                            error: classified.error,
+                            retryable: classified.retryable,
+                            idempotency_key: `bridge:claims-git-gate:${active.attemptId}`,
+                        },
+                    });
+                    retainAttemptWorktree = retainDiagnosticWorktree(response);
+                    console.error(`Assignment ${taskId} claims-vs-git gate blocked read-only report repair: ${redactSecrets(classified.error)}`);
+                    return;
+                }
+            }
+            else {
+                // Pump fuel keeps one repair turn. Local-fuel Experimental lanes (Pi et al.) get a second
+                // read-only repair — truncated JSON fences are common there and re-implementing is wasteful.
+                const maxRepairs = fuelSource === "local" ? 2 : 1;
+                let parseError = error instanceof Error ? error.message : "Agent delivery report was invalid";
+                let previousReply = reportText;
+                let resumeSessionId = result.sessionId ?? undefined;
+                let repaired = null;
+                let parsed = null;
+                for (let repairTurn = 1; repairTurn <= maxRepairs; repairTurn++) {
+                    const replyDigest = createHash("sha256").update(previousReply).digest("hex");
+                    await client.attemptRequest(taskId, "progress", {
+                        phase: "preparing_delivery",
+                        message: `Delivery envelope invalid (${redactSecrets(parseError)}); starting report-only repair turn ${repairTurn}/${maxRepairs} without rerunning implementation. Original reply: ${previousReply.length} characters, sha256:${replyDigest}.`,
+                        idempotency_key: `bridge:progress:${active.attemptId}:delivery-repair:${repairTurn}`,
+                    });
+                    try {
+                        repaired = await driver.run({
+                            prompt: buildDeliveryRepairPrompt(parseError, previousReply, spec.acceptance ?? []),
+                            workspace: attemptWorkspace,
+                            // Preserve only existing read authority. No write, test, branch, or push
+                            // capability is available while the agent repairs the response envelope.
+                            grants: grants.filter((grant) => grant === "repo_read"),
+                            capabilities: [],
+                            verificationCommands: [],
+                            // Envelope repair is read-only observe authority regardless of the original class.
+                            executionClass: "observe",
+                            resumeSessionId,
+                            timeoutMs,
+                            model: selection.model,
+                            fuel,
+                            fuelSource,
+                        });
+                    }
+                    catch (repairError) {
+                        const message = repairError instanceof Error ? repairError.message : "Delivery report repair failed";
+                        await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair failed: ${message}`, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
+                        console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
+                        return;
+                    }
+                    if (repaired.sessionId) {
+                        config.sessions = { ...config.sessions, [taskId]: repaired.sessionId };
+                        resumeSessionId = repaired.sessionId;
+                        agentSessionId = repaired.sessionId;
+                    }
+                    if (repaired.status === "failed") {
+                        const message = repaired.error ?? "Delivery report repair failed";
+                        await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(message), idempotency_key: `bridge:delivery-repair-failed:${active.attemptId}` } });
+                        console.error(`Assignment ${taskId} report-only repair failed: ${redactSecrets(message)}`);
                         return;
                     }
-                    console.error(`Assignment ${taskId} report-only repair turn ${repairTurn} still invalid: ${redactSecrets(parseError)}; retrying`);
+                    previousReply = repaired.resultText ?? "";
+                    try {
+                        parsed = parseAgentReport(previousReply, spec.acceptance ?? []);
+                        break;
+                    }
+                    catch (repairError) {
+                        parseError = repairError instanceof Error ? repairError.message : "Repaired delivery report was invalid";
+                        if (repairTurn >= maxRepairs) {
+                            const detail = `Delivery report repair exhausted: ${parseError}`;
+                            // Implementation finished; only its response envelope is invalid. Preserve the exact
+                            // tree and identify this narrow condition so the control plane can prepare repair
+                            // guidance instead of discarding the work and asking the owner to debug JSON.
+                            retainAttemptWorktree = true;
+                            const response = await queueTerminal(client, taskId, {
+                                action: "fail",
+                                body: {
+                                    error: detail,
+                                    retryable: false,
+                                    failure: {
+                                        code: "delivery_report_invalid",
+                                        class: "contract",
+                                        disposition: "rework",
+                                        responsible_party: "conduit",
+                                        message: "Conduit could not prepare a valid delivery report from the completed agent run.",
+                                        next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
+                                        diagnostic_detail: detail,
+                                    },
+                                    idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}`,
+                                },
+                            });
+                            retainAttemptWorktree = retainDiagnosticWorktree(response);
+                            console.error(`Assignment ${taskId} exhausted its report-only repair: ${redactSecrets(parseError)}`);
+                            const replyTail = previousReply.slice(-8_000);
+                            console.error(`Assignment ${taskId} repaired reply tail (${previousReply.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);
+                            return;
+                        }
+                        console.error(`Assignment ${taskId} report-only repair turn ${repairTurn} still invalid: ${redactSecrets(parseError)}; retrying`);
+                    }
                 }
+                if (!parsed)
+                    return;
+                reportText = previousReply;
+                report = parsed;
             }
-            if (!parsed)
+        }
+        if (!landContinuationUsed
+            && requiresLandCommit({ grants, spec })
+            && reportClaimsRepositoryWork(report)
+            && await isLandTreeEmpty({ workspace: attemptWorkspace, spec, grants })) {
+            const continuation = await runLandContinuationTurn({
+                client,
+                taskId,
+                attemptId: active.attemptId,
+                workspace: attemptWorkspace,
+                spec,
+                grants,
+                driver,
+                capabilities: spec.required_capabilities ?? [],
+                verificationCommands: attemptBrief?.verification ?? [],
+                objective: task.objective,
+                selection,
+                fuel,
+                fuelSource,
+                timeoutMs,
+                resumeSessionId: agentSessionId,
+                reason: "Parsed Delivery claims repository work but git shows none; starting land-only continuation.",
+                idempotencyKey: `bridge:progress:${active.attemptId}:claims-git-gate-report`,
+            });
+            landContinuationUsed = true;
+            if (continuation.sessionId) {
+                config.sessions = { ...config.sessions, [taskId]: continuation.sessionId };
+                agentSessionId = continuation.sessionId;
+            }
+            reportText = continuation.resultText;
+            try {
+                report = parseAgentReport(reportText, spec.acceptance ?? []);
+            }
+            catch {
+                const base = spec.repository?.base_commit ?? "unknown";
+                const classified = classifyFinalizeFailure(agentNoLandCommitMessage(base));
+                await queueTerminal(client, taskId, {
+                    action: "fail",
+                    body: {
+                        error: classified.error,
+                        retryable: classified.retryable,
+                        idempotency_key: `bridge:claims-git-gate-report:${active.attemptId}`,
+                    },
+                });
+                console.error(`Assignment ${taskId} claims-vs-git gate failed after parsed-report continuation: ${redactSecrets(classified.error)}`);
                 return;
-            reportText = previousReply;
-            report = parsed;
+            }
         }
         try {
             report = await finalizeRepositoryLand({
@@ -990,6 +1137,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 fuelSource,
                 timeoutMs,
                 resumeSessionId: agentSessionId,
+                landContinuationUsed,
             });
             // Mechanical land path: agent may forget gh; Bridge pushes and the control plane opens the PR.
             report = await ensureDeliveryPullRequest({
@@ -1100,6 +1248,37 @@ function buildLandContinuationPrompt(input) {
 function bindLandHeadCommit(report, headCommit) {
     return { ...report, head_commit: headCommit };
 }
+async function runLandContinuationTurn(input) {
+    await input.client.attemptRequest(input.taskId, "progress", {
+        phase: "changing",
+        message: input.reason,
+        idempotency_key: input.idempotencyKey,
+    });
+    const continuation = await input.driver.run({
+        prompt: buildLandContinuationPrompt({
+            objective: input.objective,
+            spec: input.spec,
+            acceptance: input.spec.acceptance ?? [],
+        }),
+        workspace: input.workspace,
+        grants: input.grants,
+        capabilities: input.capabilities,
+        verificationCommands: input.verificationCommands,
+        executionClass: "mutate_repo",
+        resumeSessionId: input.resumeSessionId ?? undefined,
+        timeoutMs: input.timeoutMs,
+        model: input.selection.model ?? undefined,
+        fuel: input.fuel,
+        fuelSource: input.fuelSource,
+    });
+    if (continuation.status === "failed") {
+        throw new AgentNoLandCommitError(input.spec.repository?.base_commit ?? "unknown");
+    }
+    return {
+        resultText: continuation.resultText ?? "",
+        sessionId: continuation.sessionId ?? undefined,
+    };
+}
 async function finalizeRepositoryLand(input) {
     if (!requiresLandCommit({ grants: input.grants, spec: input.spec }))
         return input.report;
@@ -1128,34 +1307,31 @@ async function finalizeRepositoryLand(input) {
         if (!(error instanceof AgentNoLandCommitError))
             throw error;
     }
-    await input.client.attemptRequest(input.taskId, "progress", {
-        phase: "changing",
-        message: "Agent finished without landing repository changes; starting one land-only continuation turn.",
-        idempotency_key: `bridge:progress:${input.attemptId}:land-continuation`,
-    });
-    const continuation = await input.driver.run({
-        prompt: buildLandContinuationPrompt({
-            objective: input.objective,
-            spec: input.spec,
-            acceptance: input.spec.acceptance ?? [],
-        }),
+    if (input.landContinuationUsed) {
+        throw new AgentNoLandCommitError(input.spec.repository?.base_commit ?? "unknown");
+    }
+    const continuation = await runLandContinuationTurn({
+        client: input.client,
+        taskId: input.taskId,
+        attemptId: input.attemptId,
         workspace: input.workspace,
+        spec: input.spec,
         grants: input.grants,
+        driver: input.driver,
         capabilities: input.capabilities,
         verificationCommands: input.verificationCommands,
-        executionClass: "mutate_repo",
-        resumeSessionId: input.resumeSessionId ?? undefined,
-        timeoutMs: input.timeoutMs,
-        model: input.selection.model ?? undefined,
+        objective: input.objective,
+        selection: input.selection,
         fuel: input.fuel,
         fuelSource: input.fuelSource,
+        timeoutMs: input.timeoutMs,
+        resumeSessionId: input.resumeSessionId,
+        reason: "Agent finished without landing repository changes; starting one land-only continuation turn.",
+        idempotencyKey: `bridge:progress:${input.attemptId}:land-continuation`,
     });
-    if (continuation.status === "failed") {
-        throw new AgentNoLandCommitError(input.spec.repository?.base_commit ?? "unknown");
-    }
     let report = input.report;
     try {
-        report = parseAgentReport(continuation.resultText ?? "", input.spec.acceptance ?? []);
+        report = parseAgentReport(continuation.resultText, input.spec.acceptance ?? []);
     }
     catch {
         // Land may have succeeded even when the continuation envelope is malformed — git is authoritative.

package/dist/land-git-reality.js

@@ -0,0 +1,108 @@
+/**
+ * Claims vs git — detect when an agent's Delivery narrative claims repository work
+ * that git cannot see on the attempt branch.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { commitsAheadOfBase } from "./ensure-pull-request.js";
+import { extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
+import { filterPathsInScope, requiresLandCommit, } from "./land-contract.js";
+const execFileAsync = promisify(execFile);
+const NO_CHANGE_OUTCOME = /no code changes|no changes were made|working tree clean|did not (?:make|land)|nothing to (?:change|deliver)|no commit was made/i;
+async function listUncommittedPaths(workspace) {
+    const { stdout } = await execFileAsync("git", ["-C", workspace, "status", "--porcelain"], {
+        timeout: 30_000,
+        maxBuffer: 8_000_000,
+    });
+    const paths = [];
+    for (const line of stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        const entry = line.slice(3).trim();
+        if (!entry)
+            continue;
+        const path = entry.includes(" -> ")
+            ? entry.slice(entry.lastIndexOf(" -> ") + 4).trim()
+            : entry;
+        if (path)
+            paths.push(path.replace(/^"|"$/g, ""));
+    }
+    return paths;
+}
+/** True when the land contract applies and git shows no commit and no scoped dirty files. */
+export async function isLandTreeEmpty(input) {
+    if (!requiresLandCommit({ grants: input.grants, spec: input.spec }))
+        return false;
+    const base = input.spec.repository?.base_commit;
+    if (!base)
+        return false;
+    const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
+    const ahead = await countAhead(input.workspace, base);
+    if (ahead !== null && ahead > 0)
+        return false;
+    const pending = filterPathsInScope(await (input.listUncommittedPaths ?? listUncommittedPaths)(input.workspace), input.spec.change_scope ?? []);
+    return pending.length === 0;
+}
+function deliveryObjectClaimsWork(raw) {
+    if (Array.isArray(raw.changes) && raw.changes.some((entry) => typeof entry === "string" && entry.trim())) {
+        return true;
+    }
+    if (typeof raw.head_commit === "string" && raw.head_commit.trim())
+        return true;
+    if (Array.isArray(raw.evidence) && raw.evidence.some((entry) => {
+        return entry && typeof entry === "object" && entry.kind === "change";
+    })) {
+        return true;
+    }
+    if (Array.isArray(raw.acceptance_results) && raw.acceptance_results.some((entry) => {
+        return entry && typeof entry === "object" && entry.status === "met";
+    })) {
+        return true;
+    }
+    const outcome = typeof raw.outcome === "string" ? raw.outcome : "";
+    if (outcome && NO_CHANGE_OUTCOME.test(outcome))
+        return false;
+    if (outcome.trim()) {
+        if (/\b(rewrote|replaced|implemented|added|modified|removed|commit(?:ted)?|fetcher|\.rs\b|\.ts\b)\b/i.test(outcome)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Best-effort read of the agent reply — used before strict Delivery validation. */
+export function agentClaimsRepositoryWork(text) {
+    if (!text.trim())
+        return false;
+    try {
+        const raw = parseJsonObjectCandidate(extractAgentReportJsonText(text));
+        if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+            return deliveryObjectClaimsWork(raw);
+        }
+    }
+    catch {
+        // Fall through — malformed JSON may still prose-claim work in the tail.
+    }
+    if (NO_CHANGE_OUTCOME.test(text))
+        return false;
+    return /\b(rewrote|replaced|implemented|fetcher\.rs|head_commit|"changes"\s*:\s*\[)/i.test(text);
+}
+/** Parsed Delivery claims repository work (stricter than free text). */
+export function reportClaimsRepositoryWork(report) {
+    if (report.changes.some((entry) => entry.trim()))
+        return true;
+    if (report.head_commit?.trim())
+        return true;
+    if (report.evidence.some((entry) => entry.kind === "change"))
+        return true;
+    if (report.acceptance_results.some((entry) => entry.status === "met"))
+        return true;
+    if (report.outcome && NO_CHANGE_OUTCOME.test(report.outcome))
+        return false;
+    return false;
+}
+/** Hard gate: land is required, git is empty, and the agent narrative claims work landed. */
+export async function claimsVsGitMismatch(input) {
+    if (!agentClaimsRepositoryWork(input.agentReply))
+        return false;
+    return isLandTreeEmpty(input);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "description": "Conduit Bridge CLI — join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity / Grok Build agents for a Conduit organization",
   "type": "module",
   "bin": {