@miraland-labs/conduit-bridge 0.16.3 → 0.16.5

package/dist/attempt-worktree.js

@@ -53,8 +53,35 @@ export async function createAttemptWorktree(input) {
     // "commit on the current branch" accurate. -b fails if the branch exists, which is the desired
     // guard — createAttemptWorktree only ever runs for a fresh attempt id (resume reuses its worktree).
     ["-C", input.sourceWorkspace, "worktree", "add", "-b", attemptBranchName(input.attemptId), path, input.startCommit], { timeout: 60_000, maxBuffer: 2_000_000 });
+    await ensureWorktreeGitIdentity(path, input.sourceWorkspace);
     return path;
 }
+/** Attempt worktrees are separate checkouts; agents cannot always run git config. Inherit identity from source or set Bridge defaults. */
+export async function ensureWorktreeGitIdentity(worktree, sourceWorkspace) {
+    const git = async (...args) => execFileAsync("git", ["-C", worktree, ...args], {
+        timeout: 30_000,
+        maxBuffer: 1_000_000,
+    });
+    const readConfig = async (repo, key) => {
+        try {
+            const { stdout } = await execFileAsync("git", ["-C", repo, "config", "--get", key], {
+                timeout: 30_000,
+                maxBuffer: 1_000_000,
+            });
+            return stdout.trim();
+        }
+        catch {
+            return "";
+        }
+    };
+    for (const key of ["user.email", "user.name"]) {
+        if (await readConfig(worktree, key))
+            continue;
+        const inherited = await readConfig(sourceWorkspace, key);
+        const fallback = key === "user.email" ? "conduit-bridge@miraland.io" : "Conduit Bridge";
+        await git("config", key, inherited || fallback);
+    }
+}
 export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
     // Settled repair releases are returned on every assignment poll until the local tree is gone.
     // Make that at-least-once signal cheap and idempotent instead of invoking Git on a missing path.

package/dist/ensure-land-commit.js

@@ -36,6 +36,8 @@ async function uncommittedPaths(workspace) {
     }
     return paths;
 }
+const LAND_COMMIT_EMAIL = "conduit-bridge@miraland.io";
+const LAND_COMMIT_NAME = "Conduit Bridge";
 async function commitScopedPaths(workspace, paths) {
     if (!paths.length)
         throw new Error("Cannot land an empty path set");
@@ -43,7 +45,12 @@ async function commitScopedPaths(workspace, paths) {
         timeout: 120_000,
         maxBuffer: 8_000_000,
     });
-    await execFileAsync("git", ["-C", workspace, "commit", "-m", "Conduit: land scoped agent changes"], { timeout: 120_000, maxBuffer: 8_000_000 });
+    await execFileAsync("git", [
+        "-C", workspace,
+        "-c", `user.email=${LAND_COMMIT_EMAIL}`,
+        "-c", `user.name=${LAND_COMMIT_NAME}`,
+        "commit", "-m", "Conduit: land scoped agent changes",
+    ], { timeout: 120_000, maxBuffer: 8_000_000 });
 }
 /**
  * When the land contract applies, ensure the attempt branch has at least one commit after base.

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;
                     }
-                    console.error(`Assignment ${taskId} report-only repair turn ${repairTurn} still invalid: ${redactSecrets(parseError)}; retrying`);
+                    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;
+                            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.
@@ -1486,7 +1662,11 @@ function pathMatchesScope(path, scope) {
         const prefix = normalized.slice(0, -3);
         return path === prefix || path.startsWith(`${prefix}/`);
     }
-    return path === normalized;
+    if (path === normalized)
+        return true;
+    if (!normalized.includes("*") && path.startsWith(`${normalized}/`))
+        return true;
+    return false;
 }
 function retainDiagnosticWorktree(response) {
     // Lease expiry is reconciled by the CP into another diagnostic attempt. The old terminal cannot

package/dist/land-contract.js

@@ -38,7 +38,12 @@ export function pathMatchesScope(path, scope) {
         const prefix = normalized.slice(0, -3);
         return path === prefix || path.startsWith(`${prefix}/`);
     }
-    return path === normalized;
+    if (path === normalized)
+        return true;
+    // Directory scopes without /** still cover nested files (oracle-file-delivery/src/fetcher.rs).
+    if (!normalized.includes("*") && path.startsWith(`${normalized}/`))
+        return true;
+    return false;
 }
 export function filterPathsInScope(paths, changeScope) {
     if (!changeScope.length)

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.5",
   "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": {