@miraland-labs/conduit-bridge 0.16.40 → 0.16.42

package/dist/driver.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { boundedTail } from "./ensure-test-evidence.js";
 import { resolveAgentTimeout } from "./execution-budget.js";
+import { unknownAgentSignal, vendorKindForAntigravity } from "./failure-signal.js";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, rm, rmdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
@@ -27,7 +28,7 @@ function deliveryLanguageRule(language) {
     return null;
 }
 export const evidenceKinds = ["change", "test", "preview", "research", "documentation"];
-export const agentReportTemplate = '{"outcome": "one-paragraph summary", "changes": ["path from the repository root — what changed"], "verification": ["command — result"], "acceptance_results": [{"criterion": "exact criterion text", "status": "met|not_met|unknown", "unverified_reason": "omit unless status is unknown", "unverified_detail": "one sentence naming what was missing; omit unless status is unknown"}], "evidence": [{"kind": "change|test|preview|research|documentation", "name": "concise evidence name", "uri": "external URL if one exists", "digest": "optional digest", "details": ["observable result"], "acceptance_criteria": ["exact criterion text supported by this evidence"]}], "assumptions": [], "risks": [], "limitations": [], "head_commit": "full sha of your final commit, omit if none"}';
+export const agentReportTemplate = '{"outcome": "one-paragraph summary", "changes": ["path from the repository root — what changed"], "verification": ["command — result"], "acceptance_results": [{"criterion": "criterion key, for example c1", "status": "met|not_met|unknown", "unverified_reason": "omit unless status is unknown", "unverified_detail": "one sentence naming what was missing; omit unless status is unknown"}], "evidence": [{"kind": "change|test|preview|research|documentation", "name": "concise evidence name", "uri": "external URL if one exists", "digest": "optional digest", "details": ["observable result"], "acceptance_criteria": ["criterion keys this evidence supports, for example c1"]}], "assumptions": [], "risks": [], "limitations": [], "head_commit": "full sha of your final commit, omit if none"}';
 /**
  * Resolve an operator's ordered tier candidates against the live model list.
  * Picks the first safe candidate the CLI currently offers; without a live list
@@ -96,8 +97,12 @@ export function buildAssignmentPrompt(context) {
         lines.push("", `SCOPE\n${scope.map((item) => `- ${item}`).join("\n")}`);
     if (boundaries?.length)
         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 (acceptance?.length) {
+        // Each criterion carries a key. The agent reports the key, not the prose: criteria are long
+        // sentences with backticks and quotes, and a retyped sentence made the delivery invalid at
+        // "Preparing delivery" although the work was done.
+        lines.push("", "ACCEPTANCE CRITERIA — the delivery is judged against these. The key in brackets identifies each one.", ...acceptanceCriteriaLines(acceptance), "", "Name each criterion by its key — \"c1\", not the sentence — in acceptance_results[].criterion and in evidence[].acceptance_criteria. You do not need to retype the criterion text; a retyped sentence that differs makes the whole delivery invalid.", "Start from this report skeleton and change only the statuses, the reasons, and the evidence you map to each key:", acceptanceReportSkeleton(acceptance));
+    }
     if (evidence?.length && !spec.instruction) {
         lines.push("", "REQUIRED EVIDENCE");
         for (const kind of evidence) {
@@ -299,6 +304,53 @@ export function criterionKey(value) {
         .replace(/[.\u3002]+$/, "")
         .toLowerCase();
 }
+/**
+ * The key of one acceptance criterion: `c1` for the first approved criterion, `c2` for the second.
+ *
+ * The key is derived from the approved order at prompt time and at parse time. It is not stored:
+ * the approved criteria list of the execution epoch is the only source of the order, so a key
+ * cannot disagree with the contract it names.
+ */
+export function criterionKeyLabel(index) {
+    return `c${index + 1}`;
+}
+/** A criterion reference that is a key: `c1`, `C1`, `[c1]`, or the same with spaces around it. */
+const CRITERION_KEY_REFERENCE = /^\[?\s*c(\d{1,3})\s*\]?$/i;
+/**
+ * Resolve one criterion reference from the agent report to the approved criterion text.
+ *
+ * The reference is the exact text (with the `criterionKey` normalization) or the key. The text is
+ * tried first, so a criterion whose own text is "c1" keeps its identity. The result is null when
+ * the reference names no approved criterion.
+ */
+export function resolveCriterionReference(value, acceptance) {
+    const key = criterionKey(value);
+    const byText = acceptance.find((criterion) => criterionKey(criterion) === key);
+    if (byText !== undefined)
+        return byText;
+    const match = CRITERION_KEY_REFERENCE.exec(value.trim());
+    if (!match)
+        return null;
+    return acceptance[Number(match[1]) - 1] ?? null;
+}
+/** True when the reference has the shape of a key. Used to tell an unknown key from free prose. */
+function isCriterionKeyReference(value) {
+    return CRITERION_KEY_REFERENCE.test(value.trim());
+}
+/** Render the approved criteria as `[c1] <text>` lines for a prompt. */
+export function acceptanceCriteriaLines(acceptance) {
+    return acceptance.map((criterion, index) => `- [${criterionKeyLabel(index)}] ${criterion}`);
+}
+/**
+ * The pre-filled acceptance_results skeleton for the prompt: one entry per key, status unknown.
+ * The agent changes the statuses and adds the evidence instead of composing the list, because
+ * composing it means retyping long criterion prose, and a retyped sentence made the delivery
+ * invalid at "Preparing delivery" on most first deliveries.
+ */
+export function acceptanceReportSkeleton(acceptance) {
+    const entries = acceptance.map((_, index) => ({ criterion: criterionKeyLabel(index), status: "unknown" }));
+    return JSON.stringify({ acceptance_results: entries });
+}
 /** Bound one criterion for an error message. A criterion holds up to 4 000 characters. */
 function quoteCriterion(value) {
     const text = value.trim().replace(/\s+/g, " ");
@@ -335,13 +387,34 @@ export function parseAgentReport(text, acceptance) {
         const at = issue?.path?.length ? ` at ${issue.path.join(".")}` : "";
         throw new Error(`Agent report is invalid${at}: ${issue?.message ?? "unknown validation error"}`);
     }
-    const reportedKeys = parsed.data.acceptance_results.map((item) => criterionKey(item.criterion));
+    // Map every criterion reference — in the results and in the evidence — back to the approved text
+    // before anything else reads it. Downstream (the packet, the reviewer, Today) sees text only; the
+    // key is transport. An unknown key is refused here, because a key the agent invented cannot be
+    // mapped and silently leaves a criterion unwitnessed.
+    const unknownKeys = [];
+    const toApprovedText = (value) => {
+        const text = resolveCriterionReference(value, acceptance);
+        if (text !== null)
+            return text;
+        if (isCriterionKeyReference(value))
+            unknownKeys.push(value.trim());
+        return value;
+    };
+    const acceptanceResults = parsed.data.acceptance_results.map((item) => ({ ...item, criterion: toApprovedText(item.criterion) }));
+    const evidence = parsed.data.evidence.map((item) => ({ ...item, acceptance_criteria: item.acceptance_criteria.map(toApprovedText) }));
+    if (unknownKeys.length) {
+        const valid = acceptance.length
+            ? acceptance.map((criterion, index) => `${criterionKeyLabel(index)} = ${quoteCriterion(criterion)}`).join("; ")
+            : "none — this package has no acceptance criteria";
+        throw new Error(`Agent report names a criterion key that does not exist (${[...new Set(unknownKeys)].join(", ")}). The valid keys are: ${valid}`);
+    }
+    const reportedKeys = acceptanceResults.map((item) => criterionKey(item.criterion));
     const approvedKeys = new Set(acceptance.map(criterionKey));
-    const duplicated = parsed.data.acceptance_results
+    const duplicated = acceptanceResults
         .filter((item, index) => reportedKeys.indexOf(criterionKey(item.criterion)) !== index)
         .map((item) => item.criterion);
     const missing = acceptance.filter((criterion) => !reportedKeys.includes(criterionKey(criterion)));
-    const unapproved = parsed.data.acceptance_results
+    const unapproved = acceptanceResults
         .filter((item) => !approvedKeys.has(criterionKey(item.criterion)))
         .map((item) => item.criterion);
     if (missing.length || duplicated.length || unapproved.length) {
@@ -357,10 +430,11 @@ export function parseAgentReport(text, acceptance) {
     // Missing evidence mappings cannot support a "met" claim. Preserve the evidence itself, but
     // downgrade only the unsupported result to unknown so the existing quality loop can assess the
     // completed work instead of throwing the whole implementation away.
-    const mappedCriteria = new Set(parsed.data.evidence.flatMap((item) => item.acceptance_criteria.map(criterionKey)));
+    const mappedCriteria = new Set(evidence.flatMap((item) => item.acceptance_criteria.map(criterionKey)));
     return {
         ...parsed.data,
-        acceptance_results: parsed.data.acceptance_results.map((item) => {
+        evidence,
+        acceptance_results: acceptanceResults.map((item) => {
             const { unverified_reason: reported, unverified_detail: detail, ...rest } = item;
             const status = item.status === "met" && !mappedCriteria.has(criterionKey(item.criterion))
                 ? "unknown"
@@ -524,7 +598,7 @@ export const claudeCodeDriver = {
         }
         const sessionId = message?.session_id ?? null;
         if (code !== 0 || !message || message.is_error) {
-            return { status: "failed", resultText: message?.result ?? null, sessionId, error: boundedTail(message?.result || stderr || `agent exited with code ${code}`, 20_000) };
+            return { status: "failed", resultText: message?.result ?? null, sessionId, signal: unknownAgentSignal({ exit_code: code, stderr, stdout }), error: boundedTail(message?.result || stderr || `agent exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: message.result ?? "", sessionId };
     },
@@ -625,7 +699,7 @@ export const codexDriver = {
         const parsed = parseCodexJsonl(stdout);
         const resultText = parsed.resultText ?? (stdout || null);
         if (code !== 0) {
-            return { status: "failed", resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || stdout || `codex exited with code ${code}`, 20_000) };
+            return { status: "failed", resultText, sessionId: parsed.sessionId, signal: unknownAgentSignal({ exit_code: code, stderr, stdout }), error: boundedTail(stderr || stdout || `codex exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText, sessionId: parsed.sessionId };
     },
@@ -757,7 +831,7 @@ export const cursorDriver = {
         const { code, stdout, stderr } = configured;
         const parsed = parseCursorOutput(stdout);
         if (code !== 0 || parsed.isError) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || parsed.resultText || `cursor agent exited with code ${code}`, 20_000) };
+            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, signal: unknownAgentSignal({ exit_code: code, stderr, stdout }), error: boundedTail(stderr || parsed.resultText || `cursor agent exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },
@@ -924,7 +998,7 @@ export const openCodeDriver = {
         const { code, stdout, stderr } = await withOpenCodePermissions(input.workspace, () => execute(input.executable ?? "opencode", args, input.workspace, agentTurnTimeoutMs(input), fuelSource === "conduit" ? input.fuel : undefined, fuelSource));
         const parsed = parseOpenCodeOutput(stdout);
         if (code !== 0 || parsed.isError) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || parsed.resultText || `opencode exited with code ${code}`, 20_000) };
+            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, signal: unknownAgentSignal({ exit_code: code, stderr, stdout }), error: boundedTail(stderr || parsed.resultText || `opencode exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },
@@ -989,7 +1063,7 @@ export const kiroDriver = {
         args.push(input.prompt);
         const { code, stdout, stderr } = await execute(executable, args, input.workspace, agentTurnTimeoutMs(input), undefined, "local");
         if (code !== 0) {
-            return { status: "failed", resultText: stdout || null, sessionId: null, error: boundedTail(stderr || stdout || `kiro-cli exited with code ${code}`, 20_000) };
+            return { status: "failed", resultText: stdout || null, sessionId: null, signal: unknownAgentSignal({ exit_code: code, stderr, stdout }), error: boundedTail(stderr || stdout || `kiro-cli exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: stdout, sessionId: null };
     },
@@ -1218,6 +1292,24 @@ async function withAntigravityPermissions(workspace, allow, run) {
         release();
     }
 }
+/**
+ * The typed signal for a refused agy run: the envelope's own status and reason become the witness,
+ * and the vendor's vocabulary names the kind — so the control plane can hold a spent allowance
+ * without any generic prose table knowing agy at all.
+ */
+function agySignal(code, status, message, stderr, stdout) {
+    const kind = vendorKindForAntigravity(status, message);
+    if (kind === "unknown")
+        return unknownAgentSignal({ exit_code: code, stderr, stdout });
+    return {
+        phase: "agent",
+        witness: "vendor",
+        kind,
+        exit_code: code,
+        ...(status ? { vendor_status: status.slice(0, 200) } : {}),
+        ...(message ? { vendor_message: boundedTail(message, 2_000) } : {}),
+    };
+}
 export const antigravityDriver = {
     name: "antigravity",
     async listModels(executable = "agy", workspace = process.cwd()) {
@@ -1260,12 +1352,20 @@ export const antigravityDriver = {
         // it is the only text that names the cause (a spent allowance and when it refills).
         const refused = code !== 0 || (parsed.status !== null && parsed.status.toUpperCase() !== "SUCCESS");
         if (refused) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(parsed.error || stderr || parsed.resultText || `agy exited with code ${code}`, 20_000) };
+            return {
+                status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId,
+                signal: agySignal(code, parsed.status, parsed.error, stderr, stdout),
+                error: boundedTail(parsed.error || stderr || parsed.resultText || `agy exited with code ${code}`, 20_000),
+            };
         }
         // An empty response with a denial on stderr is a refused run: report it instead of an empty reply.
         const denial = parsed.resultText?.trim() ? null : antigravityDenialNotice(stderr);
         if (denial) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(`agy returned no response: ${denial}`, 20_000) };
+            return {
+                status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId,
+                signal: { phase: "agent", witness: "vendor", kind: "denied_tool", vendor_status: parsed.status ?? "ERROR", vendor_message: boundedTail(denial, 2_000) },
+                error: boundedTail(`agy returned no response: ${denial}`, 20_000),
+            };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },
@@ -1318,6 +1418,7 @@ export const piDriver = {
                 status: "failed",
                 resultText: parsed.resultText,
                 sessionId: parsed.sessionId,
+                signal: unknownAgentSignal({ exit_code: code, stderr, stdout }),
                 error: boundedTail(stderr || parsed.resultText || `pi exited with code ${code}`, 20_000),
             };
         }
@@ -1450,7 +1551,7 @@ export const grokDriver = {
         const { code, stdout, stderr } = await execute(executable, grokRunArgs(input), input.workspace, agentTurnTimeoutMs(input), undefined, "local");
         const parsed = parseGrokOutput(stdout);
         if (code !== 0 || parsed.isError) {
-            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, error: boundedTail(stderr || parsed.resultText || `grok exited with code ${code}`, 20_000) };
+            return { status: "failed", resultText: parsed.resultText, sessionId: parsed.sessionId, signal: unknownAgentSignal({ exit_code: code, stderr, stdout }), error: boundedTail(stderr || parsed.resultText || `grok exited with code ${code}`, 20_000) };
         }
         return { status: "completed", resultText: parsed.resultText, sessionId: parsed.sessionId };
     },

package/dist/ensure-test-evidence.js

@@ -5,6 +5,7 @@
  */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { resolveCriterionReference } from "./driver.js";
 import { isBoundedVerificationCommand, isRunnableVerificationCommand } from "./execution-class.js";
 const execFileAsync = promisify(execFile);
 const TEST_EVIDENCE_DETAILS_MIN = 32;
@@ -287,8 +288,10 @@ export function criteriaForTestEvidence(report, command, acceptance = []) {
     const mapped = new Set();
     for (const item of sources) {
         for (const criterion of item.acceptance_criteria ?? []) {
+            // The agent may name a criterion by its key (c1). The witness carries the approved text, so
+            // that a key never reaches the packet and the criterion is not left unwitnessed.
             if (criterion)
-                mapped.add(criterion);
+                mapped.add(resolveCriterionReference(criterion, acceptance) ?? criterion);
         }
     }
     // A criterion that names the command verbatim is proved by that command's witness, whether or

package/dist/execution.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { resolveAgentTimeout } from "./execution-budget.js";
 import { ConduitRequestError } from "./client.js";
 import { redactSecrets, saveDriverOutcome, saveDriverQuota } from "./config.js";
-import { DRIVERS, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, requireStampedExecutionClass, tierForRisk } from "./driver.js";
+import { DRIVERS, acceptanceCriteriaLines, acceptanceReportSkeleton, agentReportTemplate, buildAssignmentPrompt, evidenceKinds, extractAgentReportJsonText, fuelEndpoint, normalizeEvidenceDigest, parseAgentReport, parseJsonObjectCandidate, pickModelCandidate, 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, quarantineAttemptWorktree, removeAttemptWorktree, } from "./attempt-worktree.js";
@@ -13,6 +13,7 @@ import { promisify } from "node:util";
 import { buildWorkspaceBrief, ensureCommitAvailable, normalizeRepositoryUrl, resolveAttemptStartCommit } from "./brief.js";
 import { buildSovereignExecutionFacts, bootstrapResultForWorkspace, workspaceIsClean } from "./execution-facts.js";
 import { forgeTransportFailure } from "./transport-fault.js";
+import { formatResetMinute, parseQuotaResetAt } from "./quota-reset.js";
 import { headCommitOrNull } from "./git.js";
 import { BRIDGE_PROTOCOL_VERSION } from "./preflight.js";
 import { bridgeVersion } from "./version.js";
@@ -96,14 +97,18 @@ export function providerQuotaRefusal(message) {
  */
 export function providerQuotaFailure(detail) {
     const resets = /resets? in ([^.\n]{1,40})/i.exec(detail);
+    // The absolute time wins when the vendor's words parse into one — an owner reads a clock, not
+    // arithmetic. The vendor's own phrasing is the fallback, and no reset stated stays unsaid.
+    const absolute = parseQuotaResetAt(detail);
+    const refills = absolute
+        ? `It refills at ${formatResetMinute(absolute)}.`
+        : resets ? `It refills in ${resets[1].trim()}.` : "";
     return {
         code: "driver_quota_exhausted",
         class: "environment",
         disposition: "hold",
         responsible_party: "computer_operator",
-        message: resets
-            ? `The agent lane on this computer has spent its subscription allowance. It refills in ${resets[1].trim()}.`
-            : "The agent lane on this computer has spent its subscription allowance.",
+        message: `The agent lane on this computer has spent its subscription allowance.${refills ? ` ${refills}` : ""}`,
         next_action: "Wait for the allowance to refill, bring another agent lane online to start sooner, or point this lane's model settings at a model that still has allowance.",
         diagnostic_detail: detail,
     };
@@ -159,66 +164,6 @@ function timeoutFailureBody(resolution, attemptId) {
 }
 class AgentTurnTimeoutError extends Error {
 }
-/**
- * When the window refills, if the vendor said so.
- *
- * Vendors phrase this as an absolute clock time ("resets at 3pm"), a duration ("try again in 2h
- * 14m"), or a Unix epoch. Returning null when none matches is fine — `laneQuota` treats a record
- * without a reset as exhausted until something proves otherwise, and the next successful run clears
- * it. Guessing a reset time would be worse: an invented one un-darks the lane early and the owner
- * watches the same refusal twice.
- */
-export function parseQuotaResetAt(message, now = Date.now()) {
-    const epoch = /\bresets?[ _-]?(?:at|in)?\b\D{0,12}(\d{10})\b/i.exec(message);
-    if (epoch)
-        return plausibleReset(Number(epoch[1]) * 1000, now);
-    // Units must end where they claim to. Unanchored, `m` swallowed the "m" of "500ms" and of
-    // "2 months" and read both as minutes — turning a 500-millisecond backoff into an eight-hour
-    // blackout of the only local lane.
-    const duration = /\b(?:try again|retry|resets?|available again)\b[^.\n]{0,24}?\bin\b\s*(?:(\d+)\s*(?:h|hrs?|hours?)\b(?!\w))?\s*(?:(\d+)\s*(?:m|mins?|minutes?)\b(?!\w))?\s*(?:(\d+)\s*(?:s|secs?|seconds?)\b(?!\w))?\s*(?:(\d+)\s*(?:ms|msecs?|milliseconds?)\b(?!\w))?/i.exec(message);
-    if (duration && (duration[1] || duration[2] || duration[3] || duration[4])) {
-        const ms = (Number(duration[1] ?? 0) * 3_600 + Number(duration[2] ?? 0) * 60 + Number(duration[3] ?? 0)) * 1_000
-            + Number(duration[4] ?? 0);
-        if (ms > 0)
-            return plausibleReset(now + ms, now);
-    }
-    const iso = /\bresets?\b[^.\n]{0,24}?(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)/i.exec(message);
-    if (iso)
-        return plausibleReset(Date.parse(iso[1]), now);
-    return null;
-}
-/**
- * A reset time worth believing, or none at all.
- *
- * Two failure modes this closes. A number lifted from prose is not always a clock — a request id
- * that happens to be ten digits reads as a date in 2286 and would dark the lane for centuries. And
- * `new Date(x).toISOString()` *throws* on a non-finite or out-of-range value, which here would
- * escape between the driver returning and `queueTerminal`, stranding the attempt in `agent_running`.
- * Anything outside a plausible billing window is treated as "no reset stated", which is the honest
- * answer and already a supported state.
- */
-function plausibleReset(ms, now) {
-    if (!Number.isFinite(ms))
-        return null;
-    if (ms > now + MAX_PLAUSIBLE_RESET_MS)
-        return null;
-    // A reset that has just passed is kept, not discarded. Rejecting it returned null, which does not
-    // mean "already refilled" — it means "no reset stated", the one case trusted for a whole week. A
-    // second of clock skew or a slow stderr flush would then dark the lane for seven days instead of
-    // clearing it at once. Keeping the stale timestamp lets `laneQuota` retire it on the next read.
-    if (ms < now - MAX_STALE_RESET_MS)
-        return null;
-    try {
-        return new Date(ms).toISOString();
-    }
-    catch {
-        return null;
-    }
-}
-/** No vendor window runs longer than a month; past that the parse was a coincidence, not a clock. */
-const MAX_PLAUSIBLE_RESET_MS = 31 * 24 * 3_600_000;
-/** How far back a reset may sit and still be a real one the run simply outlived. */
-const MAX_STALE_RESET_MS = 24 * 3_600_000;
 /** 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;
 /** Delivery-report / grant / evidence contract defects (non-retryable rework). */
@@ -1290,10 +1235,19 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
             // Keep the tree until the replay-safe terminal response explicitly says whether diagnosis was
             // queued. A network fault here must not delete the evidence before Bridge can replay terminal.
             retainAttemptWorktree = true;
+            // The driver's typed cause rides beside the prose, never instead of it. A recovered
+            // verification log describes the same run: the signal becomes Bridge's verification witness
+            // and the prose carries the evidence, so the verify class stays typed without new tables.
+            const signal = result.signal
+                ? verificationDetail
+                    ? { ...result.signal, phase: "verification", witness: "bridge", stderr_tail: undefined, stdout_tail: undefined }
+                    : result.signal
+                : undefined;
             const response = await queueTerminal(client, taskId, { action: "fail", body: {
                     error: message,
                     retryable: retryableAgentFailure(agentMessage),
                     ...(providerQuotaRefusal(agentMessage) ? { failure: providerQuotaFailure(agentMessage) } : {}),
+                    ...(signal ? { signal } : {}),
                     idempotency_key: `bridge:fail:${active.attemptId}`,
                 } });
             retainAttemptWorktree = response.retain_worktree === true;
@@ -1721,8 +1675,8 @@ function buildLandContinuationPrompt(input) {
         "APPROVED CHANGE SCOPE",
         ...(scope.length ? scope.map((path) => `- ${path}`) : ["- (none — stay within the plan)"]),
         "",
-        "APPROVED ACCEPTANCE CRITERIA",
-        ...(input.acceptance.length ? input.acceptance.map((criterion) => `- ${criterion}`) : ["- None"]),
+        "APPROVED ACCEPTANCE CRITERIA — name each one by its key, not by its text",
+        ...(input.acceptance.length ? acceptanceCriteriaLines(input.acceptance) : ["- None"]),
         "",
         "REQUIRED DELIVERY SHAPE",
         agentReportTemplate,
@@ -1840,8 +1794,11 @@ function buildDeliveryRepairPrompt(parseError, previousReply, acceptance) {
         "REQUIRED DELIVERY SHAPE",
         agentReportTemplate,
         "",
-        "APPROVED ACCEPTANCE CRITERIA",
-        ...(acceptance.length ? acceptance.map((criterion) => `- ${criterion}`) : ["- None"]),
+        "APPROVED ACCEPTANCE CRITERIA — name each one by its key, not by its text",
+        ...(acceptance.length ? acceptanceCriteriaLines(acceptance) : ["- None"]),
+        ...(acceptance.length
+            ? ["", "Start from this report skeleton and change only the statuses, the reasons, and the evidence:", acceptanceReportSkeleton(acceptance)]
+            : []),
         "",
         "PARSE ERROR",
         redactSecrets(parseError),

package/dist/failure-signal.js

@@ -0,0 +1,180 @@
+import { z } from "zod";
+/**
+ * A typed failure signal from Bridge: what ended the run, from the witness that saw it.
+ *
+ * Bridge reports failures as prose (`error`), and both sides classify the prose with regex tables
+ * kept in step by a test. Anything the tables do not name became `agent_execution_failed` /
+ * `transient` / `retry` — the one classification that spends attempts silently. The signal rides
+ * beside the prose: drivers that hold structured knowledge (a vendor envelope status, an exit
+ * code, the denied tool) emit it, and classification reads the signal first, the regex second.
+ *
+ * This file is mirrored byte-identical as packages/conduit-bridge/src/failure-signal.ts and
+ * src/conductor/failure-signal.ts. Bridge cannot import from the control plane, and the other
+ * way round, so test/failure-signal.test.ts pins the two files together instead of trusting
+ * them to stay in step.
+ */
+export const failureSignalSchema = z.object({
+    phase: z.enum(["claim", "checkout", "bootstrap", "agent", "verification", "delivery_report", "land"]),
+    /** Who produced the evidence for this signal: Bridge itself, the agent CLI, or the vendor. */
+    witness: z.enum(["bridge", "agent", "vendor"]),
+    kind: z.enum(["exit_code", "timeout", "denied_tool", "quota", "usage_error", "no_output", "contract", "verification_failed", "unknown"]),
+    /** The exact command when phase is verification or bootstrap. */
+    command: z.string().max(2_000).optional(),
+    exit_code: z.number().int().nullable().optional(),
+    /** The vendor envelope's own status, e.g. agy's "ERROR". */
+    vendor_status: z.string().max(200).optional(),
+    /** The vendor envelope's own reason, bounded. */
+    vendor_message: z.string().max(2_000).optional(),
+    stderr_tail: z.string().max(2_000).optional(),
+    stdout_tail: z.string().max(2_000).optional(),
+    /** ISO time when kind is quota and the vendor said. */
+    resets_at: z.string().max(64).nullable().optional(),
+});
+/** A reset time as a person reads it: "2026-09-10 09:36 UTC". Every reset is stored ISO in UTC. */
+function resetClock(resetsAt) {
+    return `${resetsAt.slice(0, 16).replace("T", " ")} UTC`;
+}
+/** Signal tails are bounded: one runaway log cannot fill the wire or the card. */
+function bounded2k(text) {
+    return text.length > 2_000 ? `${text.slice(0, 1_999)}…` : text;
+}
+/** The signal a driver that cannot say more emits: the run ended, here is its last output. */
+export function unknownAgentSignal(input) {
+    return {
+        phase: "agent",
+        witness: "agent",
+        kind: "unknown",
+        exit_code: input.exit_code ?? null,
+        ...(input.stderr?.trim() ? { stderr_tail: bounded2k(input.stderr) } : {}),
+        ...(input.stdout?.trim() ? { stdout_tail: bounded2k(input.stdout) } : {}),
+    };
+}
+/** The vendor's own reason, kept inside the 2,000-char message bound. */
+function quotedVendorText(signal) {
+    const text = signal.vendor_message ?? signal.stderr_tail ?? "";
+    return text.length > 400 ? `${text.slice(0, 399)}…` : text;
+}
+/**
+ * Classify one typed signal. Null when the signal carries no typed verdict (`kind: "unknown"`):
+ * the caller then lets its regex tables name the cause as an upgrade, and an unknown that survives
+ * them is held by `unknownSignalHold` — never retried blind.
+ *
+ * Rules, in order:
+ * 1. quota → the lane's allowance is spent: Hold, the computer operator's wait, reset quoted.
+ * 2. denied_tool / usage_error → the driver and vendor cannot run this assignment: Hold.
+ * 3. verification run by Bridge → the verify class: diagnose the retained tree and brief a repair.
+ * 4. contract, or a delivery_report phase → the delivery contract codes: rework.
+ * 5. timeout → the turn reached its execution limit: stop.
+ */
+export function classifyFailureSignal(signal) {
+    if (signal.kind === "quota") {
+        const refill = signal.resets_at
+            ? ` It refills at ${resetClock(signal.resets_at)}.`
+            : signal.vendor_message
+                ? ` The vendor said: ${quotedVendorText(signal)}`
+                : "";
+        return {
+            code: "driver_quota_exhausted",
+            class: "environment",
+            disposition: "hold",
+            responsible_party: "computer_operator",
+            message: `The agent lane on this computer has spent its subscription allowance.${refill}`,
+            next_action: "Wait for the allowance to refill, bring another agent lane online to start sooner, or point this lane's model settings at a model that still has allowance.",
+            diagnostic_detail: signal.vendor_message ?? signal.stderr_tail,
+        };
+    }
+    if (signal.kind === "denied_tool" || signal.kind === "usage_error") {
+        return {
+            code: "driver_incompatible",
+            class: "environment",
+            disposition: "hold",
+            responsible_party: "computer_operator",
+            message: signal.kind === "denied_tool"
+                ? "The agent CLI refused a tool this assignment requires, so it cannot run here as configured."
+                : "The agent CLI rejected how this assignment was handed to it, so every retry fails the same way.",
+            next_action: "The computer operator or Bridge must fix the lane's tool mapping or driver flags. The product owner does not author technical constraints.",
+            diagnostic_detail: signal.vendor_message ?? signal.stderr_tail,
+        };
+    }
+    if (signal.phase === "verification" && signal.witness === "bridge") {
+        return {
+            code: "agent_execution_failed",
+            class: "transient",
+            disposition: "retry",
+            responsible_party: "conduit",
+            message: "The agent run failed its own verification before delivery.",
+            next_action: "Conduit will diagnose the retained failed run and brief the next authoring attempt.",
+            diagnostic_detail: [signal.command ? `$ ${signal.command}` : null, signal.stderr_tail, signal.stdout_tail].filter(Boolean).join("\n") || undefined,
+        };
+    }
+    if (signal.phase === "delivery_report" || signal.kind === "contract") {
+        return signal.phase === "delivery_report"
+            ? {
+                code: "delivery_report_invalid",
+                class: "contract",
+                disposition: "rework",
+                responsible_party: "conduit",
+                message: "The delivery report did not satisfy the delivery contract.",
+                next_action: "Bridge's report-only repair turns ran; review the report defect and rework it.",
+                diagnostic_detail: signal.vendor_message ?? signal.stderr_tail,
+            }
+            : {
+                code: "execution_contract_failed",
+                class: "contract",
+                disposition: "rework",
+                responsible_party: "conduit",
+                message: "The agent could not satisfy the approved execution contract.",
+                next_action: "Review the last run and rework the same contract; change the plan only if its authority or outcome is wrong.",
+                diagnostic_detail: signal.vendor_message ?? signal.stderr_tail,
+            };
+    }
+    if (signal.kind === "timeout") {
+        return {
+            code: "agent_turn_timeout",
+            class: "platform",
+            disposition: "stop",
+            responsible_party: "conduit",
+            message: "The agent turn reached its configured execution limit.",
+            next_action: "Conduit must compare the package budget with the computer ceiling and resume with a larger bounded turn or checkpoint. The product owner does not need to author implementation constraints.",
+            diagnostic_detail: signal.stderr_tail,
+        };
+    }
+    return null;
+}
+/**
+ * The one verdict for an unknown that survived every table: Hold, on Conduit.
+ *
+ * An unknown signal used to fall through to `transient` and burn attempts silently. The owner now
+ * sees the run's own last words — the bounded stderr tail — and Conduit owes the diagnosis, because
+ * nobody can yet name the cause.
+ */
+export function unknownSignalHold(signal, proseDetail) {
+    const tail = signal.stderr_tail ?? signal.stdout_tail ?? "";
+    return {
+        code: "agent_run_unexplained",
+        class: "environment",
+        disposition: "hold",
+        responsible_party: "conduit",
+        message: tail
+            ? `The agent run failed and neither Bridge nor Conduit can yet name the cause. The run's last output: ${quotedVendorText(signal)}`
+            : "The agent run failed and neither Bridge nor Conduit can yet name the cause.",
+        next_action: "Conduit will diagnose the retained run before any retry. The product owner does not need to author technical constraints.",
+        diagnostic_detail: proseDetail || tail || undefined,
+    };
+}
+/**
+ * agy's JSON envelope status/error mapped to a typed kind, from the vendor's own vocabulary.
+ *
+ * This is vendor knowledge, not a classification table: it reads the words agy itself prints in
+ * its envelope, so the signal can carry `quota` (etc.) and the generic tables stay empty of agy.
+ */
+export function vendorKindForAntigravity(vendorStatus, vendorMessage) {
+    const text = `${vendorStatus ?? ""}\n${vendorMessage ?? ""}`;
+    if (/individual quota reached|quota reached|upgrade your subscription/i.test(text))
+        return "quota";
+    if (/no output produced|headless mode cannot prompt for|was auto-denied|permission/i.test(text))
+        return "denied_tool";
+    if (/took "[^"]*" as its prompt|Usage of agy|unknown (?:option|argument)|unrecognized (?:option|argument)/i.test(text))
+        return "usage_error";
+    return "unknown";
+}

package/dist/quota-reset.js

@@ -0,0 +1,88 @@
+/**
+ * The refill time a vendor states in a quota refusal, as an absolute clock.
+ *
+ * This file is mirrored byte-identical as packages/conduit-bridge/src/quota-reset.ts and
+ * src/conductor/quota-reset.ts. Bridge cannot import from the control plane, and the other way
+ * round, so test/failure-classification.test.ts pins the two files together instead of trusting
+ * them to stay in step.
+ *
+ * Vendors phrase the refill as an absolute clock time (RFC 1123), a duration ("try again in 2h
+ * 14m", or agy's Go form "Resets in 165h48m43s"), or a Unix epoch. Returning null when none
+ * matches is fine — `laneQuota` treats a record without a reset as exhausted until something
+ * proves otherwise, and the next successful run clears it. Guessing a reset time would be worse:
+ * an invented one un-darks the lane early, and the owner watches the same refusal twice.
+ */
+export function parseQuotaResetAt(message, now = Date.now()) {
+    const epoch = /\bresets?[ _-]?(?:at|in)?\b\D{0,12}(\d{10})\b/i.exec(message);
+    if (epoch)
+        return plausibleReset(Number(epoch[1]) * 1000, now);
+    // Units must end where they claim to. Unanchored, `m` swallowed the "m" of "500ms" and of
+    // "2 months" and read both as minutes — turning a 500-millisecond backoff into an eight-hour
+    // blackout of the only local lane.
+    const duration = /\b(?:try again|retry|resets?|available again)\b[^.\n]{0,24}?\bin\b\s*(?:(\d+)\s*(?:h|hrs?|hours?)\b(?!\w))?\s*(?:(\d+)\s*(?:m|mins?|minutes?)\b(?!\w))?\s*(?:(\d+)\s*(?:s|secs?|seconds?)\b(?!\w))?\s*(?:(\d+)\s*(?:ms|msecs?|milliseconds?)\b(?!\w))?/i.exec(message);
+    if (duration && (duration[1] || duration[2] || duration[3] || duration[4])) {
+        const ms = (Number(duration[1] ?? 0) * 3_600 + Number(duration[2] ?? 0) * 60 + Number(duration[3] ?? 0)) * 1_000
+            + Number(duration[4] ?? 0);
+        if (ms > 0)
+            return plausibleReset(now + ms, now);
+    }
+    // Go prints the same duration with the units glued to the numbers ("Resets in 165h48m43s",
+    // under an hour "48m43s", "45m0s"), where no unit ends at a boundary and the spaced pattern
+    // above cannot see it. Match the token whole, then let the trailing `\b(?!\w)` reject a glued
+    // "ms": "1h30ms" is one hour plus 30 milliseconds, and reading that 30 as minutes is the
+    // eight-hour blackout the spaced rule guards against.
+    const compact = /\b(?:try again|retry|resets?|available again)\b[^.\n]{0,24}?\bin\s+((?:(\d{1,5})h)?(?:(\d{1,2})m)?(?:(\d{1,2})s)?)\b(?!\w)/i.exec(message);
+    if (compact && (compact[2] || compact[3] || compact[4])) {
+        const ms = Number(compact[2] ?? 0) * 3_600_000 + Number(compact[3] ?? 0) * 60_000 + Number(compact[4] ?? 0) * 1_000;
+        if (ms > 0)
+            return plausibleReset(now + ms, now);
+    }
+    const iso = /\bresets?\b[^.\n]{0,24}?(\d{4}-\d{2}-\d{2}T[\d:.]+Z?)/i.exec(message);
+    if (iso)
+        return plausibleReset(Date.parse(iso[1]), now);
+    const rfc1123 = /\bresets?\b[^.\n]{0,24}?((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{1,2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT)\b/i.exec(message);
+    if (rfc1123)
+        return plausibleReset(Date.parse(rfc1123[1]), now);
+    return null;
+}
+/**
+ * A reset time worth believing, or none at all.
+ *
+ * Two failure modes this closes. A number lifted from prose is not always a clock — a request id
+ * that happens to be ten digits reads as a date in 2286 and would dark the lane for centuries. And
+ * `new Date(x).toISOString()` *throws* on a non-finite or out-of-range value, which here would
+ * escape between the driver returning and the failure being queued, stranding the attempt in a
+ * running state. Anything outside a plausible billing window is treated as "no reset stated",
+ * which is the honest answer and already a supported state.
+ */
+function plausibleReset(ms, now) {
+    if (!Number.isFinite(ms))
+        return null;
+    if (ms > now + MAX_PLAUSIBLE_RESET_MS)
+        return null;
+    // A reset that has just passed is kept, not discarded. Rejecting it returned null, which does not
+    // mean "already refilled" — it means "no reset stated", the one case trusted for a whole week. A
+    // second of clock skew or a slow stderr flush would then dark the lane for seven days instead of
+    // clearing it at once. Keeping the stale timestamp lets `laneQuota` retire it on the next read.
+    if (ms < now - MAX_STALE_RESET_MS)
+        return null;
+    try {
+        return new Date(ms).toISOString();
+    }
+    catch {
+        return null;
+    }
+}
+/** No vendor window runs longer than a month; past that the parse was a coincidence, not a clock. */
+const MAX_PLAUSIBLE_RESET_MS = 31 * 24 * 3_600_000;
+/** How far back a reset may sit and still be a real one the run simply outlived. */
+const MAX_STALE_RESET_MS = 24 * 3_600_000;
+/**
+ * The absolute reset as a person reads it: "2026-09-10 09:36 UTC".
+ *
+ * Every reset is stored as ISO in UTC, so the same cut of the string is the same moment on both
+ * sides of the wire, and no locale can make the two screens disagree.
+ */
+export function formatResetMinute(resetsAt) {
+    return `${resetsAt.slice(0, 16).replace("T", " ")} UTC`;
+}

package/package.json

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