@miraland-labs/conduit-bridge 0.16.148 → 0.16.150

package/dist/attempt-worktree.js

@@ -2,7 +2,7 @@
  * F-07 slice 1: one Git worktree per attempt. The install-service source checkout is never the
  * agent cwd; retries must not inherit dirty files from a failed run.
  */
-import { access, appendFile, mkdir, readFile, rm } from "node:fs/promises";
+import { access, appendFile, mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { execFile } from "node:child_process";
@@ -118,6 +118,45 @@ export async function removeAttemptWorktree(sourceWorkspace, worktreePath) {
     }
     return true;
 }
+/** A retained worktree the control plane never released is swept after this long. */
+export const STALE_ATTEMPT_WORKTREE_MS = 7 * 24 * 60 * 60_000;
+/**
+ * Removes every retained attempt worktree older than seven days that no attempt of this Bridge is
+ * running in. The control plane releases a retained tree only when its repair settles; a repair
+ * that never settles left the tree on disk for ever (four September trees deleted by hand,
+ * 2026-10-03). A diagnosis runs inside its source attempt's tree, so that tree counts as in use.
+ * Answers the paths it removed.
+ */
+export async function sweepStaleAttemptWorktrees(sourceWorkspace, activeAttempts, now = Date.now()) {
+    const root = join(sourceWorkspace, ".conduit", "attempts");
+    let entries;
+    try {
+        entries = await readdir(root);
+    }
+    catch {
+        return [];
+    }
+    const inUse = new Set();
+    for (const attempt of Object.values(activeAttempts)) {
+        inUse.add(resolve(root, attempt.attemptId));
+        if (attempt.sourceAttemptId)
+            inUse.add(resolve(root, attempt.sourceAttemptId));
+        if (attempt.worktreePath)
+            inUse.add(resolve(attempt.worktreePath));
+    }
+    const removed = [];
+    for (const entry of entries) {
+        const path = join(root, entry);
+        if (inUse.has(resolve(path)))
+            continue;
+        const modified = await stat(path).then((info) => info.isDirectory() ? info.mtimeMs : null, () => null);
+        if (modified === null || now - modified < STALE_ATTEMPT_WORKTREE_MS)
+            continue;
+        if (await removeAttemptWorktree(sourceWorkspace, path))
+            removed.push(path);
+    }
+    return removed;
+}
 /**
  * F-07 safe resume: prove the interrupted attempt still owns this worktree path.
  * Does not check session identity — caller requires config.sessions[taskId] separately.

package/dist/cli.js

@@ -22,7 +22,7 @@ import { buildOnShiftIntentProof, managedWorkspacePath, maybeApplyOnShiftIntent
 import { expandOpsValue, loadOpsEnv, OPS_VERBS, runOps } from "./ops.js";
 import { discardWorktreeWrites, pumpExecutionSlots, renewLeases } from "./execution.js";
 import { applyRunnerToolPath, installRunnerService, uninstallRunnerService } from "./service.js";
-import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, planGateRehearsals, PREFLIGHT_CACHE_TTL_MS, runGateRehearsal, unavailableWorkspacePreflight } from "./preflight.js";
+import { BRIDGE_PROTOCOL_VERSION, cachedBridgePreflight, gateRehearsalLockHeld, planGateRehearsals, PREFLIGHT_CACHE_TTL_MS, runGateRehearsal, unavailableWorkspacePreflight } from "./preflight.js";
 import { refreshSourceWorkspace } from "./workspace-refresh.js";
 import { executeNextInvestigation } from "./investigation.js";
 import { bridgeVersion } from "./version.js";
@@ -666,8 +666,9 @@ async function runner() {
                 await heartbeat(client, config, workspace, currentBrief, preflight, intentProof, bootstrapResult);
             }
             await renewLeases(client, config);
+            // Another runner on this computer rehearsing its gate: claim as usual, rehearse on a later cycle.
             if (workspace && onlineDriverIds(config).length && !gateRehearsalRunning && rehearsalPlan?.due
-                && running.size === 0 && Object.keys(config.activeAttempts).length === 0) {
+                && running.size === 0 && Object.keys(config.activeAttempts).length === 0 && !gateRehearsalLockHeld()) {
                 startGateRehearsal(rehearsalPlan.due.workspace, rehearsalPlan.due.plan);
             }
             // No claim while the gate rehearses: the rehearsal measures the gate alone, never beside an attempt.
@@ -767,6 +768,8 @@ function startGateRehearsal(workspace, plan) {
     gateRehearsalRunning = true;
     console.log(`Rehearsing the gate in ${workspace}: ${plan.commands.join(", ")}`);
     void runGateRehearsal(workspace, plan)
+        .then((rehearsal) => { if (rehearsal === "busy")
+        console.log("Gate rehearsal deferred: another runner on this computer is rehearsing"); })
         .catch((error) => console.error(`Gate rehearsal failed: ${redactSecrets(error instanceof Error ? error.message : "unknown error")}`))
         .finally(async () => {
         if (!await workspaceIsClean(workspace))

package/dist/ensure-test-evidence.js

@@ -232,18 +232,49 @@ const TAIL_HEAD_CHARS = 200;
  *
  * Returns the input unchanged when it already fits, so nothing short is ever decorated.
  */
-export function boundedDetailLines(lines, maxLines) {
+export function boundedDetailLines(lines, maxLines, identifiers = []) {
     if (lines.length <= maxLines)
         return lines;
     const head = Math.min(3, Math.max(0, maxLines - 2));
     const tail = maxLines - head - 1;
-    const dropped = lines.length - head - tail;
+    const middle = lines.slice(head, lines.length - tail);
+    // A criterion such as "its output shows privileged_wallet_holds_the_plan_without_payment as ok"
+    // is proved by one line in the middle of a long suite, and a reviewer must not infer it from the
+    // summary. So the lines that name an identifier the criteria name are kept too, in run order. The
+    // cap keeps a broad identifier that matches every line from storing the whole run.
+    const named = identifiers.length === 0
+        ? []
+        : [...new Set(middle.filter((line) => identifiers.some((id) => line.includes(id))))]
+            .slice(0, NAMED_DETAIL_LINES_MAX)
+            .map((line) => (line.length > 500 ? `${line.slice(0, 500)}…` : line));
+    const dropped = middle.length - named.length;
     return [
         ...lines.slice(0, head),
         `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`,
+        ...named,
         ...lines.slice(lines.length - tail),
     ];
 }
+const NAMED_DETAIL_LINES_MAX = 40;
+/**
+ * The test and symbol names the acceptance criteria name: every backticked string, and every
+ * snake_case, camelCase, dotted or `::` token of at least 8 characters. An ordinary English word has
+ * none of `_`, `::`, `.` or an inner capital, so it never counts.
+ */
+function criterionIdentifiers(acceptance) {
+    const found = new Set();
+    for (const criterion of acceptance) {
+        for (const match of criterion.matchAll(/`([^`]+)`/g)) {
+            if (match[1].trim())
+                found.add(match[1].trim());
+        }
+        for (const [token] of criterion.matchAll(/[A-Za-z_][A-Za-z0-9_]*(?:(?:::|\.)[A-Za-z_][A-Za-z0-9_]*)*/g)) {
+            if (token.length >= 8 && /_|::|\.|[a-z0-9][A-Z]/.test(token))
+                found.add(token);
+        }
+    }
+    return [...found];
+}
 /**
  * Shorten a raw diagnostic message while keeping the end.
  *
@@ -593,11 +624,10 @@ export async function ensureTestEvidence(input) {
         }
         const rawDetails = [
             `$ ${command}`,
-            ...stdoutLines,
-            ...stderrLines,
+            ...outputLines(result),
             `exit ${result.code}`,
         ].map((line) => line.slice(0, 4_000));
-        const details = boundedDetailLines(rawDetails, 100);
+        const details = boundedDetailLines(rawDetails, 100, criterionIdentifiers(acceptance));
         if (details.join("\n").trim().length < TEST_EVIDENCE_DETAILS_MIN) {
             throw new Error(`Agent report: Verification produced insufficient output for test evidence (${command})`);
         }

package/dist/execution.js

@@ -11,7 +11,7 @@ import { saveDriverOutcome, saveDriverQuota, tierCandidates } from "./config.js"
 import { DRIVERS, acceptanceCriteriaLines, acceptanceReportSkeleton, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, isSafeModelName, driverExecutable, requireStampedExecutionClass, tierForRisk } from "./driver.js";
 import { assertClassFloor } from "./execution-class.js";
 import { pickDriverForClaim, recordDriverQuota, resolveDriverFuel, resolveDriverFuelProvenance, supportsReadOnlyDiagnosis, clearDriverOutcome, recordDriverTimeout } from "./drivers.js";
-import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
+import { attemptWorktreePath, createAttemptWorktree, proveResumeWorktree, removeAttemptWorktree, sweepStaleAttemptWorktrees, } from "./attempt-worktree.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, fetchOrigin, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
@@ -856,6 +856,14 @@ export async function claimNextAssignment(client, config, workspace, brief, driv
             console.error(`Diagnostic worktree release failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
         }
     }
+    try {
+        for (const swept of await sweepStaleAttemptWorktrees(workspace, config.activeAttempts)) {
+            console.log(`Released stale diagnostic worktree ${swept}`);
+        }
+    }
+    catch (error) {
+        console.error(`Stale worktree sweep failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
+    }
     const assignment = assignments[0];
     if (!assignment)
         return null;

package/dist/preflight.js

@@ -1,6 +1,8 @@
 import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { link, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { buildWorkspaceBrief, normalizeRepositoryUrl } from "./brief.js";
@@ -352,8 +354,78 @@ export async function planGateRehearsals(checkouts, options = {}) {
     }
     return { reports, due };
 }
-/** Run the planned gate once and remember it for the day. Null when no command could start. */
+/**
+ * One gate rehearsal at a time on a computer. The VPS runs two runner services (conduit-runner and
+ * forge-runner); on 2026-10-03 both rehearsed together, each gate slowed the other, and the times
+ * recorded were wrong. Each installation has its own config directory, so the lock lives in the
+ * user's cache directory, which every runner of that user shares. The lock names its holder's
+ * process; a lock whose process is gone is taken over.
+ */
+export function gateRehearsalLockPath() {
+    return join(homedir(), ".cache", "conduit", "gate-rehearsal.lock");
+}
+/** A live process holds the gate rehearsal lock. */
+export function gateRehearsalLockHeld(lockPath = gateRehearsalLockPath()) {
+    let pid;
+    try {
+        pid = Number.parseInt(readFileSync(lockPath, "utf8"), 10);
+    }
+    catch {
+        return false;
+    }
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/** Take the lock, or answer false when a live process holds it. */
+async function acquireGateRehearsalLock(lockPath) {
+    await mkdir(dirname(lockPath), { recursive: true });
+    // Linked into place whole, so the lock never exists without its holder's pid in it.
+    const claim = `${lockPath}.${randomUUID()}`;
+    await writeFile(claim, `${process.pid}\n`);
+    try {
+        for (let tries = 0; tries < 2; tries += 1) {
+            try {
+                await link(claim, lockPath);
+                return true;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+            }
+            if (gateRehearsalLockHeld(lockPath))
+                return false;
+            await unlink(lockPath).catch(() => undefined);
+        }
+        return false;
+    }
+    finally {
+        await unlink(claim).catch(() => undefined);
+    }
+}
+/**
+ * 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.
+ */
 export async function runGateRehearsal(workspace, plan, options = {}) {
+    const lockPath = options.lockPath ?? gateRehearsalLockPath();
+    if (!await acquireGateRehearsalLock(lockPath))
+        return "busy";
+    try {
+        return await rehearseGate(workspace, plan, options);
+    }
+    finally {
+        await unlink(lockPath).catch(() => undefined);
+    }
+}
+async function rehearseGate(workspace, plan, options) {
     const now = options.now ?? Date.now;
     const run = options.runCommand ?? runBoundedVerificationCommand;
     const commands = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.16.148",
+  "version": "0.16.150",
   "description": "Conduit Bridge CLI \u2014 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": {