@miraland-labs/conduit-bridge 0.16.137 → 0.16.140

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { redactSecrets } from "./secret-redaction.js";
 import { parseArgs } from "node:util";
 import { resolve, dirname, join as pathJoin } from "node:path";
 import { hostname, homedir, platform, userInfo } from "node:os";
@@ -8,7 +9,7 @@ import { chmodSync, cpSync, existsSync, mkdirSync, readdirSync } from "node:fs";
 import { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { assignmentPollBehindServer, ConduitClient, ConduitRequestError } from "./client.js";
-import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearLocalConnection, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, redactSecrets, saveConfig, saveConfigPrefs, saveDriverQuota, savePendingConnection, suggestMachineName, } from "./config.js";
+import { BRIDGE_LEASE_CAPACITY, BRIDGE_MAX_LEASE_CAPACITY, clampLeaseCapacity, clearLocalConnection, clearPendingConnection, loadConfig, loadConfigIfPresent, loadOrCreateInstallationId, loadPendingConnection, saveConfig, saveConfigPrefs, saveDriverQuota, savePendingConnection, suggestMachineName, } from "./config.js";
 import { runMcp } from "./mcp.js";
 import { detectInstalledClients, localFuelOnlyClients, suggestFuelSource } from "./detect.js";
 import { DRIVERS, MODEL_TIERS } from "./driver.js";

package/dist/config.js

@@ -77,8 +77,10 @@ export async function loadConfigIfPresent() {
             // → config — so a new lane field has to be added in both, and forgetting here is silent: the
             // value survives in memory, then vanishes on the next load. `quota` was lost exactly that way.
             const quota = plainQuota(lane.quota);
+            const outcome = plainOutcome(lane.outcome);
             const models = plainTierModels(lane.models, `drivers.${id}.models`);
             cleaned[id] = { state, ...(modelsPolicy ? { models_policy: modelsPolicy } : {}), ...(fuel ? { fuel } : {}), ...(quota ? { quota } : {}),
+                ...(outcome ? { outcome } : {}),
                 ...(models && Object.keys(models).length ? { models } : {}) };
         }
         config.drivers = cleaned;
@@ -136,6 +138,14 @@ function plainQuota(raw) {
     const vendor = typeof raw.vendor === "string" && raw.vendor.trim() ? raw.vendor : undefined;
     return { exhausted: raw.exhausted, resets_at: raw.resets_at, observed_at: raw.observed_at, ...(vendor ? { vendor } : {}) };
 }
+/** The lane's timeout record. Dropped here, the count never passed 1 and a lane that kept timing out was never demoted. */
+function plainOutcome(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    if (!Number.isFinite(raw.consecutive_timeouts) || typeof raw.last_timeout_at !== "string")
+        return undefined;
+    return { consecutive_timeouts: Math.max(0, Math.floor(raw.consecutive_timeouts)), last_timeout_at: raw.last_timeout_at };
+}
 async function loadRuntime() {
     try {
         const raw = JSON.parse(await readFile(runtimePath, "utf8"));
@@ -224,9 +234,10 @@ function mergeCurrentDriverQuota(disk, snapshot) {
         return snapshot;
     const drivers = {};
     for (const [id, lane] of Object.entries(snapshot)) {
-        const { quota: _staleQuota, ...prefs } = lane;
+        const { quota: _staleQuota, outcome: _staleOutcome, ...prefs } = lane;
         const quota = plainQuota(disk.drivers?.[id]?.quota);
-        drivers[id] = { ...prefs, ...(quota ? { quota } : {}) };
+        const outcome = plainOutcome(disk.drivers?.[id]?.outcome);
+        drivers[id] = { ...prefs, ...(quota ? { quota } : {}), ...(outcome ? { outcome } : {}) };
     }
     return drivers;
 }
@@ -409,15 +420,3 @@ export function suggestMachineName(host, installationId) {
     const suffix = installationId.slice(-5).toLowerCase();
     return `${base.slice(0, 199 - suffix.length)}-${suffix}`;
 }
-export function redactSecrets(value) {
-    // Conduit's own key classes, then the provider and forge shapes an agent's own environment
-    // carries (ANTHROPIC_API_KEY, XAI_API_KEY, GEMINI_API_KEY, a GitHub token, a bearer header) —
-    // an agent that prints its environment on failure must not leak them through this terminal.
-    return value
-        .replace(/(runner_sk_|gateway_sk_|lease_|connect_)[A-Za-z0-9-]+/g, "$1[redacted]")
-        .replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-[redacted]")
-        .replace(/xai-[A-Za-z0-9]+/g, "xai-[redacted]")
-        .replace(/AIza[0-9A-Za-z_-]{35}/g, "AIza[redacted]")
-        .replace(/(ghp_|gho_|github_pat_|glpat-)[A-Za-z0-9_-]+/g, "$1[redacted]")
-        .replace(/Bearer\s+\S+/g, "Bearer [redacted]");
-}

package/dist/execution.js

@@ -1,3 +1,5 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { redactSecrets, redactSecretsDeep } from "./secret-redaction.js";
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { z } from "zod";
@@ -5,7 +7,7 @@ import { resolveAgentTimeout } from "./execution-budget.js";
 import { AttemptStalledError, createAttemptWatchdog, withTimeout } from "./attempt-watchdog.js";
 import { workPackageSchema } from "./work-package-schema.js";
 import { ConduitRequestError, reportAssignmentPollShapeMismatch } from "./client.js";
-import { redactSecrets, saveDriverOutcome, saveDriverQuota, tierCandidates } from "./config.js";
+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";
@@ -184,8 +186,22 @@ function timeoutFailureBody(resolution, attemptId) {
 }
 class AgentTurnTimeoutError extends Error {
 }
-/** Environment faults that must Hold — mirror CP ENVIRONMENT_FAILURES message patterns. */
-const FINALIZE_ENVIRONMENT_PATTERN = /base[_ ]not[_ ]ancestor|required base commit is not available|source[_ ]workspace[_ ]dirty|uncommitted changes|dirty workspace|workspace[_ ]head[_ ]changed|workspace[_ ]repository|workspace[_ ]unavailable|driver[_ ]not[_ ]authenticated|not logged in|no login|not authenticated|login required|no[_ ]online[_ ]driver|bridge[_ ]preflight|stale bridge|bridge version/i;
+/**
+ * Computer faults found while finishing a run. Each Holds on its own named cause: without an
+ * envelope the control plane read them as unclassifiable and stopped the task instead (K3/K4).
+ * Order matters: the first match names the cause.
+ */
+const FINALIZE_ENVIRONMENT_CAUSES = [
+    [/base[_ ]not[_ ]ancestor|required base commit is not available/i, "base_not_ancestor"],
+    [/source[_ ]workspace[_ ]dirty|uncommitted changes|dirty workspace/i, "workspace_dirty"],
+    [/workspace[_ ]head[_ ]changed/i, "workspace_head_changed"],
+    [/workspace[_ ]repository/i, "workspace_repository_mismatch"],
+    [/workspace[_ ]unavailable/i, "workspace_unavailable"],
+    [/driver[_ ]not[_ ]authenticated|not logged in|no login|not authenticated|login required/i, "driver_not_authenticated"],
+    [/no[_ ]online[_ ]driver/i, "no_online_driver"],
+    [/bridge[_ ]preflight/i, "bridge_preflight_missing"],
+    [/stale bridge|bridge version/i, "stale_bridge"],
+];
 /** Delivery-report / grant / evidence contract defects (non-retryable rework). */
 /** Two finalize messages with builders of their own in the twin and the cause table. */
 const CONTRACT_SCOPE_CONFLICT_MESSAGE = /Agent reported changes outside the approved scope:/i;
@@ -204,8 +220,9 @@ export function classifyFinalizeFailure(message) {
     // the owner reads the refusal rather than that Conduit could not classify the failure.
     if (message.startsWith(PULL_REQUEST_OPEN_FAILURE_PREFIX))
         return { retryable: false, error: message, failure: bridgeCause("pull_request_open_refused", message) };
-    if (FINALIZE_ENVIRONMENT_PATTERN.test(message))
-        return { retryable: false, error: message };
+    const environment = FINALIZE_ENVIRONMENT_CAUSES.find(([pattern]) => pattern.test(message))?.[1];
+    if (environment)
+        return { retryable: false, error: message, failure: bridgeCause(environment, message) };
     // Bridge names the contract defect it found (K3); an unknown throw below stays prose until its
     // own site names a code.
     if (FINALIZE_CONTRACT_PATTERN.test(message)) {
@@ -471,11 +488,6 @@ export function parseDiagnosticRepairBrief(text) {
     }
     return parsed.data;
 }
-/**
- * The gate command inside the witness line, for the diagnosis prompt. Repair names the gate from
- * the typed signal; this pattern stays until that prompt moves.
- */
-const VERIFICATION_GATE_PATTERN = /Verification failed \(([^)]+)\)/;
 /** Prompt for Option C: IDE-depth understanding in the retained tree, with write authority absent. */
 export function buildDiagnosticPrompt(input) {
     const pkg = input.workPackage;
@@ -488,7 +500,7 @@ export function buildDiagnosticPrompt(input) {
     // Bridge re-runs the gate itself after the next authoring run. Without this rule the diagnosis
     // reads the gate as the agent's own command and briefs the agent to run a different one, which
     // cannot change what Bridge runs: the briefed run then fails on identical output.
-    const gate = VERIFICATION_GATE_PATTERN.exec(input.failureOutput)?.[1]?.trim();
+    const gate = input.gateCommand;
     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.",
@@ -760,7 +772,8 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
             console.error(`Slot recovery failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
         })
             .then(() => undefined)
-            .finally(() => { running.delete(id); });
+            .finally(() => { if (running.get(id) === slot)
+            running.delete(id); });
         running.set(id, slot);
     }
     while (running.size < config.leaseCapacity) {
@@ -795,7 +808,8 @@ export async function pumpExecutionSlots(client, config, workspace, brief, timeo
             console.error(`Slot execution failed: ${redactSecrets(error instanceof Error ? error.message : "unknown")}`);
         })
             .then(() => undefined)
-            .finally(() => { running.delete(taskId); });
+            .finally(() => { if (running.get(taskId) === slot)
+            running.delete(taskId); });
         running.set(taskId, slot);
     }
     return progressed;
@@ -960,6 +974,13 @@ export async function executeNextAssignment(client, config, driver, workspace, b
  * hung: keep it instead of clearing it as an ordinary finished attempt.
  */
 const stalledAttempts = new Set();
+/**
+ * The attempt the current run serves. The maps above are keyed by task, and an abandoned run (after
+ * a stall or a lost lease) keeps running while the task's next attempt starts on this machine — a
+ * repair diagnosis always does. Without this, the old run reported with the new attempt's lease and
+ * removed the new run's handles.
+ */
+const runningAttempt = new AsyncLocalStorage();
 /** T90: the timers and the sleep guard of a running attempt, for a stall report to stop. */
 const attemptDisposers = new Map();
 /** T90: the watchdog of a running attempt, so any terminal path can name the phase it ends in. */
@@ -978,7 +999,7 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
         turnBudgetMs: resolveAgentTimeout({ machineCeilingMs: timeoutMs }).timeoutMs,
     });
     attemptWatchdogs.set(taskId, watchdog);
-    const attempt = runAttempt(client, config, driver, workspace, brief, taskId, watchdog, timeoutMs, supervision, options);
+    const attempt = runningAttempt.run(client.attempt(taskId).attemptId, () => runAttempt(client, config, driver, workspace, brief, taskId, watchdog, timeoutMs, supervision, options));
     try {
         await Promise.race([attempt, watchdog.stalled]);
     }
@@ -1413,6 +1434,7 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
             spec,
             workPackage,
             failureOutput: diagnosticFailure,
+            gateCommand: workPackage.diagnostic_context?.gate_command ?? null,
             verificationCommands: attemptBrief?.verification ?? [],
         })
         : buildAssignmentPrompt({
@@ -2300,9 +2322,12 @@ async function runAttempt(client, config, driver, workspace, brief, taskId, watc
         // that never answered.
         if (stalledAttempts.delete(active.attemptId))
             retainAttemptWorktree = true;
-        attemptDisposers.delete(taskId);
+        // Only this run's own handles: the task's next attempt may already have set its own.
+        if (attemptDisposers.get(taskId) === disposeTimers)
+            attemptDisposers.delete(taskId);
         disposeTimers();
-        slotAborts.delete(taskId);
+        if (slotAborts.get(taskId) === abort)
+            slotAborts.delete(taskId);
         if (retainAttemptWorktree) {
             console.log(`Retained failed-attempt worktree for Conductor diagnosis at ${attemptWorkspace}`);
         }
@@ -3096,11 +3121,19 @@ async function endAttemptForChangedFact(client, workspace, taskId, fact, observe
     }
     console.error(`Assignment ${taskId} ended: ${redactSecrets(detail)}`);
 }
-async function queueTerminal(client, taskId, terminal) {
+async function queueTerminal(client, taskId, reported) {
+    // Every terminal of every path passes here: its prose, envelope, signal tails and delivery packet
+    // carry agent and gate output, so the whole report is redacted once, before it is stored or sent.
+    const terminal = redactSecretsDeep(reported);
+    const active = client.attempt(taskId);
+    const owner = runningAttempt.getStore();
+    if (owner && owner !== active.attemptId) {
+        console.error(`Assignment ${taskId}: a run for attempt ${owner} answered after attempt ${active.attemptId} took the task; its report is dropped.`);
+        return { accepted: false, status: "superseded" };
+    }
     // Every terminal of every path passes here, so this is where the attempt's clock learns that the
     // work is over and only the report is left.
     attemptWatchdogs.get(taskId)?.phase("terminal");
-    const active = client.attempt(taskId);
     let executionFacts = active.executionFacts;
     if (executionFacts && executionFacts.final_commit === null && active.worktreePath) {
         const finalCommit = await headCommitOrNull(active.worktreePath);

package/dist/investigation.js

@@ -5,12 +5,12 @@
  * held to repo_read + test_run by the same driver projection that enforces read-only diagnosis, and
  * the worktree it reads is deleted whichever way the run ends.
  */
+import { redactSecrets } from "./secret-redaction.js";
 import { z } from "zod";
 import { boundedTail, runBoundedVerificationCommand } from "./ensure-test-evidence.js";
 import { createAttemptWorktree, removeAttemptWorktree } from "./attempt-worktree.js";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl } from "./brief.js";
 import { headCommitOrNull } from "./git.js";
-import { redactSecrets } from "./config.js";
 import { learnDriverFuel, resolveAssignmentModel, changedPathsSince, runDeliveryVerificationGates, discardWorktreeWrites } from "./execution.js";
 import { DRIVERS, extractAgentReportJsonText, parseJsonObjectCandidate } from "./driver.js";
 import { pickDriverForClaim, resolveDriverFuel, supportsReadOnlyDiagnosis } from "./drivers.js";
@@ -52,6 +52,8 @@ export const investigationAssignmentSchema = z.object({
     acceptance: z.array(z.string().trim().min(1).max(4_000)).max(20).optional().default([]),
     /** Delivery verification: the brief's `[sN]` / `[kN]` lines. Absent or [] on a plain investigation. */
     brief_keys: z.array(z.string().trim().min(1).max(4_000)).max(40).optional().default([]),
+    /** Delivery verification: the owner's returns on this delivery, which amend the brief. */
+    owner_returns: z.array(z.string().trim().min(1).max(4_000)).max(10).optional().default([]),
 });
 /**
  * Enforcement is a vendor's claim; verification is ours. Both run on every investigation — this only
@@ -145,6 +147,10 @@ export function buildDeliveryVerificationPrompt(assignment, commit, context) {
         : "REGISTERED COMMANDS\n- none: this repository registers no verification command, so judge from the files only";
     const keys = (assignment.brief_keys ?? []).map((key) => key.trim()).filter(Boolean);
     const briefKeysBlock = keys.length ? `BRIEF KEYS\n${keys.join("\n")}` : "";
+    const returns = (assignment.owner_returns ?? []).map((text) => text.trim()).filter(Boolean);
+    const ownerReturnsBlock = returns.length
+        ? `OWNER RETURNS — the product owner's decisions on this delivery, in order. They amend the criteria and the brief: where a return changes a rule, judge and probe the rule as returned, never the original wording.\n${returns.map((text, index) => `${index + 1}. ${text}`).join("\n")}`
+        : "";
     const probeBlock = keys.length ? DELIVERY_VERIFICATION_PROBE_INSTRUCTION : "";
     return [
         "You are Conductor's independent delivery verification. A coding agent delivered this commit against approved acceptance criteria; you check it the way a careful reviewer would, and you never take the agent's word for anything.",
@@ -161,6 +167,7 @@ export function buildDeliveryVerificationPrompt(assignment, commit, context) {
         `PINNED COMMIT ${commit}`,
         commands,
         assignment.question,
+        ...(ownerReturnsBlock ? [ownerReturnsBlock] : []),
         ...(briefKeysBlock ? [briefKeysBlock] : []),
         ...(probeBlock ? [probeBlock] : []),
         `BUDGET\nAt most ${assignment.budget.max_files} files read in full; the change summary and command output are not counted.`,

package/dist/secret-redaction.js

@@ -0,0 +1,35 @@
+/**
+ * The one list of secret shapes, for the Bridge and the control plane.
+ *
+ * The Bridge source is packages/conduit-bridge/src/secret-redaction.ts. The control-plane copy at
+ * src/conductor/secret-redaction.ts is generated by `npm run sync:twins`. Do not edit that copy.
+ * Bridge cannot import from the control plane, and the other way round.
+ *
+ * Three lists used to exist (Bridge terminal, control-plane logs, forge diffs), and each missed
+ * shapes another caught. An agent that prints its environment on failure must not leak a provider,
+ * forge, cloud or Conduit credential through any of them.
+ */
+export function redactSecrets(value) {
+    return value
+        .replace(/-----BEGIN [^-]+-----[\s\S]*?-----END [^-]+-----/g, "[redacted private key]")
+        .replace(/(authorization\s*:\s*bearer\s+)[^\s]+/gi, "$1[redacted]")
+        .replace(/Bearer\s+\S+/g, "Bearer [redacted]")
+        .replace(/((?:api[_-]?key|access[_-]?token|client[_-]?secret|password|secret)\s*[:=]\s*)["']?[^\s"']+/gi, "$1[redacted]")
+        .replace(/(runner_sk_|gateway_sk_|lease_|connect_)[A-Za-z0-9-]+/g, "$1[redacted]")
+        .replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-[redacted]")
+        .replace(/xai-[A-Za-z0-9]+/g, "xai-[redacted]")
+        .replace(/AIza[0-9A-Za-z_-]{35}/g, "AIza[redacted]")
+        .replace(/(gh[pousr]_|github_pat_|glpat-|xox[baprs]-)[A-Za-z0-9_-]+/g, "$1[redacted]")
+        .replace(/AKIA[0-9A-Z]{16}/g, "AKIA[redacted]");
+}
+/** Every string inside a JSON-shaped value, redacted; the shape is kept. */
+export function redactSecretsDeep(value) {
+    if (typeof value === "string")
+        return redactSecrets(value);
+    if (Array.isArray(value))
+        return value.map((item) => redactSecretsDeep(item));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactSecretsDeep(item)]));
+    }
+    return value;
+}

package/dist/work-package-schema.js

@@ -56,6 +56,8 @@ export const workPackageSchema = z.object({
     diagnostic_context: z.object({
         source_attempt_id: z.string().uuid(),
         failure_output: z.string().min(1).max(12_000),
+        /** The gate Bridge re-runs, from the failed attempt's verification signal; null names no gate. */
+        gate_command: z.string().min(1).max(2_000).nullable(),
     }).strict().optional(),
     /** Working/Delivery language for Bridge assignment prose. */
     working_language: z.enum(["en", "zh"]).optional(),

package/package.json

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