@miraland-labs/conduit-bridge 0.16.138 → 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)) {
@@ -755,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) {
@@ -790,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;
@@ -955,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. */
@@ -973,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]);
     }
@@ -2296,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}`);
         }
@@ -3092,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/package.json

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