@miraland-labs/conduit-bridge 0.12.4 → 0.13.0

package/dist/attempt-worktree.js

@@ -56,6 +56,14 @@ export async function createAttemptWorktree(input) {
     return path;
 }
 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.
+    try {
+        await access(worktreePath, constants.F_OK);
+    }
+    catch {
+        return;
+    }
     try {
         await execFileAsync("git", ["-C", sourceWorkspace, "worktree", "remove", "--force", worktreePath], { timeout: 60_000, maxBuffer: 2_000_000 });
     }

package/dist/client.js

@@ -48,6 +48,8 @@ export class ConduitClient {
             leaseExpiresAt: String(data.lease_expires_at),
             phase: "claimed",
             ...(extras?.driverId ? { driverId: extras.driverId } : {}),
+            ...(extras?.executionKind ? { executionKind: extras.executionKind } : {}),
+            ...(extras?.sourceAttemptId ? { sourceAttemptId: extras.sourceAttemptId } : {}),
         };
         this.config.activeAttempts[taskId] = active;
         await this.persistRuntime(this.config);

package/dist/driver.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
 import { deniedCommands, executionClassPromptRules, parsePiJsonl, projectClaude, projectCoarseMode, projectCodex, projectCursor, projectKiroTools, projectPi, requireStampedExecutionClass, } from "./execution-class.js";
@@ -334,6 +334,7 @@ export const claudeCodeDriver = {
         const projected = projectClaude(executionClass, {
             grants: input.grants,
             verificationCommands: input.verificationCommands,
+            diagnosis: input.workRole === "diagnose",
         });
         // Fail closed: omitting --allowedTools would leave only the deny-list and
         // broaden the agent beyond the grant contract (privileged grants map to none).
@@ -456,7 +457,10 @@ export const codexDriver = {
             };
         }
         const executionClass = resolveRunClass(input);
-        const projected = projectCodex(executionClass, { capabilities: input.capabilities });
+        const projected = projectCodex(executionClass, {
+            capabilities: input.capabilities,
+            diagnosis: input.workRole === "diagnose",
+        });
         // Prompt via stdin avoids ARG_MAX limits on large assignment contracts.
         const { code, stdout, stderr } = await execute(input.executable ?? resolveCodexExecutable(), codexExecArgs({ ...input, networkAccess: projected.networkAccess }, projected.sandbox), input.workspace, input.timeoutMs ?? 20 * 60_000, fuelSource === "conduit" ? input.fuel : undefined, fuelSource, input.prompt);
         const parsed = parseCodexJsonl(stdout);
@@ -588,6 +592,7 @@ export const cursorDriver = {
             grants: input.grants,
             verificationCommands: input.verificationCommands,
             capabilities: input.capabilities ?? [],
+            diagnosis: input.workRole === "diagnose",
         });
         const configured = await withCursorPermissions(input.workspace, { allow: projected.allow, deny: projected.deny }, () => execute(executable, cursorRunArgs({ ...input, trustWorkspace, executionClass, force: projected.force }), input.workspace, input.timeoutMs ?? 20 * 60_000, undefined, "local"));
         const { code, stdout, stderr } = configured;
@@ -602,6 +607,7 @@ export const cursorDriver = {
 async function withCursorPermissions(workspace, permissions, run) {
     const configDir = join(workspace, ".cursor");
     const configPath = join(configDir, "cli.json");
+    const configDirExisted = existsSync(configDir);
     let previous = null;
     try {
         previous = await readFile(configPath, "utf8");
@@ -621,6 +627,11 @@ async function withCursorPermissions(workspace, permissions, run) {
             await rm(configPath, { force: true });
         else
             await writeFile(configPath, previous, "utf8");
+        // Do not leave control-plane permission scaffolding in a worktree that had no Cursor config.
+        // rmdir removes only an empty directory, preserving anything the operator already had or the
+        // CLI legitimately created during the run.
+        if (!configDirExisted)
+            await rmdir(configDir).catch(() => undefined);
     }
 }
 /**

package/dist/drivers.js

@@ -16,6 +16,12 @@ const LABEL_TO_DRIVER = {
     Antigravity: "antigravity",
 };
 const LOCAL_FUEL_ONLY_DRIVERS = new Set(["cursor", "pi", "kiro", "antigravity"]);
+/**
+ * Drivers that can combine repository reads with bounded verification while denying source edits.
+ * Coarse build/bash modes are not enough for Invariant 23: a diagnosis carries `test_run`, but it
+ * must never acquire `repo_write` as an implementation detail of the selected lane.
+ */
+const READ_ONLY_DIAGNOSIS_DRIVERS = new Set(["claude-code", "codex", "cursor"]);
 export function isSupportedDriverId(id) {
     return Object.prototype.hasOwnProperty.call(DRIVERS, id);
 }
@@ -25,6 +31,9 @@ export function driverLabel(id) {
 export function localFuelOnlyDriver(id) {
     return LOCAL_FUEL_ONLY_DRIVERS.has(id);
 }
+export function supportsReadOnlyDiagnosis(id) {
+    return READ_ONLY_DIAGNOSIS_DRIVERS.has(id);
+}
 /** Map PATH probe labels to unique driver ids. */
 export function driverIdsFromDetectedLabels(labels) {
     const ids = new Set();
@@ -148,9 +157,13 @@ export function driversHeartbeatReport(config, activeAttempts, processOnlineIds)
  * Pick an online driver for a new claim: least loaded among online (shared machine pool).
  * `processOnlineIds` overrides config online lanes (tests / harness).
  */
-export function pickDriverForClaim(config, processOnlineIds) {
-    const online = (processOnlineIds?.length ? processOnlineIds : onlineDriverIds(config))
-        .filter((id) => isSupportedDriverId(id));
+export function pickDriverForClaim(config, processOnlineIds, eligible = () => true) {
+    const candidates = processOnlineIds === undefined || processOnlineIds === null
+        ? onlineDriverIds(config)
+        : processOnlineIds;
+    const online = candidates
+        .filter((id) => isSupportedDriverId(id))
+        .filter(eligible);
     if (!online.length)
         return null;
     const load = new Map();

package/dist/execution-class.js

@@ -126,8 +126,13 @@ export function projectCursor(executionClass, input) {
             ? landCommands.map((command) => `Shell(${command})`)
             : []),
     ];
-    if (executionClass === "observe" || executionClass === "observe_network") {
+    if (executionClass === "observe" || executionClass === "observe_network" || input.diagnosis) {
         deny.push("Shell(*)", "Write(**)");
+        if (input.diagnosis) {
+            // Re-open only the bounded verification commands below. Diagnosis may run checks, never an
+            // arbitrary shell or Cursor's write tool.
+            deny.splice(deny.indexOf("Shell(*)"), 1);
+        }
     }
     const allow = [];
     if (allowsExternalFetch(executionClass, capabilities))
@@ -175,6 +180,7 @@ export function projectClaude(executionClass, input) {
         return {
             allowedTools: [
                 "Read",
+                ...(input.diagnosis ? ["Glob", "Grep"] : []),
                 ...verificationCommands.filter(isBoundedVerificationCommand).map((command) => `Bash(${command}:*)`),
                 ...fetchTools,
             ],
@@ -207,7 +213,7 @@ export function projectCodex(executionClass, input) {
     const networkAccess = allowsExternalFetch(executionClass, capabilities);
     // Read-only is the sandbox for the one class that may not write; everything else needs the
     // workspace. Network is the shared predicate, so Codex cannot drift from Cursor and Claude again.
-    if (executionClass === "observe")
+    if (executionClass === "observe" || input.diagnosis)
         return { sandbox: "read-only", networkAccess };
     return { sandbox: "workspace-write", networkAccess };
 }

package/dist/execution.js

@@ -2,9 +2,9 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ConduitRequestError } from "./client.js";
 import { redactSecrets } from "./config.js";
-import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, pickModelCandidate, requireStampedExecutionClass, tierForRisk } from "./driver.js";
+import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, requireStampedExecutionClass, tierForRisk } from "./driver.js";
 import { assertClassFloor } from "./execution-class.js";
-import { pickDriverForClaim, resolveDriverFuel } from "./drivers.js";
+import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
@@ -62,10 +62,13 @@ const assignmentSchema = z.object({
     id: z.string().uuid(),
     attempt_id: z.string().uuid(),
     execution_mode: z.enum(["agent", "human"]).optional().default("agent"),
+    execution_kind: z.enum(["authoring", "diagnosis"]).optional().default("authoring"),
+    source_attempt_id: z.string().uuid().nullable().optional().default(null),
     repository_fingerprint: z.string().nullable().optional().default(null),
     requested_base_commit: z.string().nullable().optional().default(null),
     claimed_head: z.string().nullable().optional().default(null),
 });
+const releasedWorktreeAttemptIdsSchema = z.array(z.string().uuid()).max(50);
 const taskDetailSchema = z.object({
     objective: z.string(),
     project_id: z.string().uuid(),
@@ -74,6 +77,8 @@ const taskDetailSchema = z.object({
     delivery_state: z.string(),
     delivery_summary: z.string().nullable(),
     execution_mode: z.enum(["agent", "human"]).optional().default("agent"),
+    execution_kind: z.enum(["authoring", "diagnosis"]).optional().default("authoring"),
+    source_attempt_id: z.string().uuid().nullable().optional().default(null),
 });
 const taskSpecSchema = z.object({
     goal: z.string().optional(), scope: z.array(z.string()).optional(), boundaries: z.array(z.string()).optional(),
@@ -94,6 +99,7 @@ const executionContractSchema = z.object({
     repository_fingerprint: z.string().nullable().optional().default(null),
     requested_base_commit: z.string().nullable().optional().default(null),
     claimed_head: z.string().nullable().optional().default(null),
+    source_attempt_id: z.string().uuid().nullable().optional().default(null),
 });
 const workPackageSchema = z.object({
     work_role: z.string().nullable().optional(),
@@ -111,8 +117,104 @@ const workPackageSchema = z.object({
     }).optional(),
     decisions: z.array(z.object({ question: z.string(), decision: z.string() })).optional(),
     rework_feedback: z.string().nullable().optional(),
+    diagnostic_context: z.object({
+        source_attempt_id: z.string().uuid(),
+        failure_output: z.string().min(1).max(12_000),
+    }).optional(),
     working_language: z.enum(["en", "zh"]).optional(),
 }).nullable().optional();
+const diagnosticRepairBriefSchema = z.object({
+    root_cause: z.string().trim().min(1).max(2_000),
+    wrong_approach: z.string().trim().max(2_000).default(""),
+    fix_direction: z.string().trim().min(1).max(4_000),
+    do_not_touch: z.array(z.string().trim().min(1).max(400)).max(10).default([]),
+    confident: z.boolean().default(true),
+});
+function diagnosticText(value, max) {
+    if (typeof value === "string")
+        return value.trim().slice(0, max);
+    if (!Array.isArray(value))
+        return undefined;
+    const parts = value.filter((item) => typeof item === "string")
+        .map((item) => item.trim()).filter(Boolean);
+    if (!parts.length)
+        return undefined;
+    return (parts.length === 1 ? parts[0] : parts.map((part, index) => `${index + 1}. ${part}`).join("\n"))
+        .slice(0, max);
+}
+/** Parse the diagnostic agent's final JSON with the same field-shape tolerance as the CP. */
+export function parseDiagnosticRepairBrief(text) {
+    let raw = parseJsonObjectCandidate(extractAgentReportJsonText(text));
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("Diagnostic agent did not emit a RepairBrief object");
+    }
+    let obj = { ...raw };
+    const keys = Object.keys(obj);
+    if (keys.length === 1 && obj[keys[0]] && typeof obj[keys[0]] === "object"
+        && !Array.isArray(obj[keys[0]]) && "fix_direction" in obj[keys[0]]) {
+        obj = { ...obj[keys[0]] };
+    }
+    for (const [field, max] of [["root_cause", 2_000], ["wrong_approach", 2_000], ["fix_direction", 4_000]]) {
+        const value = diagnosticText(obj[field], max);
+        if (value !== undefined)
+            obj[field] = value;
+    }
+    if (obj.wrong_approach == null)
+        obj.wrong_approach = "";
+    obj.do_not_touch = Array.isArray(obj.do_not_touch)
+        ? obj.do_not_touch.filter((item) => typeof item === "string")
+            .map((item) => item.trim().slice(0, 400)).filter(Boolean).slice(0, 10)
+        : typeof obj.do_not_touch === "string" && obj.do_not_touch.trim()
+            ? [obj.do_not_touch.trim().slice(0, 400)]
+            : [];
+    if (typeof obj.confident === "string") {
+        const token = obj.confident.trim().toLowerCase();
+        if (token === "true" || token === "yes")
+            obj.confident = true;
+        else if (token === "false" || token === "no")
+            obj.confident = false;
+    }
+    const parsed = diagnosticRepairBriefSchema.safeParse(obj);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        throw new Error(`Diagnostic RepairBrief is invalid${issue?.path.length ? ` at ${issue.path.join(".")}` : ""}: ${issue?.message ?? "unknown shape"}`);
+    }
+    return parsed.data;
+}
+/** Prompt for Option C: IDE-depth understanding in the retained tree, with write authority absent. */
+export function buildDiagnosticPrompt(input) {
+    const pkg = input.workPackage;
+    const goal = pkg?.goal ?? input.spec.goal ?? input.objective;
+    const scope = pkg?.scope?.length ? pkg.scope : input.spec.scope ?? [];
+    const boundaries = pkg?.boundaries?.length ? pkg.boundaries : input.spec.boundaries ?? [];
+    const acceptance = pkg?.acceptance?.length ? pkg.acceptance : input.spec.acceptance ?? [];
+    const changeScope = pkg?.change_scope?.length ? pkg.change_scope : input.spec.change_scope ?? [];
+    const decisions = pkg?.decisions ?? [];
+    return [
+        "You are Conductor's read-only diagnosis lane. Diagnose the exact failed authoring run in the current retained worktree.",
+        "Inspect the actual code, git diff, nearby callers, and relevant tests. Run only the supplied project verification commands when useful.",
+        "You have repo_read and test_run only. Do not edit, create, delete, format, commit, branch, push, install, or change any file.",
+        "Do not propose owner-authored compiler constraints and do not return a Delivery Packet. Your only deliverable is a grounded RepairBrief for the next authoring agent.",
+        "The RepairBrief crosses to the control plane: name files, symbols, and fix steps, but do not quote secrets or copy file bodies into it.",
+        "If the worktree does not support a grounded diagnosis, set confident to false; never guess.",
+        "",
+        `TASK ${input.taskId}`,
+        `GOAL\n${goal}`,
+        ...(scope.length ? ["", `APPROVED SCOPE\n${scope.map((item) => `- ${item}`).join("\n")}`] : []),
+        ...(boundaries.length ? ["", `BOUNDARIES\n${boundaries.map((item) => `- ${item}`).join("\n")}`] : []),
+        ...(acceptance.length ? ["", `APPROVED ACCEPTANCE CRITERIA\n${acceptance.map((item) => `- ${item}`).join("\n")}`] : []),
+        ...(changeScope.length ? ["", `APPROVED CHANGE SCOPE\n${changeScope.map((item) => `- ${item}`).join("\n")}`] : []),
+        ...(decisions.length ? ["", `OWNER DECISIONS\n${decisions.map((item) => `- ${item.question}: ${item.decision}`).join("\n")}`] : []),
+        ...(input.verificationCommands.length ? ["", `BOUNDED VERIFICATION COMMANDS\n${input.verificationCommands.map((item) => `- ${item}`).join("\n")}`] : []),
+        "",
+        "WITNESSED FAILURE OUTPUT",
+        redactSecrets(input.failureOutput),
+        "",
+        "Return only one fenced ```json object with exactly this shape:",
+        '{"root_cause":"specific cause grounded in files/symbols","wrong_approach":"what the failed run did wrong","fix_direction":"ordered fix instructions for the authoring agent","do_not_touch":["out-of-scope paths or behavior"],"confident":true}',
+        "root_cause, wrong_approach, and fix_direction are strings, not arrays. Close the fence and add no prose after it.",
+    ].join("\n");
+}
 export async function renewLeases(client, config) {
     for (const active of Object.values(config.activeAttempts)) {
         if (Date.parse(active.leaseExpiresAt) - Date.now() < 120_000) {
@@ -142,6 +244,26 @@ export async function recoverActiveAttempt(client, config, driver, workspace, br
     const active = taskId ? config.activeAttempts[taskId] : Object.values(config.activeAttempts)[0];
     if (!active)
         return false;
+    // A terminal payload is already complete and replay-safe. Replaying it must not depend on the
+    // driver that produced it still being installed or online after a Bridge restart.
+    if (active.phase === "terminal_pending") {
+        const response = await flushTerminal(client, active.taskId);
+        const diagnosis = active.executionKind === "diagnosis";
+        const worktreeOwner = diagnosis ? active.sourceAttemptId : active.attemptId;
+        const worktree = active.worktreePath ?? (worktreeOwner ? attemptWorktreePath(workspace, worktreeOwner) : "");
+        if (diagnosis && !retainDiagnosticWorktree(response) && worktree) {
+            await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
+        }
+        else if (!diagnosis && response.retain_worktree !== true && worktree) {
+            if (active.terminal?.action === "fail") {
+                await quarantineAttemptWorktree(workspace, worktree, active.attemptId).catch(() => removeAttemptWorktree(workspace, worktree).catch(() => undefined));
+            }
+            else {
+                await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
+            }
+        }
+        return true;
+    }
     const laneDriver = resolveAttemptDriver(config, active, driver);
     if (!laneDriver) {
         console.error(`No driver for attempt ${active.attemptId} (driverId=${active.driverId ?? "unset"})`);
@@ -153,10 +275,12 @@ export async function recoverActiveAttempt(client, config, driver, workspace, br
             await client.updateAttempt(active.taskId, { driverId: assigned });
     }
     if (active.phase === "agent_running") {
-        const worktree = active.worktreePath ?? attemptWorktreePath(workspace, active.attemptId);
+        const diagnosis = active.executionKind === "diagnosis";
+        const worktreeOwner = diagnosis ? active.sourceAttemptId : active.attemptId;
+        const worktree = active.worktreePath ?? (worktreeOwner ? attemptWorktreePath(workspace, worktreeOwner) : "");
         const sessionId = config.sessions?.[active.taskId]?.trim() || "";
         // F-07 safe resume: only when session + worktree identity are both proven. Otherwise interrupt.
-        if (sessionId && await proveResumeWorktree(workspace, active.attemptId, worktree)) {
+        if (worktreeOwner && sessionId && await proveResumeWorktree(workspace, worktreeOwner, worktree)) {
             console.log(`Resuming interrupted attempt ${active.attemptId} with proven worktree and session.`);
             await runClaimedAssignment(client, config, laneDriver, workspace, brief, active.taskId, timeoutMs, supervision, {
                 existingWorktree: worktree,
@@ -164,22 +288,29 @@ export async function recoverActiveAttempt(client, config, driver, workspace, br
             });
             return true;
         }
-        await quarantineAttemptWorktree(workspace, worktree, active.attemptId).catch(() => removeAttemptWorktree(workspace, worktree).catch(() => undefined));
-        await client.updateAttempt(active.taskId, { worktreePath: undefined });
-        await queueTerminal(client, active.taskId, {
+        const response = await queueTerminal(client, active.taskId, {
             action: "fail",
-            body: { error: "Bridge restarted during agent execution; Conduit may retry this work safely.", idempotency_key: `bridge:restart:${active.attemptId}` },
+            body: {
+                error: diagnosis
+                    ? "Bridge restarted during read-only diagnosis; Conduit may retry diagnosis safely."
+                    : "Bridge restarted during agent execution; Conduit may retry this work safely.",
+                idempotency_key: `bridge:restart:${active.attemptId}`,
+            },
         });
+        if (diagnosis && !retainDiagnosticWorktree(response) && worktree) {
+            await removeAttemptWorktree(workspace, worktree).catch(() => undefined);
+        }
+        else if (!diagnosis && response.retain_worktree !== true && worktree) {
+            // Do not quarantine before the terminal response: Conduit may need this exact tree for a
+            // pinned diagnosis even when Bridge restarted before it could preserve the agent session.
+            await quarantineAttemptWorktree(workspace, worktree, active.attemptId).catch(() => removeAttemptWorktree(workspace, worktree).catch(() => undefined));
+        }
         return true;
     }
     if (client.attempt(active.taskId).phase === "agent_finished") {
         await submitFinishedDelivery(client, active.taskId);
         return true;
     }
-    if (client.attempt(active.taskId).phase === "terminal_pending") {
-        await flushTerminal(client, active.taskId);
-        return true;
-    }
     await runClaimedAssignment(client, config, laneDriver, workspace, brief, active.taskId, timeoutMs, supervision);
     return true;
 }
@@ -199,8 +330,10 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
         if (running.has(id))
             continue;
         const active = config.activeAttempts[id];
-        const laneDriver = resolveAttemptDriver(config, active, fallbackDriver);
-        if (!laneDriver) {
+        const laneDriver = active.phase === "terminal_pending"
+            ? fallbackDriver
+            : resolveAttemptDriver(config, active, fallbackDriver);
+        if (!laneDriver && active.phase !== "terminal_pending") {
             console.error(`Slot recovery skipped for ${id}: no driver lane`);
             continue;
         }
@@ -228,9 +361,12 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
         }
         if (!laneDriver || !driverId)
             break;
-        const taskId = await claimNextAssignment(client, config, workspace, brief, driverId);
-        if (!taskId)
+        const claimed = await claimNextAssignment(client, config, workspace, brief, driverId, processOnlineIds);
+        if (!claimed)
             break;
+        const taskId = claimed.taskId;
+        driverId = claimed.driverId ?? driverId;
+        laneDriver = driverId ? DRIVERS[driverId] ?? laneDriver : laneDriver;
         progressed = true;
         console.log(`Executing ${taskId} via ${laneDriver.name}`);
         const slot = runClaimedAssignment(client, config, laneDriver, workspace, brief, taskId, timeoutMs, supervision)
@@ -244,10 +380,17 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
     return progressed;
 }
 /** Claim one assignment when under capacity; does not start the agent (multi-slot pump does). */
-export async function claimNextAssignment(client, config, workspace, brief, driverId) {
+export async function claimNextAssignment(client, config, workspace, brief, driverId, processOnlineIds) {
     if (Object.keys(config.activeAttempts).length >= config.leaseCapacity)
         return null;
     const data = await client.request("/runner/v1/assignments");
+    const releasedWorktrees = releasedWorktreeAttemptIdsSchema.parse(data.released_worktree_attempt_ids ?? []);
+    for (const attemptId of releasedWorktrees) {
+        const worktree = attemptWorktreePath(workspace, attemptId);
+        await removeAttemptWorktree(workspace, worktree)
+            .then(() => console.log(`Released settled diagnostic worktree ${worktree}`))
+            .catch((error) => console.error(`Diagnostic worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`));
+    }
     const assignments = z.array(assignmentSchema).parse(data.assignments ?? []);
     const assignment = assignments[0];
     if (!assignment)
@@ -256,18 +399,25 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
         console.log(`Human takeover assignment ${assignment.id} — use Bridge MCP tools to claim and submit (agent runner skips).`);
         return null;
     }
+    let selectedDriverId = driverId ?? null;
+    if (assignment.execution_kind === "diagnosis" && selectedDriverId && !supportsReadOnlyDiagnosis(selectedDriverId)) {
+        // Prefer a lane that can honour repo_read + test_run without silently widening to repo_write.
+        // If none is online, claim on the selected lane so runClaimedAssignment can create a durable,
+        // owner-safe Hold and refund the diagnostic slot instead of leaving an expiring dispatch loop.
+        selectedDriverId = pickDriverForClaim(config, processOnlineIds, supportsReadOnlyDiagnosis) ?? selectedDriverId;
+    }
     const liveBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
     const liveRepository = liveBrief?.repository ? normalizeRepositoryUrl(liveBrief.repository) : null;
     let rejection = null;
     if (assignment.repository_fingerprint && liveRepository !== assignment.repository_fingerprint)
         rejection = "workspace_repository_mismatch";
-    else if (assignment.repository_fingerprint && assignment.claimed_head && liveBrief?.base_commit !== assignment.claimed_head) {
+    else if (assignment.execution_kind === "authoring" && assignment.repository_fingerprint && assignment.claimed_head && liveBrief?.base_commit !== assignment.claimed_head) {
         // Rework / advanced base may claim a head that differs from the source checkout HEAD.
         const reachable = await ensureCommitAvailable(workspace, assignment.claimed_head).catch(() => false);
         if (!reachable)
             rejection = "workspace_head_changed";
     }
-    if (!rejection && assignment.requested_base_commit && assignment.claimed_head) {
+    if (!rejection && assignment.execution_kind === "authoring" && assignment.requested_base_commit && assignment.claimed_head) {
         const startHead = await resolveAttemptStartCommit(workspace, assignment.requested_base_commit, assignment.claimed_head);
         if (!startHead)
             rejection = "base_not_ancestor";
@@ -280,17 +430,21 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
         console.error(`Assignment ${assignment.id} rejected before claim: ${rejection}`);
         return null;
     }
-    console.log(`Claiming assignment ${assignment.id} (attempt ${assignment.attempt_id})`);
-    await client.claim(assignment.id, assignment.attempt_id, driverId ? { driverId } : undefined);
-    return assignment.id;
+    console.log(`Claiming ${assignment.execution_kind} assignment ${assignment.id} (attempt ${assignment.attempt_id})`);
+    await client.claim(assignment.id, assignment.attempt_id, {
+        ...(selectedDriverId ? { driverId: selectedDriverId } : {}),
+        executionKind: assignment.execution_kind,
+        ...(assignment.source_attempt_id ? { sourceAttemptId: assignment.source_attempt_id } : {}),
+    });
+    return { taskId: assignment.id, driverId: selectedDriverId };
 }
 export async function executeNextAssignment(client, config, driver, workspace, brief, timeoutMs, supervision) {
     if (Object.keys(config.activeAttempts).length)
         return recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision);
-    const taskId = await claimNextAssignment(client, config, workspace, brief);
-    if (!taskId)
+    const claimed = await claimNextAssignment(client, config, workspace, brief);
+    if (!claimed)
         return false;
-    await runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision);
+    await runClaimedAssignment(client, config, driver, workspace, brief, claimed.taskId, timeoutMs, supervision);
     return true;
 }
 async function runClaimedAssignment(client, config, driver, workspace, brief, taskId, timeoutMs, supervision, options = {}) {
@@ -299,12 +453,21 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
     const task = taskDetailSchema.parse(detail.task);
     const executionContract = executionContractSchema.parse(detail.execution_contract ?? {});
     const workPackage = workPackageSchema.parse(detail.work_package) ?? null;
+    const executionKind = task.execution_kind;
+    const diagnosis = executionKind === "diagnosis";
+    const sourceAttemptId = task.source_attempt_id ?? executionContract.source_attempt_id ?? active.sourceAttemptId ?? null;
+    if (active.executionKind !== executionKind || active.sourceAttemptId !== (sourceAttemptId ?? undefined)) {
+        await client.updateAttempt(taskId, {
+            executionKind,
+            sourceAttemptId: sourceAttemptId ?? undefined,
+        });
+    }
     const parsedSpec = parseTaskSpec(task.spec_json);
     const deliverable = workPackage?.deliverable ?? parsedSpec.deliverable;
     const spec = { ...parsedSpec, deliverable };
-    const artifactDelivery = deliverable === "artifact";
+    const artifactDelivery = !diagnosis && deliverable === "artifact";
     const grants = z.array(z.string()).parse(task.grants_json ? JSON.parse(task.grants_json) : []);
-    const reworkFeedback = task.delivery_state === "changes_requested" ? changesRequestedFeedback(task.delivery_summary) : null;
+    const reworkFeedback = !diagnosis && task.delivery_state === "changes_requested" ? changesRequestedFeedback(task.delivery_summary) : null;
     // Recompile current state at claim time — earlier packages may have moved the repo.
     const liveBrief = await buildWorkspaceBrief(workspace).catch(() => brief);
     const liveRepository = liveBrief?.repository ? normalizeRepositoryUrl(liveBrief.repository) : null;
@@ -313,37 +476,83 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         console.error(`Assignment ${taskId} preflight failed: Workspace repository changed after dispatch`);
         return;
     }
-    const startCommit = (() => {
-        const claimed = executionContract.claimed_head ?? liveBrief?.base_commit ?? null;
-        return claimed;
-    })();
-    if (!startCommit) {
-        await queueTerminal(client, taskId, { action: "fail", body: { error: "No start commit for attempt worktree", retryable: true, idempotency_key: `bridge:no-start-commit:${active.attemptId}` } });
-        return;
-    }
-    let worktreeStart = startCommit;
-    if (executionContract.requested_base_commit) {
-        const resolved = await resolveAttemptStartCommit(workspace, executionContract.requested_base_commit, startCommit);
-        if (!resolved) {
-            await queueTerminal(client, taskId, { action: "fail", body: { error: "Required base commit is not available in this workspace", retryable: true, idempotency_key: `bridge:base-not-ancestor:${active.attemptId}` } });
+    const startCommit = executionContract.claimed_head ?? liveBrief?.base_commit ?? null;
+    let worktreeStart = startCommit ?? "retained-worktree";
+    let attemptWorkspace;
+    let deliverySubmitted = false;
+    // A diagnostic terminal defaults to retention. If its lease disappears, deleting the only copy
+    // of the failed code would make the durable retry mechanically impossible.
+    let retainAttemptWorktree = diagnosis;
+    if (diagnosis) {
+        if (!sourceAttemptId) {
+            await queueTerminal(client, taskId, {
+                action: "fail",
+                body: {
+                    failure: {
+                        code: "repair_diagnosis_source_missing",
+                        class: "platform",
+                        disposition: "stop",
+                        responsible_party: "conduit",
+                        message: "Conductor could not locate the failed run for read-only diagnosis.",
+                        next_action: "No compiler constraints are needed from the owner; inspect Conduit repair history before retrying the task.",
+                        diagnostic_detail: "Diagnostic assignment omitted source_attempt_id.",
+                    },
+                    error: "Diagnostic assignment omitted source_attempt_id",
+                    retryable: false,
+                    idempotency_key: `bridge:diagnosis-source-missing:${active.attemptId}`,
+                },
+            });
             return;
         }
-        worktreeStart = resolved;
-    }
-    else if (liveBrief?.base_commit && liveBrief.base_commit !== startCommit) {
-        const reachable = await ensureCommitAvailable(workspace, startCommit).catch(() => false);
-        if (!reachable) {
-            await queueTerminal(client, taskId, { action: "fail", body: { error: "Delivered head is not available in this workspace", retryable: true, idempotency_key: `bridge:workspace-mismatch:${active.attemptId}` } });
-            console.error(`Assignment ${taskId} preflight failed: Delivered head is not available in this workspace`);
+        const retained = options.existingWorktree ?? attemptWorktreePath(workspace, sourceAttemptId);
+        if (!(await proveResumeWorktree(workspace, sourceAttemptId, retained))) {
+            await queueTerminal(client, taskId, {
+                action: "fail",
+                body: {
+                    failure: {
+                        code: "repair_diagnosis_worktree_missing",
+                        class: "platform",
+                        disposition: "stop",
+                        responsible_party: "conduit",
+                        message: "Conductor could not access the retained failed run for read-only diagnosis.",
+                        next_action: "No compiler constraints are needed from the owner; inspect Conduit repair history before retrying the task.",
+                        diagnostic_detail: `Retained worktree for source attempt ${sourceAttemptId} is unavailable.`,
+                    },
+                    error: "Retained failed worktree is unavailable for read-only diagnosis",
+                    retryable: false,
+                    idempotency_key: `bridge:diagnosis-worktree-missing:${active.attemptId}`,
+                },
+            });
             return;
         }
+        attemptWorkspace = retained;
+        worktreeStart = executionContract.claimed_head ?? "retained-worktree";
+        await client.updateAttempt(taskId, { worktreePath: attemptWorkspace, executionKind, sourceAttemptId });
     }
-    let attemptWorkspace;
-    let deliverySubmitted = false;
-    if (options.existingWorktree) {
+    else if (options.existingWorktree) {
         attemptWorkspace = options.existingWorktree;
     }
     else {
+        if (!startCommit) {
+            await queueTerminal(client, taskId, { action: "fail", body: { error: "No start commit for attempt worktree", retryable: true, idempotency_key: `bridge:no-start-commit:${active.attemptId}` } });
+            return;
+        }
+        if (executionContract.requested_base_commit) {
+            const resolved = await resolveAttemptStartCommit(workspace, executionContract.requested_base_commit, startCommit);
+            if (!resolved) {
+                await queueTerminal(client, taskId, { action: "fail", body: { error: "Required base commit is not available in this workspace", retryable: true, idempotency_key: `bridge:base-not-ancestor:${active.attemptId}` } });
+                return;
+            }
+            worktreeStart = resolved;
+        }
+        else if (liveBrief?.base_commit && liveBrief.base_commit !== startCommit) {
+            const reachable = await ensureCommitAvailable(workspace, startCommit).catch(() => false);
+            if (!reachable) {
+                await queueTerminal(client, taskId, { action: "fail", body: { error: "Delivered head is not available in this workspace", retryable: true, idempotency_key: `bridge:workspace-mismatch:${active.attemptId}` } });
+                console.error(`Assignment ${taskId} preflight failed: Delivered head is not available in this workspace`);
+                return;
+            }
+        }
         try {
             attemptWorkspace = await createAttemptWorktree({
                 sourceWorkspace: workspace,
@@ -362,6 +571,16 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         }
         await client.updateAttempt(taskId, { worktreePath: attemptWorkspace });
     }
+    // Diagnosis reads manifests and verification commands from the failed tree itself. The source
+    // checkout may be clean but stale relative to edits that caused the failure.
+    const attemptBrief = diagnosis
+        ? await buildWorkspaceBrief(attemptWorkspace).catch(() => liveBrief)
+        : liveBrief;
+    const removeReleasedDiagnosticWorktree = async (response) => {
+        if (diagnosis && !retainDiagnosticWorktree(response)) {
+            await removeAttemptWorktree(workspace, attemptWorkspace).catch(() => undefined);
+        }
+    };
     // Stamped class is the source of truth (Bridge 0.11+). Do not re-derive from grants.
     let executionClass;
     try {
@@ -372,10 +591,11 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         console.error(`Assignment ${taskId}: ${detail}`);
         // Non-retryable: control plane restamps on dispatch/claim. Infinite retry here burned path-4
         // attempt budget when a pre-inversion task row still lacked the stamp.
-        await queueTerminal(client, taskId, {
+        const response = await queueTerminal(client, taskId, {
             action: "fail",
             body: { error: detail, retryable: false, idempotency_key: `bridge:fail:${active.attemptId}:missing-class` },
         });
+        await removeReleasedDiagnosticWorktree(response);
         return;
     }
     // An artifact deliverable that is not publish_artifact cannot write/publish — fail closed.
@@ -393,19 +613,68 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
     if (!floor.ok) {
         const detail = `Class floor unmet: ${floor.reason}`;
         console.error(`Assignment ${taskId}: ${detail}`);
-        await queueTerminal(client, taskId, {
+        const response = await queueTerminal(client, taskId, {
             action: "fail",
             body: { error: detail, retryable: false, idempotency_key: `bridge:fail:${active.attemptId}:class-floor` },
         });
+        await removeReleasedDiagnosticWorktree(response);
+        return;
+    }
+    const builtInDriverId = Object.entries(DRIVERS).find(([, candidate]) => candidate === driver)?.[0] ?? null;
+    if (diagnosis && builtInDriverId && !supportsReadOnlyDiagnosis(builtInDriverId)) {
+        const detail = `${driver.name} cannot combine bounded test execution with enforced read-only repository access.`;
+        const response = await queueTerminal(client, taskId, {
+            action: "fail",
+            body: {
+                failure: {
+                    code: "repair_diagnosis_driver_read_only_unsupported",
+                    class: "environment",
+                    disposition: "hold",
+                    responsible_party: "computer_operator",
+                    message: "Conductor is waiting for a diagnostic lane that can enforce read-only access.",
+                    next_action: "Bring a Claude Code, Codex, or Cursor lane online on this computer, then Recheck. Do not author compiler constraints for the agent.",
+                    diagnostic_detail: detail,
+                },
+                error: detail,
+                retryable: false,
+                idempotency_key: `bridge:diagnosis-driver-authority:${active.attemptId}`,
+            },
+        });
+        await removeReleasedDiagnosticWorktree(response);
+        console.error(`Assignment ${taskId} diagnosis held: ${detail}`);
+        return;
+    }
+    const diagnosticFailure = workPackage?.diagnostic_context?.failure_output;
+    if (diagnosis && !diagnosticFailure) {
+        const response = await queueTerminal(client, taskId, {
+            action: "fail",
+            body: {
+                error: "Diagnostic assignment is missing witnessed failure output",
+                retryable: true,
+                idempotency_key: `bridge:diagnosis-context-missing:${active.attemptId}`,
+            },
+        });
+        await removeReleasedDiagnosticWorktree(response);
         return;
     }
-    const prompt = buildAssignmentPrompt({ taskId, objective: task.objective, spec, grants, workspace: attemptWorkspace, currentHead: worktreeStart, reworkFeedback, workPackage, verificationCommands: liveBrief?.verification ?? [], executionClass });
+    const prompt = diagnosis
+        ? buildDiagnosticPrompt({
+            taskId,
+            objective: task.objective,
+            spec,
+            workPackage,
+            failureOutput: diagnosticFailure,
+            verificationCommands: attemptBrief?.verification ?? [],
+        })
+        : buildAssignmentPrompt({ taskId, objective: task.objective, spec, grants, workspace: attemptWorkspace, currentHead: worktreeStart, reworkFeedback, workPackage, verificationCommands: attemptBrief?.verification ?? [], executionClass });
     const resuming = Boolean(options.forceResumeSessionId);
     await client.attemptRequest(taskId, "progress", {
-        phase: "changing",
+        phase: diagnosis ? "inspecting" : "changing",
         message: resuming
             ? `Resuming ${driver.name} after Bridge restart with proven session and worktree.`
-            : `Starting ${driver.name} for this assignment${reworkFeedback ? " with review feedback" : ""}.`,
+            : diagnosis
+                ? `Starting ${driver.name} read-only diagnosis in the retained failed worktree.`
+                : `Starting ${driver.name} for this assignment${reworkFeedback ? " with review feedback" : ""}.`,
         idempotency_key: resuming ? `bridge:progress:${active.attemptId}:resume` : `bridge:progress:${active.attemptId}:start`,
     });
     const driverId = active.driverId
@@ -433,7 +702,14 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             : `Started ${driver.name}${selection.model ? ` on ${selection.model}` : " on its CLI default"}.`,
         idempotency_key: resuming ? `bridge:progress:${active.attemptId}:agent-resume` : `bridge:progress:${active.attemptId}:agent-start`,
     });
-    await client.updateAttempt(taskId, { phase: "agent_running", fuelMode: fuelSource, worktreePath: attemptWorkspace, driverId });
+    await client.updateAttempt(taskId, {
+        phase: "agent_running",
+        fuelMode: fuelSource,
+        worktreePath: attemptWorkspace,
+        driverId,
+        executionKind,
+        sourceAttemptId: sourceAttemptId ?? undefined,
+    });
     const renewTimer = setInterval(() => { void renewLeases(client, config).catch((error) => console.error(`Lease renewal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`)); }, 60_000);
     let heartbeatRunning = false;
     const heartbeatTimer = supervision ? setInterval(() => {
@@ -455,9 +731,9 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             workspace: attemptWorkspace,
             grants,
             capabilities: spec.required_capabilities ?? [],
-            verificationCommands: liveBrief?.verification ?? [],
+            verificationCommands: attemptBrief?.verification ?? [],
             deliverable,
-            workRole: workPackage?.work_role ?? spec.work_role,
+            workRole: diagnosis ? "diagnose" : workPackage?.work_role ?? spec.work_role,
             executionClass,
             resumeSessionId,
             timeoutMs,
@@ -467,6 +743,50 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         });
         if (result.sessionId)
             config.sessions = { ...config.sessions, [taskId]: result.sessionId };
+        if (diagnosis) {
+            if (result.status === "failed") {
+                const message = result.error ?? "Read-only diagnosis failed";
+                const response = await queueTerminal(client, taskId, {
+                    action: "fail",
+                    body: {
+                        error: message,
+                        retryable: retryableAgentFailure(message),
+                        idempotency_key: `bridge:diagnosis-fail:${active.attemptId}`,
+                    },
+                });
+                retainAttemptWorktree = retainDiagnosticWorktree(response);
+                console.error(`Assignment ${taskId} diagnosis failed: ${redactSecrets(message)}`);
+                return;
+            }
+            let repairBrief;
+            try {
+                repairBrief = parseDiagnosticRepairBrief(result.resultText ?? "");
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Diagnostic RepairBrief was invalid";
+                const response = await queueTerminal(client, taskId, {
+                    action: "fail",
+                    body: {
+                        error: message,
+                        retryable: true,
+                        idempotency_key: `bridge:diagnosis-invalid:${active.attemptId}`,
+                    },
+                });
+                retainAttemptWorktree = retainDiagnosticWorktree(response);
+                console.error(`Assignment ${taskId} diagnosis returned no usable brief: ${redactSecrets(message)}`);
+                return;
+            }
+            const response = await queueTerminal(client, taskId, {
+                action: "complete",
+                body: {
+                    repair_brief: repairBrief,
+                    idempotency_key: `bridge:diagnosis-complete:${active.attemptId}`,
+                },
+            });
+            retainAttemptWorktree = retainDiagnosticWorktree(response);
+            console.log(`Assignment ${taskId} returned a grounded Conductor RepairBrief.`);
+            return;
+        }
         if (result.status === "failed") {
             const agentMessage = result.error ?? "Agent execution failed";
             // The agent verifies inside its own tool loop, so its compiler/test output never reaches
@@ -474,16 +794,22 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             // reason", leaving Conductor nothing to diagnose. Re-run the project's bounded verification
             // in the attempt worktree to recover the real errors. Best-effort: keep the agent's own
             // message when there is no command, the command cannot run, or the tree actually verifies.
-            const verificationDetail = await captureVerificationFailure({
-                workspace: attemptWorkspace,
-                verificationCommands: liveBrief?.verification ?? [],
-            });
+            const verificationDetail = grants.includes("test_run")
+                ? await captureVerificationFailure({
+                    workspace: attemptWorkspace,
+                    verificationCommands: attemptBrief?.verification ?? [],
+                })
+                : null;
             const message = verificationDetail
                 ? `Verification failed after the agent run.\n${verificationDetail}`
                 : agentMessage;
             // Retryability stays keyed to what the agent reported; a recovered verification log describes
             // the same run and must not silently reclassify an unretryable failure.
-            await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(agentMessage), idempotency_key: `bridge:fail:${active.attemptId}` } });
+            // Keep the tree until the replay-safe terminal response explicitly says whether diagnosis was
+            // queued. A network fault here must not delete the evidence before Bridge can replay terminal.
+            retainAttemptWorktree = true;
+            const response = await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: retryableAgentFailure(agentMessage), idempotency_key: `bridge:fail:${active.attemptId}` } });
+            retainAttemptWorktree = response.retain_worktree === true;
             console.error(`Assignment ${taskId} failed: ${redactSecrets(message)}`);
             return;
         }
@@ -583,16 +909,25 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 report,
                 spec,
                 grants,
-                verificationCommands: liveBrief?.verification ?? [],
+                verificationCommands: attemptBrief?.verification ?? [],
             });
             validateDeliveryReport(report, spec, grants);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Agent delivery report was invalid";
-            // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail closed
-            // (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
-            const classified = classifyFinalizeFailure(message);
-            await queueTerminal(client, taskId, {
+            // Bridge's own bounded verification can reject an otherwise completed agent run here. That is
+            // the same verify-class pre-delivery failure as the driver-failed path above: preserve the
+            // exact tree and send the witness marker that arms Conductor diagnosis. Treating it as a
+            // delivery-envelope defect would stop before Invariant 23 ever ran.
+            const verificationFailed = /^Agent report: Verification failed \(/.test(message);
+            const classified = verificationFailed
+                ? { retryable: true, error: `Verification failed after the agent run.\n${message}` }
+                // classifyFinalizeFailure: forge transport → retryable; contract/environment/unknown → fail
+                // closed (unknown prefixed as "Bridge finalize interrupted", not laundered as contract).
+                : classifyFinalizeFailure(message);
+            if (verificationFailed)
+                retainAttemptWorktree = true;
+            const response = await queueTerminal(client, taskId, {
                 action: "fail",
                 body: {
                     error: classified.error,
@@ -600,6 +935,8 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                     idempotency_key: `bridge:invalid-delivery:${active.attemptId}`,
                 },
             });
+            if (verificationFailed)
+                retainAttemptWorktree = response.retain_worktree === true;
             console.error(`Assignment ${taskId} could not produce a valid Delivery: ${redactSecrets(classified.error)}`);
             const replyTail = reportText.slice(-8_000);
             console.error(`Assignment ${taskId} agent reply tail (${reportText.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);
@@ -614,7 +951,10 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         clearInterval(renewTimer);
         if (heartbeatTimer)
             clearInterval(heartbeatTimer);
-        if (artifactDelivery && !deliverySubmitted) {
+        if (retainAttemptWorktree) {
+            console.log(`Retained failed-attempt worktree for Conductor diagnosis at ${attemptWorkspace}`);
+        }
+        else if (artifactDelivery && !deliverySubmitted) {
             console.error(`Artifact delivery was not submitted; retained generated files at ${attemptWorkspace}`);
         }
         else {
@@ -883,22 +1223,28 @@ function pathMatchesScope(path, scope) {
     }
     return path === normalized;
 }
+function retainDiagnosticWorktree(response) {
+    // Lease expiry is reconciled by the CP into another diagnostic attempt. The old terminal cannot
+    // receive that decision, so fail safe by retaining the only copy of the failed code.
+    return response.retain_worktree === true || response.status === "invalid_lease";
+}
 async function queueTerminal(client, taskId, terminal) {
     await client.updateAttempt(taskId, { phase: "terminal_pending", terminal });
-    await flushTerminal(client, taskId);
+    return flushTerminal(client, taskId);
 }
 export async function flushTerminal(client, taskId) {
     const active = client.attempt(taskId);
     if (!active.terminal)
         throw new Error("Pending terminal operation is missing its replay payload");
     try {
-        await client.attemptRequest(taskId, active.terminal.action, active.terminal.body);
+        const response = await client.attemptRequest(taskId, active.terminal.action, active.terminal.body);
         await client.clearAttempt(taskId);
+        return response;
     }
     catch (error) {
         if (error instanceof ConduitRequestError && error.code === "invalid_lease") {
             await client.clearAttempt(taskId);
-            return;
+            return { accepted: false, status: "invalid_lease" };
         }
         throw error;
     }

package/dist/preflight.js

@@ -3,7 +3,8 @@ import { promisify } from "node:util";
 import { buildWorkspaceBrief, normalizeRepositoryUrl } from "./brief.js";
 import { hasAntigravityLogin, hasClaudeLogin, hasOpenAiLogin, hasOpenCodeLogin, resolveCodexExecutable, } from "./driver.js";
 import { localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel } from "./drivers.js";
-export const BRIDGE_PROTOCOL_VERSION = 2;
+/** Protocol 3: read-only diagnosis can reuse a retained failed-attempt worktree. */
+export const BRIDGE_PROTOCOL_VERSION = 3;
 const execFileAsync = promisify(execFile);
 async function defaultCommandRunner(command, args, cwd) {
     try {
@@ -110,7 +111,7 @@ export async function cachedBridgePreflight(input) {
     cached = { key, at: Date.now(), report };
     return report;
 }
-/** Heartbeat-only / missing workspace still reports protocol 2 preflight (not ready). */
+/** Heartbeat-only / missing workspace still reports the current protocol preflight (not ready). */
 export function unavailableWorkspacePreflight(input) {
     const online = input.processOnlineIds?.length ? input.processOnlineIds : onlineDriverIds(input.config);
     const issues = [];

package/package.json

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