@miraland-labs/conduit-bridge 0.8.0 → 0.9.0

package/dist/brief.js

@@ -43,6 +43,41 @@ export async function isBaseCommitAncestor(workspace, baseCommit, headCommit) {
         throw error;
     }
 }
+/** True when `sha` is a local commit object, optionally after fetching it from origin. */
+export async function ensureCommitAvailable(workspace, sha) {
+    const present = async () => {
+        try {
+            await execFileAsync("git", ["-C", workspace, "cat-file", "-e", `${sha}^{commit}`], {
+                timeout: 10_000,
+                windowsHide: true,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (await present())
+        return true;
+    try {
+        await execFileAsync("git", ["-C", workspace, "fetch", "--no-tags", "--depth=1", "origin", sha], {
+            timeout: 120_000,
+            windowsHide: true,
+        });
+    }
+    catch {
+        try {
+            await execFileAsync("git", ["-C", workspace, "fetch", "--no-tags", "origin"], {
+                timeout: 120_000,
+                windowsHide: true,
+            });
+        }
+        catch {
+            return false;
+        }
+    }
+    return present();
+}
 async function gitRemoteUrl(workspace) {
     try {
         const { common } = await gitDirectories(workspace);

package/dist/cli.js

@@ -6,7 +6,7 @@ import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { ConduitClient } from "./client.js";
-import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, savePendingConnection, suggestMachineName, } from "./config.js";
+import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, saveConfigPrefs, savePendingConnection, suggestMachineName, } from "./config.js";
 import { runMcp } from "./mcp.js";
 import { detectInstalledClients, localFuelOnlyClients, suggestFuelSource } from "./detect.js";
 import { DRIVERS } from "./driver.js";
@@ -219,7 +219,7 @@ async function finishConnection(baseUrl, data, fuelSource) {
     }
     console.log(`Confirmed capabilities (matching): ${config.capabilities.join(", ") || "none"}`);
     console.log(`Allowed actions: ${config.grants.join(", ") || "none"}`);
-    console.log(`Fuel source: ${config.fuelSource === "local" ? "local subscription" : "Conduit pump"}`
+    console.log(`Fuel source: ${config.fuelSource === "local" ? "local subscription" : "Conduit /v1 (project owner BYOK on open orgs; org credentials on invite-only)"}`
         + (fuelAutoLocal ? " (auto: only Cursor/Kiro/Antigravity detected)" : ""));
     const localOnly = localFuelOnlyClients(detected);
     if (config.fuelSource === "conduit" && localOnly.length) {
@@ -268,7 +268,7 @@ async function installService() {
         }
         config = seedDriverLanes(config, [values.agent]).config;
         config = setDriversOnline(config, [values.agent], true);
-        await saveConfig(config);
+        await saveConfigPrefs(config);
         console.log(`Brought ${values.agent} online for this computer (shared capacity ${config.leaseCapacity}).`);
     }
     else if (!onlineDriverIds(config).length) {
@@ -303,7 +303,7 @@ async function fuelCommand() {
     }
     const config = await loadConfig();
     config.fuelSource = mode;
-    await saveConfig(config);
+    await saveConfigPrefs(config);
     const client = new ConduitClient(config);
     await heartbeat(client, config, null);
     console.log(`Machine fuel source set to ${mode === "local" ? "local subscription" : "Conduit pump"} and reported on heartbeat.`);
@@ -313,7 +313,7 @@ async function driversCommand() {
     let config = await loadConfig();
     config = (await seedDriversFromDetection(config)).config;
     if (!sub || sub === "list") {
-        await saveConfig(config);
+        await saveConfigPrefs(config);
         const lanes = listDriverLanes(config);
         if (!lanes.length) {
             console.log("No driver lanes registered. Install a supported agent CLI, then re-run this command.");
@@ -339,7 +339,7 @@ async function driversCommand() {
         }
         config = seedDriverLanes(config, ids).config;
         config = setDriversOnline(config, ids, sub === "online");
-        await saveConfig(config);
+        await saveConfigPrefs(config);
         const client = new ConduitClient(config);
         await heartbeat(client, config, null).catch(() => undefined);
         console.log(`${sub === "online" ? "Online" : "Offline"}: ${ids.join(", ")}`);
@@ -354,7 +354,7 @@ async function driversCommand() {
         }
         config = seedDriverLanes(config, [id]).config;
         config = setDriverFuel(config, id, mode);
-        await saveConfig(config);
+        await saveConfigPrefs(config);
         console.log(`${driverLabel(id)} lane fuel set to ${mode}`);
         return;
     }
@@ -369,10 +369,10 @@ async function runner() {
     const fuelOverride = parseFuelSource(values.fuel);
     if (fuelOverride) {
         config.fuelSource = fuelOverride;
-        await saveConfig(config);
+        await saveConfigPrefs(config);
     }
     config = (await seedDriversFromDetection(config)).config;
-    await saveConfig(config);
+    await saveConfigPrefs(config);
     const client = new ConduitClient(config);
     let processDriver = null;
     let processOnlineIds = null;
@@ -415,11 +415,11 @@ async function runner() {
             config.drivers = latest.drivers;
             config.fuelSource = latest.fuelSource;
             config.leaseCapacity = latest.leaseCapacity;
-            await heartbeat(client, config, workspace ? await buildWorkspaceBrief(workspace).catch(() => brief) : null);
+            await heartbeat(client, config, workspace ? await buildWorkspaceBrief(workspace).catch(() => brief) : null, processOnlineIds);
             await renewLeases(client, config);
             if (workspace && (processDriver || onlineDriverIds(config).length)) {
                 progressed = await pumpExecutionSlots(client, config, workspace, brief, timeoutMs, {
-                    heartbeat: async () => heartbeat(client, config, await buildWorkspaceBrief(workspace).catch(() => brief)),
+                    heartbeat: async () => heartbeat(client, config, await buildWorkspaceBrief(workspace).catch(() => brief), processOnlineIds),
                     heartbeatIntervalMs: intervalMs,
                 }, running, { driver: processDriver, processOnlineIds });
             }
@@ -435,15 +435,16 @@ async function runner() {
         await new Promise((resolveSleep) => setTimeout(resolveSleep, intervalMs));
     }
 }
-async function heartbeat(client, config, brief) {
-    const online = onlineDriverIds(config);
+async function heartbeat(client, config, brief, processOnlineIds) {
+    // Process-level `--agent` override must count as online even when saved lanes are offline.
+    const online = processOnlineIds?.length ? processOnlineIds : onlineDriverIds(config);
     const status = heartbeatStatusForDrivers(online);
     await client.request("/runner/v1/heartbeat", { method: "POST", body: JSON.stringify({
             status,
             capabilities: config.capabilities,
             lease_capacity: config.leaseCapacity,
             fuel_source: config.fuelSource === "local" ? "local" : "conduit",
-            drivers: driversHeartbeatReport(config, config.activeAttempts),
+            drivers: driversHeartbeatReport(config, config.activeAttempts, processOnlineIds),
             ...(brief ? { workspace_brief: brief } : {}),
         }) });
 }

package/dist/client.js

@@ -1,4 +1,4 @@
-import { saveConfig } from "./config.js";
+import { removeRuntimeAttempt, saveConfigPrefs, saveRuntime } from "./config.js";
 export class ConduitRequestError extends Error {
     status;
     code;
@@ -10,10 +10,24 @@ export class ConduitRequestError extends Error {
 }
 export class ConduitClient {
     config;
-    persist;
-    constructor(config, persist = saveConfig) {
+    persistRuntime;
+    persistPrefs;
+    removeAttempt;
+    constructor(config, persist) {
         this.config = config;
-        this.persist = persist;
+        if (typeof persist === "function") {
+            this.persistRuntime = persist;
+            this.persistPrefs = persist;
+            this.removeAttempt = async (taskId) => {
+                delete this.config.activeAttempts[taskId];
+                await persist(this.config);
+            };
+        }
+        else {
+            this.persistRuntime = persist?.runtime ?? saveRuntime;
+            this.persistPrefs = persist?.prefs ?? saveConfigPrefs;
+            this.removeAttempt = persist?.removeAttempt ?? removeRuntimeAttempt;
+        }
     }
     async request(path, init = {}) {
         const response = await fetch(`${this.config.baseUrl}${path}`, {
@@ -25,11 +39,18 @@ export class ConduitClient {
             throw new ConduitRequestError(data.error?.message ?? `Conduit request failed (${response.status})`, response.status, data.error?.code);
         return data;
     }
-    async claim(taskId, attemptId) {
+    async claim(taskId, attemptId, extras) {
         const data = await this.request(`/runner/v1/tasks/${taskId}/claim`, { method: "POST", body: JSON.stringify({ attempt_id: attemptId, idempotency_key: `bridge:claim:${attemptId}` }) });
-        const active = { taskId, attemptId, leaseToken: String(data.lease_token), leaseExpiresAt: String(data.lease_expires_at), phase: "claimed" };
+        const active = {
+            taskId,
+            attemptId,
+            leaseToken: String(data.lease_token),
+            leaseExpiresAt: String(data.lease_expires_at),
+            phase: "claimed",
+            ...(extras?.driverId ? { driverId: extras.driverId } : {}),
+        };
         this.config.activeAttempts[taskId] = active;
-        await this.persist(this.config);
+        await this.persistRuntime(this.config);
         return { ...data, lease_token: "stored by Conduit Bridge" };
     }
     attempt(taskId) {
@@ -51,12 +72,15 @@ export class ConduitClient {
             else
                 Object.assign(active, { [key]: value });
         }
-        await this.persist(this.config);
+        await this.persistRuntime(this.config);
         return active;
     }
     async clearAttempt(taskId) {
+        const active = this.config.activeAttempts[taskId];
         delete this.config.activeAttempts[taskId];
-        await this.persist(this.config);
+        if (this.config.sessions)
+            delete this.config.sessions[taskId];
+        await this.removeAttempt(taskId, active?.attemptId);
     }
     /**
      * Ensure a project-scoped gateway fuel key for agent /v1 calls.
@@ -74,7 +98,7 @@ export class ConduitClient {
             gatewayKey = String(rotated.gateway_secret);
         }
         this.config.fuel = { ...this.config.fuel, [projectId]: { gatewayKey } };
-        await this.persist(this.config);
+        await this.persistPrefs(this.config);
         return gatewayKey;
     }
 }

package/dist/config.js

@@ -1,7 +1,9 @@
-import { chmod, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, readFile, rename, unlink, writeFile, stat } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+/** Serialize config writes in-process so concurrent claim/phase updates cannot clobber each other. */
+let saveChain = Promise.resolve();
 /** Default when join omits --capacity. */
 export const BRIDGE_LEASE_CAPACITY = 1;
 /** Hard ceiling for truthful concurrent Bridge slots (one agent + worktree each). */
@@ -16,6 +18,9 @@ const directory = process.env.CONDUIT_BRIDGE_CONFIG_DIR?.trim()
     ? resolve(process.env.CONDUIT_BRIDGE_CONFIG_DIR)
     : join(homedir(), ".config", "conduit");
 const path = join(directory, "config.json");
+/** Runtime attempt/session state — separate so drivers CLI cannot clobber live claims. */
+const runtimePath = join(directory, "runtime.json");
+const lockPath = join(directory, "config.lock");
 const pendingPath = join(directory, "pending-connect.json");
 const installationPath = join(directory, "installation.json");
 export async function loadConfig() {
@@ -43,7 +48,10 @@ export async function loadConfigIfPresent() {
             throw new Error(`Bridge configuration is missing ${field}; run \`conduit join --url <worker-url>\` to reconnect this machine.`);
         }
     }
-    config.activeAttempts ??= {};
+    const runtime = await loadRuntime();
+    // Prefer dedicated runtime file; fall back to legacy fields still present in config.json.
+    config.activeAttempts = runtime?.activeAttempts ?? config.activeAttempts ?? {};
+    config.sessions = runtime?.sessions ?? config.sessions;
     for (const active of Object.values(config.activeAttempts))
         active.phase ??= "agent_running";
     if (config.fuelSource !== "local" && config.fuelSource !== "conduit")
@@ -63,10 +71,175 @@ export async function loadConfigIfPresent() {
     }
     return config;
 }
-export async function saveConfig(config) {
+async function loadRuntime() {
+    try {
+        const raw = JSON.parse(await readFile(runtimePath, "utf8"));
+        return {
+            activeAttempts: raw.activeAttempts && typeof raw.activeAttempts === "object" ? raw.activeAttempts : {},
+            sessions: raw.sessions && typeof raw.sessions === "object" ? raw.sessions : undefined,
+            tombstones: raw.tombstones && typeof raw.tombstones === "object" ? raw.tombstones : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function withConfigLock(fn) {
     await mkdir(directory, { recursive: true, mode: 0o700 });
-    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
-    await chmod(path, 0o600);
+    const started = Date.now();
+    for (;;) {
+        try {
+            const handle = await open(lockPath, "wx");
+            try {
+                await handle.writeFile(`${process.pid}\n`);
+                return await fn();
+            }
+            finally {
+                await handle.close().catch(() => undefined);
+                await unlink(lockPath).catch(() => undefined);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "EEXIST")
+                throw error;
+            try {
+                const age = Date.now() - (await stat(lockPath)).mtimeMs;
+                if (age > 30_000)
+                    await unlink(lockPath).catch(() => undefined);
+            }
+            catch { /* lock raced away */ }
+            if (Date.now() - started > 10_000)
+                throw new Error("Timed out waiting for Bridge config lock");
+            await new Promise((resolveSleep) => setTimeout(resolveSleep, 25));
+        }
+    }
+}
+async function writeJsonAtomic(filePath, value) {
+    const tmp = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+        await rename(tmp, filePath);
+        await chmod(filePath, 0o600);
+    }
+    catch (error) {
+        await unlink(tmp).catch(() => undefined);
+        throw error;
+    }
+}
+/** Merge snapshot onto disk without resurrecting attempts removed under lock. */
+export function mergeRuntimeState(disk, snapshot) {
+    const tombstones = { ...(disk?.tombstones ?? {}) };
+    const merged = { ...(disk?.activeAttempts ?? {}) };
+    for (const [taskId, attempt] of Object.entries(snapshot.activeAttempts ?? {})) {
+        if (tombstones[taskId] === attempt.attemptId)
+            continue;
+        const onDisk = merged[taskId];
+        if (onDisk && onDisk.attemptId !== attempt.attemptId)
+            continue;
+        merged[taskId] = attempt;
+        delete tombstones[taskId];
+    }
+    const sessions = { ...(disk?.sessions ?? {}), ...(snapshot.sessions ?? {}) };
+    for (const taskId of Object.keys(tombstones))
+        delete sessions[taskId];
+    return {
+        activeAttempts: merged,
+        sessions: Object.keys(sessions).length ? sessions : undefined,
+        tombstones: Object.keys(tombstones).length ? tombstones : undefined,
+    };
+}
+/**
+ * Persist Bridge config. Operator prefs and runtime attempt state are written as separate files under
+ * a cross-process lock so `drivers online|offline` cannot erase an in-flight claim (and vice versa).
+ */
+export async function saveConfig(config, options = {}) {
+    const snapshot = structuredClone(config);
+    const run = async () => {
+        await withConfigLock(async () => {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            // One-time migrate: if runtime.json is missing, preserve legacy activeAttempts from config.json.
+            const existingRuntime = await loadRuntime();
+            if (!existingRuntime) {
+                let legacyAttempts = {};
+                let legacySessions;
+                try {
+                    const legacy = JSON.parse(await readFile(path, "utf8"));
+                    if (legacy.activeAttempts && typeof legacy.activeAttempts === "object")
+                        legacyAttempts = legacy.activeAttempts;
+                    if (legacy.sessions && typeof legacy.sessions === "object")
+                        legacySessions = legacy.sessions;
+                }
+                catch { /* no prior config */ }
+                if (Object.keys(legacyAttempts).length || legacySessions) {
+                    await writeJsonAtomic(runtimePath, { activeAttempts: legacyAttempts, sessions: legacySessions });
+                }
+            }
+            const prefs = { ...snapshot };
+            delete prefs.activeAttempts;
+            delete prefs.sessions;
+            const prefsForDisk = { ...prefs, activeAttempts: {}, sessions: undefined };
+            await writeJsonAtomic(path, prefsForDisk);
+            if (!options.prefsOnly) {
+                const disk = await loadRuntime();
+                await writeJsonAtomic(runtimePath, mergeRuntimeState(disk, {
+                    activeAttempts: snapshot.activeAttempts ?? {},
+                    sessions: snapshot.sessions,
+                }));
+            }
+        });
+    };
+    const next = saveChain.then(run, run);
+    saveChain = next.catch(() => undefined);
+    await next;
+}
+/** Operator-pref write that leaves runtime.json (claims/sessions) untouched. */
+export async function saveConfigPrefs(config) {
+    await saveConfig(config, { prefsOnly: true });
+}
+/**
+ * Claim/session write that leaves prefs untouched and merges with on-disk attempts from other
+ * Bridge processes (supervisor vs MCP) instead of replacing the whole runtime snapshot.
+ */
+export async function saveRuntime(config) {
+    const snapshot = structuredClone(config);
+    const run = async () => {
+        await withConfigLock(async () => {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            const disk = await loadRuntime();
+            await writeJsonAtomic(runtimePath, mergeRuntimeState(disk, {
+                activeAttempts: snapshot.activeAttempts ?? {},
+                sessions: snapshot.sessions,
+            }));
+        });
+    };
+    const next = saveChain.then(run, run);
+    saveChain = next.catch(() => undefined);
+    await next;
+}
+/** Remove one attempt under the lock; no-op if another process already replaced the claim. */
+export async function removeRuntimeAttempt(taskId, attemptId) {
+    const run = async () => {
+        await withConfigLock(async () => {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            const disk = await loadRuntime();
+            if (!disk)
+                return;
+            const current = disk.activeAttempts[taskId];
+            if (!current)
+                return;
+            if (attemptId && current.attemptId !== attemptId)
+                return;
+            delete disk.activeAttempts[taskId];
+            if (disk.sessions)
+                delete disk.sessions[taskId];
+            disk.tombstones = { ...(disk.tombstones ?? {}), [taskId]: current.attemptId };
+            await writeJsonAtomic(runtimePath, disk);
+        });
+    };
+    const next = saveChain.then(run, run);
+    saveChain = next.catch(() => undefined);
+    await next;
 }
 export async function loadPendingConnection() {
     try {

package/dist/driver.js

@@ -81,6 +81,7 @@ export function buildAssignmentPrompt(context) {
     const changeScope = packageContext?.change_scope?.length ? packageContext.change_scope : spec.change_scope;
     const evidence = packageContext?.required_evidence?.length ? packageContext.required_evidence : spec.required_evidence;
     const rework = packageContext?.rework_feedback ?? context.reworkFeedback;
+    const artifact = (packageContext?.deliverable ?? spec.deliverable) === "artifact";
     const lines = [
         `You are completing one delegated Conduit assignment as the ${role} role. Work only inside the current workspace.`,
         "",
@@ -99,8 +100,17 @@ export function buildAssignmentPrompt(context) {
         lines.push("", `BOUNDARIES — never violate these\n${boundaries.map((item) => `- ${item}`).join("\n")}`);
     if (acceptance?.length)
         lines.push("", `ACCEPTANCE CRITERIA — the delivery is judged against these\n${acceptance.map((item) => `- ${item}`).join("\n")}`);
-    if (evidence?.length)
-        lines.push("", `REQUIRED EVIDENCE\n${evidence.map((item) => `- ${item}`).join("\n")}`);
+    if (evidence?.length) {
+        lines.push("", "REQUIRED EVIDENCE");
+        for (const kind of evidence) {
+            if (kind === "test") {
+                lines.push("- test — include verbatim command stdout/stderr (and exit code) in evidence details; summaries alone are rejected");
+            }
+            else {
+                lines.push(`- ${kind}`);
+            }
+        }
+    }
     if (changeScope?.length)
         lines.push("", `CHANGE SCOPE — only modify paths under\n${changeScope.map((item) => `- ${item}`).join("\n")}`);
     if (spec.repository?.base_commit)
@@ -113,6 +123,7 @@ export function buildAssignmentPrompt(context) {
     if (rework)
         lines.push("", `REWORK FEEDBACK — an independent review returned this delivery; address every point\n${rework}`);
     const mustCommit = context.grants.includes("repo_write") && context.grants.includes("branch_create");
+    const mustOpenPr = mustCommit && context.grants.includes("pr_create") && Boolean(changeScope?.length);
     // Exactly what the driver's permission contract will allow, derived from the same source, so the
     // prompt cannot drift from the enforcement.
     const runnableCommands = [
@@ -130,8 +141,24 @@ export function buildAssignmentPrompt(context) {
             `- These are the ONLY shell commands you may run: ${runnableCommands.join("; ")}. Anything else is rejected — do not try variations, wrappers, or \`echo\`. Run the relevant ones and report their real output.`,
         ]
         : ["- You have no shell authority for this assignment. Do not attempt shell commands; verify by reading files and report what you could not verify as unknown."]), ...(mustCommit
-        ? ["- Your working branch is already checked out. Commit your repository changes on the current branch (git add + git commit) — do not create a new branch — and report the resulting sha as head_commit. A delivery that changed files without a commit is rejected. Local commits are required; pushing is a separate authority."]
-        : ["- You have no repository write authority for this assignment. Do not create, modify, or commit any file; a delivery reporting repository changes will be rejected. Record all findings, verification output, and conclusions in your final report instead."]), "- Never merge, deploy, push to protected branches, or touch production.", `- Hard-denied commands (all drivers): ${deniedCommands.join("; ")}.`, "- Do not invent evidence. Report unknown when you could not verify a criterion.", 
+        ? [
+            "- Your working branch is already checked out. Commit your repository changes on the current branch (git add + git commit) — do not create a new branch — and report the resulting sha as head_commit. A delivery that changed files without a commit is rejected.",
+            ...(mustOpenPr
+                ? [
+                    "- This assignment includes pr_create: after committing, `git push -u origin HEAD` and `gh pr create` against the repository default branch, then set pull_request_url to that PR URL. Conduit merge-on-accept lands the PR when the owner Accepts — a head_commit without a PR leaves main unchanged and breaks later packages.",
+                ]
+                : ["- You may commit locally; opening a pull request is outside this assignment's grants."]),
+        ]
+        : artifact
+            ? [
+                // repo_write without branch_create: the agent may write, but the output is not repository
+                // content. `.conduit/` is already in .git/info/exclude, so this path is ignored by git and
+                // `git status` stays clean — which is the point for a content pack, and mandatory for
+                // anything binary.
+                "- This assignment delivers an artifact, not repository content. Write your output under `.conduit/artifacts/` — that path is excluded from git, so do not commit anything and do not report a head_commit.",
+                "- Publish the artifact to its destination and report each output in your evidence with the published URL and a sha256 digest. An artifact nobody can fetch is not a delivery.",
+            ]
+            : ["- You have no repository write authority for this assignment. Do not create, modify, or commit any file; a delivery reporting repository changes will be rejected. Record all findings, verification output, and conclusions in your final report instead."]), "- Never merge, deploy, force-push, push to protected branches, or touch production.", `- Hard-denied commands (all drivers): ${deniedCommands.join("; ")}.`, "- Do not invent evidence. Report unknown when you could not verify a criterion.", 
     // A met claim with nothing backing it is rejected server-side ("Met acceptance criteria require
     // mapped evidence"). Observed live: six criteria marked met, evidence mapped to four, whole
     // delivery lost. Say it here rather than let the agent discover it by failing.
@@ -832,7 +859,7 @@ function boundedEnvironment(fuel, fuelSource = "conduit") {
         ...(fuelSource === "local" ? LOCAL_VENDOR_ENV : [])];
     const env = Object.fromEntries(allowed.flatMap((name) => process.env[name] === undefined ? [] : [[name, process.env[name]]]));
     if (fuelSource === "conduit" && fuel) {
-        const v1 = `${fuel.baseUrl.replace(/\/+$/, "")}/v1`;
+        const v1 = fuelEndpoint(fuel.baseUrl);
         env.ANTHROPIC_API_KEY = fuel.gatewayKey;
         env.ANTHROPIC_BASE_URL = v1;
         env.OPENAI_API_KEY = fuel.gatewayKey;
@@ -841,6 +868,10 @@ function boundedEnvironment(fuel, fuelSource = "conduit") {
     }
     return env;
 }
+/** The `/v1` a fuelled agent is pointed at — and the one its model names are validated against. */
+export function fuelEndpoint(baseUrl) {
+    return `${baseUrl.replace(/\/+$/, "")}/v1`;
+}
 export function hasClaudeLogin(env = process.env) {
     if (env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN)
         return true;

package/dist/drivers.js

@@ -129,7 +129,8 @@ export function advertiseLeaseCapacity(approved, onlineIds) {
         return 1; // schema/heartbeat min; status standby prevents matching
     return approved;
 }
-export function driversHeartbeatReport(config, activeAttempts) {
+export function driversHeartbeatReport(config, activeAttempts, processOnlineIds) {
+    const processOnline = new Set(processOnlineIds ?? []);
     const busyByDriver = new Map();
     for (const active of Object.values(activeAttempts)) {
         if (!active.driverId)
@@ -138,7 +139,7 @@ export function driversHeartbeatReport(config, activeAttempts) {
     }
     return listDriverLanes(config).map((lane) => ({
         id: lane.id,
-        state: lane.state,
+        state: processOnline.has(lane.id) ? "online" : lane.state,
         busy: (busyByDriver.get(lane.id) ?? 0) > 0,
     }));
 }

package/dist/ensure-pull-request.js

@@ -0,0 +1,98 @@
+/**
+ * After the agent commits scoped work with pr_create, Bridge must land a GitHub PR.
+ * Push uses the machine's git credentials; PR creation uses the control-plane GitHub
+ * credential via /runner/v1/tasks/:id/open-pull-request so secrets never live on runners.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export function needsPullRequest(report, spec, grants) {
+    return Boolean(grants.includes("pr_create")
+        && (spec.change_scope?.length ?? 0) > 0
+        && report.head_commit
+        && !report.pull_request_url);
+}
+/** True when reported SHA equals workspace HEAD (allows short SHA prefixes). */
+export function isAbsoluteHttpsUrl(value) {
+    try {
+        return new URL(value).protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+export function commitsMatch(reported, actual) {
+    const left = reported.trim().toLowerCase();
+    const right = actual.trim().toLowerCase();
+    if (!left || !right)
+        return false;
+    return left === right || left.startsWith(right) || right.startsWith(left);
+}
+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().toLowerCase();
+    if (!/^[0-9a-f]{7,64}$/.test(head))
+        throw new Error("Could not determine workspace HEAD commit");
+    return head;
+}
+/**
+ * Bind reported head_commit to the checkout HEAD, then open a PR when still needed.
+ * Agent-supplied PR URLs skip creation but still require HEAD identity.
+ */
+export async function ensureDeliveryPullRequest(input) {
+    const readHead = input.readHeadCommit ?? workspaceHeadCommit;
+    let report = input.report;
+    if (report.head_commit && (input.spec.change_scope?.length ?? 0) > 0) {
+        const head = await readHead(input.workspace);
+        if (!commitsMatch(report.head_commit, head)) {
+            throw new Error(`Delivered head_commit ${report.head_commit} does not match workspace HEAD ${head}`);
+        }
+        report = { ...report, head_commit: head };
+    }
+    if (!needsPullRequest(report, input.spec, input.grants))
+        return report;
+    await execFileAsync("git", ["-C", input.workspace, "push", "-u", "origin", "HEAD"], {
+        timeout: 120_000,
+        maxBuffer: 2_000_000,
+    });
+    const headAfterPush = await readHead(input.workspace);
+    if (!report.head_commit || !commitsMatch(report.head_commit, headAfterPush)) {
+        throw new Error(`Workspace HEAD changed during push (${report.head_commit} → ${headAfterPush})`);
+    }
+    report = { ...report, head_commit: headAfterPush };
+    const { stdout: branchOut } = await execFileAsync("git", ["-C", input.workspace, "branch", "--show-current"], {
+        timeout: 30_000,
+        maxBuffer: 1_000_000,
+    });
+    const headBranch = branchOut.trim();
+    if (!headBranch)
+        throw new Error("Could not determine the attempt branch for pull request creation");
+    const response = await input.client.attemptRequest(input.taskId, "open-pull-request", {
+        head_branch: headBranch,
+        head_commit: report.head_commit,
+        title: (input.title ?? "Conduit delivery").slice(0, 200),
+        body: [
+            "Opened by Conduit Bridge after the agent committed scoped delivery work.",
+            "",
+            `Head commit: ${report.head_commit}`,
+        ].join("\n"),
+        idempotency_key: `bridge:open-pr:${input.attemptId}`,
+    });
+    const pullRequestUrl = typeof response.pull_request_url === "string" ? response.pull_request_url : "";
+    // Any https URL: the control plane resolved which forge this project uses and parsed the response
+    // with that forge's own rules, so re-asserting a github.com shape here would only reject a valid
+    // GitLab merge request — after the branch was already pushed. The head-commit cross-check below is
+    // what actually proves the returned change request is this delivery's.
+    if (!isAbsoluteHttpsUrl(pullRequestUrl)) {
+        throw new Error("Control plane did not return a pull_request_url");
+    }
+    const openedHead = typeof response.head_commit === "string" ? response.head_commit : "";
+    const deliveredHead = report.head_commit ?? "";
+    if (openedHead && deliveredHead && !commitsMatch(openedHead, deliveredHead)) {
+        throw new Error(`Opened pull request head ${openedHead} does not match delivered commit ${deliveredHead}`);
+    }
+    return { ...report, pull_request_url: pullRequestUrl };
+}

package/dist/execution.js

@@ -2,10 +2,25 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ConduitRequestError } from "./client.js";
 import { redactSecrets } from "./config.js";
-import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, parseAgentReport, pickModelCandidate, tierForRisk } from "./driver.js";
+import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, fuelEndpoint, parseAgentReport, pickModelCandidate, tierForRisk } from "./driver.js";
 import { pickDriverForClaim, resolveDriverFuel } from "./drivers.js";
 import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
-import { buildWorkspaceBrief, isBaseCommitAncestor, normalizeRepositoryUrl } from "./brief.js";
+import { buildWorkspaceBrief, ensureCommitAvailable, isBaseCommitAncestor, normalizeRepositoryUrl } from "./brief.js";
+import { ensureDeliveryPullRequest } from "./ensure-pull-request.js";
+/** Feedback text for changes_requested summaries (plain string or `{ feedback }`). */
+function changesRequestedFeedback(summary) {
+    if (!summary)
+        return null;
+    if (!summary.startsWith("{"))
+        return summary;
+    try {
+        const parsed = JSON.parse(summary);
+        return typeof parsed.feedback === "string" && parsed.feedback.trim() ? parsed.feedback : null;
+    }
+    catch {
+        return null;
+    }
+}
 const assignmentSchema = z.object({
     id: z.string().uuid(),
     attempt_id: z.string().uuid(),
@@ -70,7 +85,11 @@ export async function renewLeases(client, config) {
 function resolveAttemptDriver(config, active, fallback) {
     if (active.driverId && DRIVERS[active.driverId])
         return DRIVERS[active.driverId];
-    return fallback ?? null;
+    if (fallback)
+        return fallback;
+    // Crash between claim and driverId persist: pick any free online lane so recovery is not stranded.
+    const picked = pickDriverForClaim(config);
+    return picked ? DRIVERS[picked] ?? null : null;
 }
 export async function recoverActiveAttempt(client, config, driver, workspace, brief, timeoutMs, supervision, taskId) {
     const active = taskId ? config.activeAttempts[taskId] : Object.values(config.activeAttempts)[0];
@@ -81,6 +100,11 @@ export async function recoverActiveAttempt(client, config, driver, workspace, br
         console.error(`No driver for attempt ${active.attemptId} (driverId=${active.driverId ?? "unset"})`);
         return false;
     }
+    if (!active.driverId) {
+        const assigned = Object.entries(DRIVERS).find(([, d]) => d === laneDriver)?.[0];
+        if (assigned)
+            await client.updateAttempt(active.taskId, { driverId: assigned });
+    }
     if (active.phase === "agent_running") {
         const worktree = active.worktreePath ?? attemptWorktreePath(workspace, active.attemptId);
         const sessionId = config.sessions?.[active.taskId]?.trim() || "";
@@ -158,10 +182,9 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
         }
         if (!laneDriver || !driverId)
             break;
-        const taskId = await claimNextAssignment(client, config, workspace, brief);
+        const taskId = await claimNextAssignment(client, config, workspace, brief, driverId);
         if (!taskId)
             break;
-        await client.updateAttempt(taskId, { driverId });
         progressed = true;
         console.log(`Executing ${taskId} via ${laneDriver.name}`);
         const slot = runClaimedAssignment(client, config, laneDriver, workspace, brief, taskId, timeoutMs, supervision)
@@ -175,7 +198,7 @@ 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) {
+export async function claimNextAssignment(client, config, workspace, brief, driverId) {
     if (Object.keys(config.activeAttempts).length >= config.leaseCapacity)
         return null;
     const data = await client.request("/runner/v1/assignments");
@@ -192,11 +215,15 @@ export async function claimNextAssignment(client, config, workspace, brief) {
     let rejection = null;
     if (assignment.repository_fingerprint && liveRepository !== assignment.repository_fingerprint)
         rejection = "workspace_repository_mismatch";
-    else if (assignment.repository_fingerprint && liveBrief?.base_commit !== assignment.claimed_head)
-        rejection = "workspace_head_changed";
-    else if (assignment.requested_base_commit && assignment.claimed_head) {
-        const compatible = await isBaseCommitAncestor(workspace, assignment.requested_base_commit, assignment.claimed_head).catch(() => false);
-        if (!compatible)
+    else if (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) {
+        const startHead = await resolveStartHead(workspace, assignment.requested_base_commit, assignment.claimed_head);
+        if (!startHead)
             rejection = "base_not_ancestor";
     }
     if (rejection) {
@@ -208,9 +235,28 @@ export async function claimNextAssignment(client, config, workspace, brief) {
         return null;
     }
     console.log(`Claiming assignment ${assignment.id} (attempt ${assignment.attempt_id})`);
-    await client.claim(assignment.id, assignment.attempt_id);
+    await client.claim(assignment.id, assignment.attempt_id, driverId ? { driverId } : undefined);
     return assignment.id;
 }
+/**
+ * When a sibling merge advances task.base_commit past the machine checkout, the required base is a
+ * descendant of claimed_head — not an ancestor. Fetch it and start from the advanced base instead of looping.
+ */
+async function resolveStartHead(workspace, requestedBase, claimedHead) {
+    if (await isBaseCommitAncestor(workspace, requestedBase, claimedHead).catch(() => false))
+        return claimedHead;
+    await ensureCommitAvailable(workspace, requestedBase).catch(() => false);
+    if (await isBaseCommitAncestor(workspace, requestedBase, claimedHead).catch(() => false))
+        return claimedHead;
+    // Workspace is behind the required base (dependent package after merge).
+    if (await isBaseCommitAncestor(workspace, claimedHead, requestedBase).catch(() => false))
+        return requestedBase;
+    if (await ensureCommitAvailable(workspace, requestedBase).catch(() => false)
+        && await isBaseCommitAncestor(workspace, claimedHead, requestedBase).catch(() => false)) {
+        return requestedBase;
+    }
+    return null;
+}
 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);
@@ -228,25 +274,40 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
     const workPackage = workPackageSchema.parse(detail.work_package) ?? null;
     const spec = parseTaskSpec(task.spec_json);
     const grants = z.array(z.string()).parse(task.grants_json ? JSON.parse(task.grants_json) : []);
-    const reworkFeedback = task.delivery_state === "changes_requested" && task.delivery_summary && !task.delivery_summary.startsWith("{") ? task.delivery_summary : null;
+    const reworkFeedback = 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;
-    if (executionContract.repository_fingerprint && (liveRepository !== executionContract.repository_fingerprint
-        || !liveBrief?.base_commit
-        || liveBrief.base_commit !== executionContract.claimed_head)) {
-        const message = liveRepository !== executionContract.repository_fingerprint
-            ? "Workspace repository changed after dispatch"
-            : "Workspace HEAD changed after dispatch";
-        await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: true, idempotency_key: `bridge:workspace-mismatch:${active.attemptId}` } });
-        console.error(`Assignment ${taskId} preflight failed: ${message}`);
+    if (executionContract.repository_fingerprint && liveRepository !== executionContract.repository_fingerprint) {
+        await queueTerminal(client, taskId, { action: "fail", body: { error: "Workspace repository changed after dispatch", retryable: true, idempotency_key: `bridge:workspace-mismatch:${active.attemptId}` } });
+        console.error(`Assignment ${taskId} preflight failed: Workspace repository changed after dispatch`);
         return;
     }
-    const startCommit = executionContract.claimed_head ?? liveBrief?.base_commit;
+    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 resolveStartHead(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;
+        }
+    }
     let attemptWorkspace;
     if (options.existingWorktree) {
         attemptWorkspace = options.existingWorktree;
@@ -256,7 +317,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             attemptWorkspace = await createAttemptWorktree({
                 sourceWorkspace: workspace,
                 attemptId: active.attemptId,
-                startCommit,
+                startCommit: worktreeStart,
             });
         }
         catch (error) {
@@ -272,7 +333,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
     }
     // Same list the driver hands to the permission contract, so the prompt states exactly what is
     // executable rather than leaving the agent to guess and hit rejections.
-    const prompt = buildAssignmentPrompt({ taskId, objective: task.objective, spec, grants, workspace: attemptWorkspace, currentHead: startCommit, reworkFeedback, workPackage, verificationCommands: liveBrief?.verification ?? [] });
+    const prompt = buildAssignmentPrompt({ taskId, objective: task.objective, spec, grants, workspace: attemptWorkspace, currentHead: worktreeStart, reworkFeedback, workPackage, verificationCommands: liveBrief?.verification ?? [] });
     const resuming = Boolean(options.forceResumeSessionId);
     await client.attemptRequest(taskId, "progress", {
         phase: "changing",
@@ -292,7 +353,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         const gatewayKey = await client.ensureFuel(task.project_id);
         fuel = { baseUrl: config.baseUrl, gatewayKey };
     }
-    const selection = await resolveAssignmentModel(driver, config, spec, taskId, attemptWorkspace);
+    const selection = await resolveAssignmentModel(driver, config, spec, taskId, attemptWorkspace, fuel);
     await client.attemptRequest(taskId, "model-selection", {
         risk: selection.risk, tier: selection.tier, model: selection.model ?? null, driver: driver.name,
         ...(selection.model ? {} : { note: "cli-default" }), idempotency_key: `model:${active.attemptId}`,
@@ -399,11 +460,25 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             }
         }
         try {
+            // Mechanical land path: agent may forget gh; Bridge pushes and the control plane opens the PR.
+            report = await ensureDeliveryPullRequest({
+                client,
+                taskId,
+                attemptId: active.attemptId,
+                workspace: attemptWorkspace,
+                report,
+                spec,
+                grants,
+                title: task.objective,
+            });
             validateDeliveryReport(report, spec, grants);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Agent delivery report was invalid";
-            await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable: false, idempotency_key: `bridge:invalid-delivery:${active.attemptId}` } });
+            // Missing PR tooling / credential is retryable once the environment is fixed; other contract
+            // failures (scope, evidence mapping) stay non-retryable.
+            const retryable = /pull_request|merge_request|forge|GitHub|GitLab|gh |push|credential/i.test(message);
+            await queueTerminal(client, taskId, { action: "fail", body: { error: message, retryable, idempotency_key: `bridge:invalid-delivery:${active.attemptId}` } });
             console.error(`Assignment ${taskId} could not produce a valid Delivery: ${redactSecrets(message)}`);
             const replyTail = reportText.slice(-8_000);
             console.error(`Assignment ${taskId} agent reply tail (${reportText.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);
@@ -458,36 +533,77 @@ async function submitFinishedDelivery(client, taskId) {
     await client.attemptRequest(taskId, "progress", { phase: "preparing_delivery", message: "Agent finished; submitting the Delivery.", idempotency_key: `bridge:progress:${active.attemptId}:delivery` });
     await queueTerminal(client, taskId, terminal);
 }
-/**
- * The live model list per driver, cached with a TTL so tier candidates are
- * re-validated against reality as vendors add and retire models — no config
- * edit or restart needed for the refresh itself.
- */
-const modelListCache = new Map();
+export const modelListCache = new Map();
 const MODEL_LIST_TTL_MS = 6 * 60 * 60 * 1000;
-async function availableModels(driver, workspace) {
+/** A failure is remembered only briefly: long enough not to re-pay it per claim, short enough that
+ *  validation resumes soon after the cause clears. */
+const MODEL_LIST_FAILURE_TTL_MS = 60 * 1000;
+export async function availableModels(driver, workspace, fuel) {
+    // Under Conduit fuel the agent's requests go to Conduit's /v1, which resolves an organization alias
+    // and rejects a vendor model name outright — so the list that matters is Conduit's, not the CLI's.
+    // If it cannot be read, fall back to the CLI's list rather than to no validation at all.
+    if (fuel) {
+        const aliases = await cachedList(`conduit:${fuel.baseUrl}`, () => conduitAliases(fuel));
+        if (aliases)
+            return aliases;
+    }
     if (!driver.listModels)
         return null;
-    const cached = modelListCache.get(driver.name);
-    if (cached && Date.now() - cached.at < MODEL_LIST_TTL_MS)
+    return cachedList(driver.name, () => driver.listModels(undefined, workspace).catch(() => null));
+}
+export async function cachedList(key, load) {
+    const cached = modelListCache.get(key);
+    const ttl = cached?.available ? MODEL_LIST_TTL_MS : MODEL_LIST_FAILURE_TTL_MS;
+    if (cached && Date.now() - cached.at < ttl)
         return cached.available;
-    const available = await driver.listModels(undefined, workspace).catch(() => null);
-    modelListCache.set(driver.name, { at: Date.now(), available });
+    const available = await load();
+    modelListCache.set(key, { at: Date.now(), available });
     return available;
 }
-async function resolveAssignmentModel(driver, config, spec, taskId, workspace) {
+/** The organization's enabled aliases, which is exactly what /v1 will accept as a model. */
+export async function conduitAliases(fuel) {
+    try {
+        const response = await fetch(`${fuelEndpoint(fuel.baseUrl)}/models`, {
+            headers: { authorization: `Bearer ${fuel.gatewayKey}` },
+        });
+        if (!response.ok)
+            return null;
+        const body = await response.json();
+        const ids = (body.data ?? []).map((row) => row.id).filter((id) => typeof id === "string");
+        return ids.length ? new Set(ids) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveAssignmentModel(driver, config, spec, taskId, workspace, fuel) {
     const tier = tierForRisk(spec.risk_level);
     const configured = config.models?.[tier];
     const risk = spec.risk_level === "low" || spec.risk_level === "medium" || spec.risk_level === "high" ? spec.risk_level : "unset";
+    let listed;
+    const list = async () => (listed === undefined ? (listed = await availableModels(driver, workspace, fuel)) : listed);
+    const offered = async () => {
+        const available = fuel ? await list() : null;
+        return available ? ` Conduit accepts: ${[...available].join(", ")}.` : "";
+    };
     if (!configured || (Array.isArray(configured) && configured.length === 0)) {
-        console.log(`Assignment ${taskId} intelligence tier ${tier} (risk ${risk}); no model mapping — CLI default`);
+        // Not fatal on purpose. Conduit's /v1 rejects a vendor model name — proven by `npm run
+        // probe:fuel` — so under Conduit fuel the CLI's own default cannot resolve. Whether every driver
+        // honours the injected base URL rather than its stored login is not proven per driver, so this
+        // says exactly what is wrong and lets the run show it rather than refusing on a half-proven chain.
+        const unmapped = `Assignment ${taskId} intelligence tier ${tier} (risk ${risk}); no model mapping — CLI default`;
+        if (fuel)
+            console.error(`${unmapped}, which Conduit resolves as an organization alias and rejects otherwise.${await offered()}`);
+        else
+            console.log(unmapped);
         return { risk, tier };
     }
     const candidates = Array.isArray(configured) ? configured : [configured];
-    const { model, skipped } = pickModelCandidate(candidates, await availableModels(driver, workspace));
+    const { model, skipped } = pickModelCandidate(candidates, await list());
     const skippedNote = skipped.length ? ` (skipped unavailable/unsafe: ${skipped.join(", ")})` : "";
     if (!model) {
-        console.error(`Assignment ${taskId} intelligence tier ${tier} (risk ${risk}): no configured candidate available — CLI default${skippedNote}`);
+        const none = `Assignment ${taskId} intelligence tier ${tier} (risk ${risk}): no configured candidate available — CLI default${skippedNote}`;
+        console.error(fuel ? `${none}. No candidate is a Conduit model alias.${await offered()}` : none);
         return { risk, tier };
     }
     console.log(`Assignment ${taskId} intelligence tier ${tier} (risk ${risk}) → model ${model}${skippedNote}`);
@@ -548,8 +664,16 @@ export function validateDeliveryReport(report, spec, grants = []) {
     if (!grants.includes("repo_write") && (report.changes.length > 0 || report.evidence.some((item) => item.kind === "change"))) {
         throw new Error("Agent reported repository changes without the repo_write grant");
     }
+    // Merge-on-accept lands GitHub PRs. Local attempt commits without a PR never reach main.
+    if (grants.includes("pr_create")
+        && (spec.change_scope?.length ?? 0) > 0
+        && report.head_commit
+        && !report.pull_request_url) {
+        throw new Error("Repository changes require a pull_request_url when pr_create is granted");
+    }
+    const requiredEvidence = spec.required_evidence ?? [];
     const supplied = new Set(report.evidence.map((item) => item.kind));
-    const missing = (spec.required_evidence ?? []).filter((kind) => !supplied.has(kind));
+    const missing = requiredEvidence.filter((kind) => !supplied.has(kind));
     if (missing.length)
         throw new Error(`Agent report is missing required evidence: ${missing.join(", ")}`);
     const unsupported = report.acceptance_results
@@ -557,7 +681,17 @@ export function validateDeliveryReport(report, spec, grants = []) {
         .map((result) => result.criterion);
     if (unsupported.length)
         throw new Error(`Met acceptance criteria require mapped evidence: ${unsupported.join("; ")}`);
+    // Plan-time normalizeRequiredEvidence puts "test" on verify packages; reject summary-only details.
+    if (requiredEvidence.includes("test")) {
+        const thin = report.evidence
+            .filter((item) => item.kind === "test")
+            .filter((item) => item.details.join("\n").trim().length < TEST_EVIDENCE_DETAILS_MIN);
+        if (thin.length) {
+            throw new Error("test evidence must include verbatim command output in details (not a summary)");
+        }
+    }
 }
+const TEST_EVIDENCE_DETAILS_MIN = 32;
 function referenceKind(kind) {
     if (kind === "change")
         return "commit";

package/package.json

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