@miraland-labs/conduit-bridge 0.16.2 → 0.16.4

package/dist/ensure-land-commit.js

@@ -0,0 +1,77 @@
+/**
+ * Mechanical land completion — commit scoped dirty work the agent left uncommitted before finalize.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { commitsAheadOfBase } from "./ensure-pull-request.js";
+import { AgentNoLandCommitError, filterPathsInScope, requiresLandCommit, } from "./land-contract.js";
+const execFileAsync = promisify(execFile);
+async function workspaceHeadCommit(workspace) {
+    const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-parse", "HEAD"], {
+        timeout: 30_000,
+        maxBuffer: 1_000_000,
+    });
+    const head = stdout.trim();
+    if (!head)
+        throw new Error("Could not read workspace HEAD");
+    return head;
+}
+async function uncommittedPaths(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;
+}
+async function commitScopedPaths(workspace, paths) {
+    if (!paths.length)
+        throw new Error("Cannot land an empty path set");
+    await execFileAsync("git", ["-C", workspace, "add", "--", ...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 });
+}
+/**
+ * When the land contract applies, ensure the attempt branch has at least one commit after base.
+ * Commits scoped dirty files Bridge can see; throws AgentNoLandCommitError when nothing is landable.
+ */
+export async function ensureLandCommit(input) {
+    if (!requiresLandCommit({ grants: input.grants, spec: input.spec })) {
+        return { kind: "skipped" };
+    }
+    const base = input.spec.repository?.base_commit;
+    if (!base)
+        return { kind: "skipped" };
+    const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
+    const readHead = input.readHeadCommit ?? workspaceHeadCommit;
+    const listPending = input.listUncommittedPaths ?? uncommittedPaths;
+    const commitPaths = input.commitPaths ?? commitScopedPaths;
+    const ahead = await countAhead(input.workspace, base);
+    if (ahead !== null && ahead > 0) {
+        return { kind: "already_landed", headCommit: await readHead(input.workspace) };
+    }
+    const pending = filterPathsInScope(await listPending(input.workspace), input.spec.change_scope ?? []);
+    if (!pending.length) {
+        throw new AgentNoLandCommitError(base);
+    }
+    await commitPaths(input.workspace, pending);
+    const afterAhead = await countAhead(input.workspace, base);
+    if (afterAhead === 0) {
+        throw new AgentNoLandCommitError(base);
+    }
+    return { kind: "committed", headCommit: await readHead(input.workspace), paths: pending };
+}

package/dist/ensure-pull-request.js

@@ -6,6 +6,7 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { normalizeRepositoryUrl } from "./brief.js";
+import { agentNoLandCommitMessage } from "./land-contract.js";
 const execFileAsync = promisify(execFile);
 /** Mirror execution.ts FORGE_TRANSPORT_PATTERN — keep local to avoid import cycles. */
 const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
@@ -197,7 +198,7 @@ export async function ensureDeliveryPullRequest(input) {
     if (base) {
         const ahead = await countAhead(input.workspace, base);
         if (ahead === 0) {
-            throw new Error(`The attempt branch has no commit after base ${base.slice(0, 12)}; this run produced no change to deliver`);
+            throw new Error(agentNoLandCommitMessage(base));
         }
     }
     await push(input.workspace);

package/dist/execution.js

@@ -11,6 +11,9 @@ import { execFile } from "node:child_process";
 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, 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. */
@@ -63,7 +66,7 @@ export function forgeTransportFailure(message) {
 /** Environment faults that must Hold — mirror CP ENVIRONMENT_FAILURES message patterns. */
 const FINALIZE_ENVIRONMENT_PATTERN = /base[_ ]not[_ ]ancestor|required base commit is not available|source[_ ]workspace[_ ]dirty|uncommitted changes|dirty workspace|workspace[_ ]head[_ ]changed|workspace[_ ]repository|workspace[_ ]unavailable|driver[_ ]not[_ ]authenticated|not logged in|no login|not authenticated|login required|no[_ ]online[_ ]driver|bridge[_ ]preflight|stale bridge|bridge version/i;
 /** Delivery-report / grant / evidence contract defects (non-retryable rework). */
-const FINALIZE_CONTRACT_PATTERN = /missing required evidence|without the repo_write grant|pull_request_url|Artifact delivery requires|outside the approved scope|head commit|test evidence must include|Met acceptance criteria|Agent report|Agent reported|Delivery report/i;
+const FINALIZE_CONTRACT_PATTERN = /missing required evidence|without the repo_write grant|pull_request_url|Artifact delivery requires|outside the approved scope|head commit|test evidence must include|Met acceptance criteria|Agent report|Agent reported|Agent did not land repository changes|Delivery report/i;
 /**
  * Classify throws from ensureDeliveryPullRequest + validateDeliveryReport.
  * Unknown non-contract faults must not be laundered as execution_contract_failed.
@@ -852,106 +855,290 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             console.error(`Assignment ${taskId} failed: ${redactSecrets(message)}`);
             return;
         }
-        let report;
+        if (requiresLandCommit({ grants, spec })) {
+            try {
+                const land = await ensureLandCommit({ workspace: attemptWorkspace, spec, grants });
+                if (land.kind === "committed") {
+                    await client.attemptRequest(taskId, "progress", {
+                        phase: "preparing_delivery",
+                        message: `Bridge committed scoped agent changes that were left uncommitted (${land.paths.join(", ")}).`,
+                        idempotency_key: `bridge:progress:${active.attemptId}:land-commit`,
+                    });
+                }
+            }
+            catch (error) {
+                if (!(error instanceof AgentNoLandCommitError))
+                    throw error;
+            }
+        }
+        let agentSessionId = result.sessionId ?? undefined;
         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;
-                }
-                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 (!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;
             }
-            if (!parsed)
+            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({
+                client,
+                taskId,
+                attemptId: active.attemptId,
+                workspace: attemptWorkspace,
+                spec,
+                grants,
+                report,
+                driver,
+                executionClass,
+                capabilities: spec.required_capabilities ?? [],
+                verificationCommands: attemptBrief?.verification ?? [],
+                objective: task.objective,
+                selection,
+                fuel,
+                fuelSource,
+                timeoutMs,
+                resumeSessionId: agentSessionId,
+                landContinuationUsed,
+            });
             // Mechanical land path: agent may forget gh; Bridge pushes and the control plane opens the PR.
             report = await ensureDeliveryPullRequest({
                 client,
@@ -1037,6 +1224,120 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         }
     }
 }
+function buildLandContinuationPrompt(input) {
+    const scope = input.spec.change_scope ?? [];
+    return [
+        "The implementation turn finished without landing repository changes on the attempt branch.",
+        "Perform exactly one land-only continuation: make the minimal scoped edits required by the approved plan, commit them on the current branch, run any bounded verification commands you are allowed to run, then return one fenced ```json Delivery object.",
+        "Do not open a pull request — Bridge opens it after finalize when pr_create is granted.",
+        "Your working branch is already checked out. Use git add and git commit; report the resulting sha as head_commit.",
+        "",
+        "OBJECTIVE",
+        input.objective,
+        "",
+        "APPROVED CHANGE SCOPE",
+        ...(scope.length ? scope.map((path) => `- ${path}`) : ["- (none — stay within the plan)"]),
+        "",
+        "APPROVED ACCEPTANCE CRITERIA",
+        ...(input.acceptance.length ? input.acceptance.map((criterion) => `- ${criterion}`) : ["- None"]),
+        "",
+        "REQUIRED DELIVERY SHAPE",
+        agentReportTemplate,
+    ].join("\n");
+}
+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;
+    const applyLand = async (report) => {
+        const land = await ensureLandCommit({
+            workspace: input.workspace,
+            spec: input.spec,
+            grants: input.grants,
+        });
+        if (land.kind === "committed") {
+            await input.client.attemptRequest(input.taskId, "progress", {
+                phase: "preparing_delivery",
+                message: `Bridge committed scoped agent changes that were left uncommitted (${land.paths.join(", ")}).`,
+                idempotency_key: `bridge:progress:${input.attemptId}:land-commit`,
+            });
+        }
+        if (land.kind === "already_landed" || land.kind === "committed") {
+            return bindLandHeadCommit(report, land.headCommit);
+        }
+        return report;
+    };
+    try {
+        return await applyLand(input.report);
+    }
+    catch (error) {
+        if (!(error instanceof AgentNoLandCommitError))
+            throw error;
+    }
+    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,
+        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`,
+    });
+    let report = input.report;
+    try {
+        report = parseAgentReport(continuation.resultText, input.spec.acceptance ?? []);
+    }
+    catch {
+        // Land may have succeeded even when the continuation envelope is malformed — git is authoritative.
+    }
+    return applyLand(report);
+}
 function buildDeliveryRepairPrompt(parseError, previousReply, acceptance) {
     const replyTail = redactSecrets(previousReply.slice(-8_000));
     return [

package/dist/land-contract.js

@@ -0,0 +1,47 @@
+/**
+ * Land contract — when a repository delivery must carry a commit on the attempt branch.
+ * Mirrors driver mustCommit / executionClassPromptRules; observe/verify/artifact paths stay out.
+ */
+/** True when finalize must prove a commit after the plan base on the attempt branch. */
+export function requiresLandCommit(input) {
+    if (input.spec.deliverable === "artifact")
+        return false;
+    const executionClass = input.spec.execution_class;
+    if (executionClass === "observe" || executionClass === "observe_network" || executionClass === "verify") {
+        return false;
+    }
+    if (executionClass === "publish_artifact")
+        return false;
+    return input.grants.includes("repo_write") && input.grants.includes("branch_create");
+}
+/** Stable prefix for classifyFinalizeFailure and the control-plane failure envelope. */
+export const AGENT_NO_LAND_COMMIT_PREFIX = "Agent did not land repository changes";
+export function agentNoLandCommitMessage(baseCommit) {
+    return `${AGENT_NO_LAND_COMMIT_PREFIX}: the attempt branch has no commit after base ${baseCommit.slice(0, 12)}.`;
+}
+/** Legacy ensureDeliveryPullRequest text — kept recognizable for stored failures. */
+export const LEGACY_NO_LAND_COMMIT_PATTERN = /no commit after base .*; this run produced no change to deliver/i;
+export function isAgentNoLandCommitMessage(message) {
+    return message.startsWith(AGENT_NO_LAND_COMMIT_PREFIX) || LEGACY_NO_LAND_COMMIT_PATTERN.test(message);
+}
+export class AgentNoLandCommitError extends Error {
+    baseCommit;
+    constructor(baseCommit) {
+        super(agentNoLandCommitMessage(baseCommit));
+        this.name = "AgentNoLandCommitError";
+        this.baseCommit = baseCommit;
+    }
+}
+export function pathMatchesScope(path, scope) {
+    const normalized = scope.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+    if (normalized.endsWith("/**")) {
+        const prefix = normalized.slice(0, -3);
+        return path === prefix || path.startsWith(`${prefix}/`);
+    }
+    return path === normalized;
+}
+export function filterPathsInScope(paths, changeScope) {
+    if (!changeScope.length)
+        return [...paths];
+    return paths.filter((path) => changeScope.some((scope) => pathMatchesScope(path, scope)));
+}

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/dist/ops.js

@@ -9,9 +9,11 @@ import { dirname, join, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { ConduitClient } from "./client.js";
 import { loadConfig } from "./config.js";
+import { ensureCheckout } from "./checkout.js";
 import { detectInstalledClients, probeAgentHealth } from "./detect.js";
 import { driverIdsFromDetectedLabels } from "./drivers.js";
 import { BRIDGE_PROTOCOL_VERSION, describePreflightIssue, runBridgePreflight } from "./preflight.js";
+import { applyRunnerToolPath, runnerServiceWorkspaceWarnings } from "./service.js";
 import { bridgeVersion } from "./version.js";
 export const OPS_VERBS = [
     "connect", "enroll", "install", "switch", "online", "offline", "status", "doctor", "disconnect", "uninstall",
@@ -154,6 +156,17 @@ export async function resolveDrivers(env, argv, detect = detectInstalledClients)
     throw new Error("No coding agent found on this computer. Install one (Claude Code, Codex, Cursor, OpenCode, Pi, Kiro, Antigravity, Grok Build), " +
         "then retry — or set CONDUIT_DRIVERS / pass driver ids explicitly.");
 }
+/** When CONDUIT_DRIVERS is unset, shared-capacity machines should not auto-online every detected IDE. */
+export function resolveInstallDrivers(env, argv, detect = detectInstalledClients) {
+    return resolveDrivers(env, argv, detect).then((drivers) => {
+        if (argv.length || splitOpsList(env.CONDUIT_DRIVERS).length || drivers.length <= 1)
+            return drivers;
+        const preferred = drivers.includes("claude-code") ? "claude-code" : drivers[0];
+        console.log(`Multiple agents detected — bringing only ${preferred} online. ` +
+            "Set CONDUIT_DRIVERS in ops.env to choose lanes explicitly.");
+        return [preferred];
+    });
+}
 /** Quote args for a copy-pasteable shell/cmd line (paths with spaces). */
 export function shellQuoteArgs(args) {
     return args.map((arg) => {
@@ -220,6 +233,11 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log(`Repo: ${env.CONDUIT_REPO || "(none)"}`);
             console.log(`Drivers: ${env.CONDUIT_DRIVERS || "(auto-detect installed agents)"}`);
             console.log(`Roles: ${env.CONDUIT_ROLES}`);
+            if (env.CONDUIT_WORKSPACE) {
+                for (const warning of runnerServiceWorkspaceWarnings(resolve(expandOpsValue(env.CONDUIT_WORKSPACE)))) {
+                    console.warn(`WARNING: ${warning}`);
+                }
+            }
             console.log("");
         }
         else {
@@ -232,10 +250,15 @@ export async function runOps(verb, argv = [], deps = {}) {
         requireOpsEnv(env);
         if (!env.CONDUIT_WORKSPACE)
             throw new Error(`Set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
+        applyRunnerToolPath();
         const config = await (deps.loadBridgeConfig ?? loadConfig)();
+        const workspace = resolve(expandOpsValue(env.CONDUIT_WORKSPACE));
+        for (const warning of runnerServiceWorkspaceWarnings(workspace)) {
+            console.warn(`WARNING: ${warning}`);
+        }
         const report = await (deps.preflight ?? runBridgePreflight)({
             config,
-            workspace: resolve(expandOpsValue(env.CONDUIT_WORKSPACE)),
+            workspace,
             expectedRepository: env.CONDUIT_REPO || undefined,
         });
         const installed = await detectInstalledClients();
@@ -257,6 +280,12 @@ export async function runOps(verb, argv = [], deps = {}) {
             console.log("");
         }
         if (report.ready) {
+            const serviceWarnings = runnerServiceWorkspaceWarnings(workspace);
+            if (serviceWarnings.length) {
+                for (const warning of serviceWarnings)
+                    console.warn(`WARNING: ${warning}`);
+                throw new Error("Background runner service workspace does not match ops.env");
+            }
             console.log("Workspace, online lanes, local fuel, CLI availability, and authentication are ready.");
             return;
         }
@@ -446,12 +475,20 @@ export async function runOps(verb, argv = [], deps = {}) {
             throw new Error(`No workspace declared. Rerun with --workspace /path/to/repo, or set CONDUIT_WORKSPACE in ${defaultOpsEnvPath()}`);
         }
         const workspace = resolve(expandOpsValue(installEnv.CONDUIT_WORKSPACE));
-        const drivers = await resolveDrivers(installEnv, installArgv);
+        const drivers = await (deps.resolveInstallDrivers ?? resolveInstallDrivers)(installEnv, installArgv);
         for (const id of drivers) {
             if (LOCAL_FUEL_DRIVERS.has(id))
                 runBridge(["drivers", "fuel", id, "local"]);
         }
         runBridge(["drivers", "online", ...drivers]);
+        applyRunnerToolPath();
+        if (installEnv.CONDUIT_REPO) {
+            const checkout = deps.ensureCheckout ?? ensureCheckout;
+            const result = await checkout(workspace, installEnv.CONDUIT_REPO);
+            console.log(result === "cloned"
+                ? `Cloned ${installEnv.CONDUIT_REPO} into ${workspace}`
+                : `Workspace already matches ${installEnv.CONDUIT_REPO}`);
+        }
         // Prove the exact local environment before installing a service that advertises availability.
         runBridge(["ops", "doctor"]);
         const installArgs = ["install-service", "--workspace", workspace];

package/dist/service.js

@@ -1,7 +1,7 @@
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
-import { dirname, join } from "node:path";
-import { realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 export const SERVICE_LABEL = "io.miraland.conduit-runner";
 function configDir() {
@@ -124,8 +124,88 @@ function escapeSystemd(value) {
 function launchAgentsPath() {
     return join(homedir(), "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
 }
-function systemdUnitPath() {
-    return join(homedir(), ".config", "systemd", "user", "conduit-runner.service");
+export function systemdUnitPath(home = homedir()) {
+    return join(home, ".config", "systemd", "user", "conduit-runner.service");
+}
+export function systemdDropInDir(home = homedir()) {
+    return join(home, ".config", "systemd", "user", "conduit-runner.service.d");
+}
+/** Parse `--workspace` from a runner argv list or systemd ExecStart line. */
+export function parseRunnerWorkspaceFromProgramArguments(args) {
+    const index = args.indexOf("--workspace");
+    return index >= 0 && args[index + 1] ? args[index + 1] : null;
+}
+export function parseRunnerWorkspaceFromExecStart(execStart) {
+    const match = /--workspace(?:=|\s+)(?:"([^"]+)"|'([^']+)'|([^\s]+))/.exec(execStart);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function dropInOverridesExecStart(content) {
+    return /^\s*ExecStart\s*=/m.test(content);
+}
+/** Drop-in fragments that override ExecStart can silently hijack ops install — strip them. */
+export async function removeExecStartOverridesFromSystemdDropIns(home = homedir()) {
+    const dir = systemdDropInDir(home);
+    if (!existsSync(dir))
+        return [];
+    const removed = [];
+    for (const name of await readdir(dir)) {
+        if (!name.endsWith(".conf"))
+            continue;
+        const path = join(dir, name);
+        const content = await readFile(path, "utf8");
+        if (!dropInOverridesExecStart(content))
+            continue;
+        const kept = content.split(/\r?\n/).filter((line) => {
+            const trimmed = line.trim();
+            return trimmed && !trimmed.startsWith("#") && !/^ExecStart\s*=/.test(trimmed);
+        });
+        if (kept.length === 0) {
+            await unlink(path);
+        }
+        else {
+            const next = content.split(/\r?\n/).filter((line) => !/^\s*ExecStart\s*=/.test(line)).join("\n").trimEnd();
+            await writeFile(path, next ? `${next}\n` : "", { mode: 0o644 });
+            if (!next)
+                await unlink(path).catch(() => undefined);
+        }
+        removed.push(name);
+    }
+    return removed;
+}
+export async function readStoredRunnerServiceWorkspace(home = homedir()) {
+    try {
+        const stored = JSON.parse(await readFile(serviceStatePath(), "utf8"));
+        return stored.options.workspace
+            ?? parseRunnerWorkspaceFromProgramArguments(stored.programArguments)
+            ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Effective workspace from the installed supervisor (systemd user unit on Linux). */
+export function readEffectiveLinuxRunnerWorkspace(home = homedir()) {
+    if (platform() !== "linux")
+        return null;
+    const result = spawnSync("systemctl", ["--user", "cat", "conduit-runner.service"], { encoding: "utf8" });
+    if (result.status !== 0)
+        return null;
+    let execStart = null;
+    for (const line of result.stdout.split(/\r?\n/)) {
+        if (line.startsWith("ExecStart="))
+            execStart = line.slice("ExecStart=".length);
+    }
+    return execStart ? parseRunnerWorkspaceFromExecStart(execStart) : null;
+}
+export function runnerServiceWorkspaceWarnings(declaredWorkspace, home = homedir()) {
+    const declared = resolve(declaredWorkspace);
+    const warnings = [];
+    const stored = platform() === "linux" ? readEffectiveLinuxRunnerWorkspace(home) : null;
+    if (stored && resolve(stored) !== declared) {
+        warnings.push(`Background runner service uses workspace ${stored}, but ops.env declares ${declaredWorkspace}. ` +
+            "Run ops install to realign the service, or remove stale systemd drop-ins under conduit-runner.service.d/.");
+    }
+    return warnings;
 }
 export const WINDOWS_TASK_NAME = "ConduitBridgeRunner";
 /** Quote one argv token for a Windows Task Scheduler /TR command line. */
@@ -256,6 +336,11 @@ export async function installRunnerService(options = {}) {
         return { path: plistPath, platform: "darwin" };
     }
     const unitPath = systemdUnitPath();
+    const removedDropIns = await removeExecStartOverridesFromSystemdDropIns();
+    if (removedDropIns.length) {
+        console.warn(`Removed stale systemd drop-in(s) that overrode ExecStart: ${removedDropIns.join(", ")}. ` +
+            "Those files can silently point the runner at the wrong checkout after ops switch.");
+    }
     await mkdir(dirname(unitPath), { recursive: true });
     await mkdir(linuxLogDir(), { recursive: true });
     await writeFile(unitPath, systemdUserUnit(programArguments, configDir()), { mode: 0o644 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.2",
+  "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": {