@miraland-labs/conduit-bridge 0.16.188 → 0.16.190

package/dist/cli.js

@@ -20,7 +20,7 @@ import { BOOTSTRAP_RESULTS, buildSovereignExecutionFacts, workspaceIsClean } fro
 import { ensureCheckout } from "./checkout.js";
 import { buildOnShiftIntentProof, managedWorkspacePath, maybeApplyOnShiftIntent } from "./on-shift-apply.js";
 import { expandOpsValue, loadOpsEnv, OPS_VERBS, runOps } from "./ops.js";
-import { pumpExecutionSlots, renewLeases } from "./execution.js";
+import { assignmentsPending, pumpExecutionSlots, renewLeases } from "./execution.js";
 import { createRehearsalWorktree, rehearsalWorktreePath, removeAttemptWorktree } from "./attempt-worktree.js";
 import { applyRunnerToolPath, installRunnerService, uninstallRunnerService } from "./service.js";
 import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, gateRehearsalLockHeld, planGateRehearsals, PREFLIGHT_CACHE_TTL_MS, runGateRehearsal, unavailableWorkspacePreflight } from "./preflight.js";
@@ -667,9 +667,17 @@ async function runner() {
                 await heartbeat(client, config, workspace, currentBrief, preflight, intentProof, bootstrapResult);
             }
             await renewLeases(client, config);
+            // Dispatched work outranks a rehearsal already running. Stop it with nothing recorded, release
+            // the lock, and claim on this same cycle. The rehearsal stays due.
+            if (gateRehearsalRunning && await assignmentsPending(client)) {
+                gateRehearsalAbort?.abort();
+                await gateRehearsalDone;
+            }
             // Another runner on this computer rehearsing its gate: claim as usual, rehearse on a later cycle.
+            // An assignment already waiting is claimed below; this cycle does not start a rehearsal.
             if (workspace && onlineDriverIds(config).length && !gateRehearsalRunning && rehearsalPlan?.due
-                && running.size === 0 && Object.keys(config.activeAttempts).length === 0 && !gateRehearsalLockHeld()) {
+                && running.size === 0 && Object.keys(config.activeAttempts).length === 0 && !gateRehearsalLockHeld()
+                && !await assignmentsPending(client)) {
                 startGateRehearsal(rehearsalPlan.due.workspace, rehearsalPlan.due.plan);
             }
             // No claim while the gate rehearses: the rehearsal measures the gate alone, never beside an attempt.
@@ -729,8 +737,10 @@ async function runner() {
         await new Promise((resolveSleep) => setTimeout(resolveSleep, intervalMs));
     }
 }
-/** True while the gate rehearsal runs in the background; the loop keeps beating but claims nothing. */
+/** True while the gate rehearsal runs in the background. A dispatched assignment aborts it, then this cycle claims. */
 let gateRehearsalRunning = false;
+let gateRehearsalAbort = null;
+let gateRehearsalDone = Promise.resolve();
 /** An observation fingerprints the source checkout; a fast-forward under it reads as the observer writing. */
 let investigationRunning = false;
 /** The rehearsals the heartbeat reports, one per on-shift repository; empty reports no field. */
@@ -777,21 +787,30 @@ async function rehearsalCheckouts(workspace, brief, refresh) {
  */
 function startGateRehearsal(workspace, plan) {
     gateRehearsalRunning = true;
+    const abort = new AbortController();
+    gateRehearsalAbort = abort;
     const rehearsalPath = rehearsalWorktreePath(workspace);
     console.log(`Rehearsing the gate in ${workspace}: ${plan.commands.join(", ")}`);
-    void createRehearsalWorktree(workspace, plan.commit)
+    gateRehearsalDone = createRehearsalWorktree(workspace, plan.commit)
         .then((path) => runGateRehearsal(path, plan, {
+        signal: abort.signal,
         freshWorkspace: (warmUpSeconds) => {
             console.log(`Gate warm-up took ${warmUpSeconds} s; measuring again in a fresh worktree`);
             return createRehearsalWorktree(workspace, plan.commit);
         },
     }))
-        .then((rehearsal) => { if (rehearsal === "busy")
-        console.log("Gate rehearsal deferred: another runner on this computer is rehearsing"); })
+        .then((rehearsal) => {
+        if (rehearsal === "busy")
+            console.log("Gate rehearsal deferred: another runner on this computer is rehearsing");
+        else if (abort.signal.aborted)
+            console.log("Gate rehearsal stopped: an assignment is waiting");
+    })
         .catch((error) => console.error(`Gate rehearsal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown error")}`))
         .finally(async () => {
         await removeAttemptWorktree(workspace, rehearsalPath);
         gateRehearsalRunning = false;
+        if (gateRehearsalAbort === abort)
+            gateRehearsalAbort = null;
     });
 }
 /** Last state announced, so a workspace that stays diverged does not print on every cycle. */

package/dist/execution.js

@@ -35,7 +35,7 @@ import { boundedTail, captureVerificationFailure, DeliveryReportDefectError, det
 import { ensureChangeEvidence } from "./ensure-change-evidence.js";
 import { ensureDemonstrationEvidence } from "./ensure-demonstration-evidence.js";
 import { ensureNormativeEvidence } from "./ensure-normative-evidence.js";
-import { changedPathsSince, compareWorktreeState, diffStatSince, worktreeStateFingerprint, worktreeWrittenPaths } from "./git-witness.js";
+import { changedPathsSince, compareWorktreeState, diffStatSince, mergeBaseWithDefaultBranch, trackedDefaultBranchRef, worktreeStateFingerprint, worktreeWrittenPaths } from "./git-witness.js";
 import { assertNormativeRefsMaterialized, checkNormativeMarkers, materializeNormativeRefs, NORMATIVE_MARKER_PREFIX, NORMATIVE_REF_PREFIX, parseNormativeRefs, } from "./normative-refs.js";
 import { checkIntegrationObligations, INTEGRATION_OBLIGATION_PREFIX, parseIntegrationObligations, } from "./integration-obligations.js";
 /** Keep a Mac awake only while an assignment is active; display sleep remains allowed. */
@@ -431,8 +431,9 @@ 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),
-    // For a rework, the control plane carries the first revision's resolved attempt start. Older
-    // contracts omit it and use the T136 worktree-start fallback below.
+    // The control plane may carry the first revision's resolved attempt start. Rework and resume
+    // measure from the default-branch fork point; this field is the fallback when that fork
+    // point cannot be computed.
     delivery_base_commit: z.string().nullable().optional().default(null),
     source_attempt_id: z.string().uuid().nullable().optional().default(null),
     // The change request and head commit the returned delivery left behind. A rework that keeps the
@@ -832,6 +833,21 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
     }
     return progressed;
 }
+/**
+ * True when `/runner/v1/assignments` lists work for this machine. A failed poll is not waiting
+ * work: the caller keeps the current cycle. The claim path still parses and claims.
+ */
+export async function assignmentsPending(client) {
+    try {
+        const data = await client.request("/runner/v1/assignments");
+        if (!data || typeof data !== "object" || !("assignments" in data))
+            return false;
+        return Array.isArray(data.assignments) && data.assignments.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 /** Claim one assignment when under capacity; does not start the agent (multi-slot pump does). */
 export async function claimNextAssignment(client, config, workspace, brief, driverId, processOnlineIds, options = {}) {
     if (Object.keys(config.activeAttempts).length >= config.leaseCapacity)
@@ -1216,21 +1232,30 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             await removeAttemptWorktree(workspace, attemptWorkspace).catch(() => undefined);
         }
     };
-    // T136: a first revision's witness starts at the commit the attempt worktree actually checked
-    // out. When main has moved past the requested base, that resolved start is the claimed head;
-    // diffing from the requested base would report commits that predate the agent as its work.
-    // T138: a rework carries the first revision's resolved start, because its worktree starts at the
-    // previous delivery's head. That lets a prose-only rework witness the original pack while still
-    // including any new rework changes. A conflict rework is different: it is pinned to the live base
-    // tip and starts fresh there, so the control plane sends no carried base and the requested base --
-    // the pinned tip -- is the delivery base. Diffing from the first revision's start would report
-    // every commit the base gained in between as the agent's own work. Older contracts fall back to
-    // the T136 rule.
-    const rework = task.delivery_state === "changes_requested" || Boolean(executionContract.prior_head_commit);
-    const deliveryBaseCommit = executionContract.delivery_base_commit
-        ?? (rework
-            ? (executionContract.requested_base_commit ?? spec.repository?.base_commit ?? worktreeStart)
-            : worktreeStart);
+    // T136: a fresh attempt witnesses from the commit the worktree checked out. When main has
+    // moved past the requested base, that resolved start is the claimed head; diffing from the
+    // requested base would report commits that predate the agent as its work.
+    // A rework or a resumed delivery measures from the merge-base of HEAD with origin/<branch>,
+    // where <branch> is the branch the source checkout has checked out — the branch ensureCheckout
+    // tracks. fetch updates that ref. fetch does not update origin/HEAD. Contract
+    // delivery_base_commit and requested_base_commit apply only when that merge-base cannot be
+    // computed. A contract base from the first attempt's start counts later default-branch commits
+    // as the agent's writes (2026-10-23, task eff1253c). Diagnosis uses the same rule.
+    const reworkOrResume = isReworkOrResumeDelivery({
+        deliveryState: task.delivery_state,
+        priorHeadCommit: executionContract.prior_head_commit,
+        resumeFromAttemptId: executionContract.resume_from_attempt_id,
+    });
+    const deliveryBaseCommit = await resolveDeliveryBaseCommit({
+        worktree: attemptWorkspace,
+        sourceWorkspace: workspace,
+        reworkOrResume,
+        worktreeStart,
+        taskId,
+        deliveryBaseCommit: executionContract.delivery_base_commit,
+        requestedBaseCommit: executionContract.requested_base_commit,
+        repositoryBaseCommit: spec.repository?.base_commit,
+    });
     // Only when the worktree really stands at the timed-out run's head: a computer that cannot reach
     // that commit starts at the base (resolveAttemptStartCommit), and the agent must not be told the
     // work is there.
@@ -2993,6 +3018,37 @@ function referenceKind(kind) {
  * Implemented in git-witness.ts; re-exported for control-plane test pins and investigation.
  */
 export { changedPathsSince } from "./git-witness.js";
+/**
+ * A rework or a resumed delivery, from the signals the attempt contract carries.
+ *
+ * Diagnosis is not a separate case: the same three signals select the base.
+ */
+export function isReworkOrResumeDelivery(input) {
+    return input.deliveryState === "changes_requested"
+        || Boolean(input.priorHeadCommit)
+        || Boolean(input.resumeFromAttemptId);
+}
+/**
+ * Commit that changedPathsSince, diffStatSince, and the land checks measure from.
+ *
+ * A fresh attempt keeps the worktree start. A rework or a resumed delivery uses the merge-base
+ * of HEAD with `origin/<branch>` on the source checkout. Contract bases apply only when that
+ * merge-base cannot be computed. One log line names the base this attempt used.
+ */
+export async function resolveDeliveryBaseCommit(input) {
+    const ref = input.reworkOrResume ? await trackedDefaultBranchRef(input.sourceWorkspace) : null;
+    const fork = ref ? await mergeBaseWithDefaultBranch(input.worktree, ref) : null;
+    const base = !input.reworkOrResume
+        ? input.worktreeStart
+        : fork
+            ?? input.deliveryBaseCommit
+            ?? input.requestedBaseCommit
+            ?? input.repositoryBaseCommit
+            ?? input.worktreeStart;
+    const via = fork && ref ? ` (merge-base with ${ref})` : "";
+    console.log(`Assignment ${input.taskId} delivery base ${base}${via}`);
+    return base;
+}
 /**
  * Does this attempt earn a verification dry run?
  *

package/dist/git-witness.js

@@ -21,6 +21,44 @@ async function gitFields(worktree, args) {
         return null;
     }
 }
+/**
+ * Fork point of HEAD with the fetched default-branch ref.
+ *
+ * Null when the ref is missing or the two histories do not meet. Callers then use the
+ * contract base. A merge of that ref into the attempt branch moves this commit forward,
+ * so the diff still names only the branch's own files.
+ */
+export async function mergeBaseWithDefaultBranch(worktree, defaultBranchRef) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", worktree, "merge-base", "HEAD", defaultBranchRef], { timeout: 30_000, maxBuffer: 1_000_000 });
+        const sha = stdout.trim().toLowerCase();
+        return /^[0-9a-f]{7,64}$/.test(sha) ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * `origin/<branch>` for the branch this checkout has checked out.
+ *
+ * `ensureCheckout` leaves that branch checked out. `fetchOrigin` and `refreshSourceWorkspace`
+ * update `origin/<branch>`. They do not update `origin/HEAD`, so this function never reads it.
+ * Null when HEAD is detached or `origin/<branch>` is absent; callers then use the contract base.
+ */
+export async function trackedDefaultBranchRef(workspace) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-parse", "--abbrev-ref", "HEAD"], { timeout: 30_000, maxBuffer: 1_000_000 });
+        const branch = stdout.trim();
+        if (!branch || branch === "HEAD")
+            return null;
+        const ref = `origin/${branch}`;
+        await execFileAsync("git", ["-C", workspace, "rev-parse", "--verify", "--quiet", `${ref}^{commit}`], { timeout: 30_000, maxBuffer: 1_000_000 });
+        return ref;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Paths changed on the attempt branch since `startCommit`, including uncommitted work.
  * Null when git cannot answer — callers must not treat null as failure.

package/dist/preflight.js

@@ -10,7 +10,7 @@ import { bridgeConfigDirectory } from "./config.js";
 import { runBoundedVerificationCommand, VERIFICATION_TIMEOUT_MS, verificationEvidenceCommands } from "./ensure-test-evidence.js";
 import { lockfileDigest } from "./execution-facts.js";
 import { resolveAgentTimeout, resolveMaxTurns } from "./execution-budget.js";
-import { hasAntigravityLogin, hasClaudeLogin, hasGrokLogin, hasOpenAiLogin, hasOpenCodeLogin, driverExecutable, readSignInStatus, } from "./driver.js";
+import { hasAntigravityLogin, hasClaudeLogin, hasGrokLogin, hasOpenAiLogin, hasOpenCodeLogin, driverExecutable, readSignInStatus, stopTrackedProcessGroups, } from "./driver.js";
 import { laneQuota, laneTierBindings, localFuelOnlyDriver, onlineDriverIds, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
 /** Protocol 3: read-only diagnosis can reuse a retained failed-attempt worktree. */
 // 4: each driver snapshot reports diagnosis_read_only, so the control plane can require a
@@ -421,23 +421,70 @@ async function acquireGateRehearsalLock(lockPath) {
         await unlink(claim).catch(() => undefined);
     }
 }
+/** Resolve when `work` settles, or with "aborted" when `signal` aborts first. */
+function untilAbort(work, signal) {
+    if (!signal)
+        return work;
+    if (signal.aborted)
+        return Promise.resolve("aborted");
+    return new Promise((resolve, reject) => {
+        const onAbort = () => resolve("aborted");
+        signal.addEventListener("abort", onAbort, { once: true });
+        work.then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(signal.aborted ? "aborted" : value);
+        }, (error) => {
+            signal.removeEventListener("abort", onAbort);
+            if (signal.aborted)
+                resolve("aborted");
+            else
+                reject(error);
+        });
+    });
+}
+/** Call `stop` if `signal` aborts after this returns. An already-aborted signal has no command yet. */
+function stopWhenAborted(signal, stop) {
+    if (!signal || signal.aborted)
+        return () => undefined;
+    signal.addEventListener("abort", stop, { once: true });
+    return () => signal.removeEventListener("abort", stop);
+}
+async function runRehearsalCommand(run, command, cwd, timeoutMs, signal) {
+    if (signal?.aborted)
+        return "aborted";
+    const work = (signal ? run(command, cwd, timeoutMs, signal) : run(command, cwd, timeoutMs)).catch(() => null);
+    const result = await untilAbort(work, signal);
+    if (result === "aborted" || signal?.aborted)
+        return "aborted";
+    return result;
+}
 /**
- * Run the planned gate once and remember it for the day. Null when no command could start.
- * "busy" when another rehearsal on this computer holds the lock: nothing is run or remembered, so
- * the gate is still due and the next cycle tries again.
+ * Run the planned gate once and remember it for the day. Null when no command could start, or when
+ * `signal` aborts: the command is stopped, nothing is remembered, and the lock is released, so the
+ * gate stays due. "busy" when another rehearsal on this computer holds the lock: nothing is run or
+ * remembered, so the gate is still due and the next cycle tries again.
  */
 export async function runGateRehearsal(workspace, plan, options = {}) {
+    if (options.signal?.aborted)
+        return null;
     const lockPath = options.lockPath ?? gateRehearsalLockPath();
     if (!await acquireGateRehearsalLock(lockPath))
         return "busy";
+    const releaseAbort = stopWhenAborted(options.signal, stopTrackedProcessGroups);
     try {
+        if (options.signal?.aborted)
+            return null;
         return await rehearseGate(workspace, plan, options);
     }
     finally {
+        releaseAbort();
         await unlink(lockPath).catch(() => undefined);
     }
 }
 async function rehearseGate(workspace, plan, options) {
+    const signal = options.signal;
+    if (signal?.aborted)
+        return null;
     const now = options.now ?? Date.now;
     const run = options.runCommand ?? runBoundedVerificationCommand;
     const commands = [];
@@ -445,7 +492,10 @@ async function rehearseGate(workspace, plan, options) {
     for (const command of plan.commands) {
         const started = now();
         // A command that cannot start measured nothing; the dry run skips it the same way.
-        const result = await run(command, cwd, REHEARSAL_TIMEOUT_MS).catch(() => null);
+        // An abort measures nothing either: the gate stays due for the next quiet cycle.
+        const result = await runRehearsalCommand(run, command, cwd, REHEARSAL_TIMEOUT_MS, signal);
+        if (result === "aborted")
+            return null;
         if (!result)
             continue;
         const elapsed = now() - started;
@@ -456,10 +506,16 @@ async function rehearseGate(workspace, plan, options) {
         }
         // The pass fit only the rehearsal's limit: it was a warm-up. Measure once more, in a fresh
         // checkout with the attempt's limit, so the report shows what an attempt will see.
-        if (options.freshWorkspace)
-            cwd = await options.freshWorkspace(seconds);
+        if (options.freshWorkspace) {
+            const fresh = await untilAbort(options.freshWorkspace(seconds), signal);
+            if (fresh === "aborted")
+                return null;
+            cwd = fresh;
+        }
         const again = now();
-        const second = await run(command, cwd, VERIFICATION_TIMEOUT_MS).catch(() => null);
+        const second = await runRehearsalCommand(run, command, cwd, VERIFICATION_TIMEOUT_MS, signal);
+        if (second === "aborted")
+            return null;
         if (!second) {
             commands.push({ command, seconds, exit_code: result.code, timed_out: false });
             continue;
@@ -472,6 +528,8 @@ async function rehearseGate(workspace, plan, options) {
             warm_up_seconds: seconds,
         });
     }
+    if (signal?.aborted)
+        return null;
     const at = now();
     const rehearsal = commands.length
         ? { repository: plan.repository, commit: plan.commit, rehearsed_at: new Date(at).toISOString(), commands }

package/package.json

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