@miraland-labs/conduit-bridge 0.16.161 → 0.16.171

package/dist/driver.js

@@ -291,82 +291,58 @@ export function buildAssignmentPrompt(context) {
     "- With it, write unverified_detail: one sentence naming exactly what was missing, in the owner's terms. \"Checking this needs the app deployed and running, and this task cannot deploy\" — not \"environment unavailable\".", 
     // The owner reads outcome, limitations and unverified_detail on a phone. Dense prose was the
     // complaint on every delivery this trial; ASD-STE100's rules are the shortest fix.
-    "- Write outcome, risks, limitations and every unverified_detail in Simplified Technical English (ASD-STE100): short sentences of at most 20 words, one fact or instruction per sentence, active voice, present tense, and the product's own terms (work package, delivery, gate, Hold) with no synonyms.", "", "When the work is finished, end your reply with exactly one fenced ```json block:", agentReportTemplate);
+    "- Write outcome, risks, limitations and every unverified_detail in Simplified Technical English (ASD-STE100): short sentences of at most 20 words, one fact or instruction per sentence, active voice, present tense, and the product's own terms (work package, delivery, gate, Hold) with no synonyms.", "", "- Delivery report limits: each details and acceptance_criteria entry is at most 4000 characters, with at most 100 entries per list; digest, name, and unverified_detail are non-empty and at most 500 characters; uri and pull_request_url are absolute URLs of at most 4000 characters.", "When the work is finished, end your reply with exactly one fenced ```json block:", agentReportTemplate);
     return lines.join("\n");
 }
 /**
- * Extract report JSON text from an agent reply, preferring the last closed ```json fence, then
- * earlier fences, then an unclosed one (truncated replies), then a balanced top-level object.
- *
- * A candidate only wins if it parses. The closed-fence pattern is lazy, so it ends at the first
- * ``` it meets — including one inside the report's own strings. That is not a rare accident: a
- * report about markdown rendering describes fences, so its summary contains them, and the extractor
- * then preferred a truncated fragment over the perfectly recoverable whole. Every retry wrote the
- * same summary and failed the same way, which is what "malformed report JSON, again" was.
+ * The reply's last ```json fenced block, or the whole reply when it has no fence. An opener ends its
+ * line (the cursor lane writes a sentence and opens the fence at its end), a closer stands alone,
+ * and a JSON string holds no line break, so a fence quoted inside the report's own strings never
+ * opens or closes one. Callers read the result with `JSON.parse` and nothing else.
  */
 export function extractAgentReportJsonText(text) {
-    const candidates = [];
-    // Anchor on each fence *opener*, last first — the report is the closing act of a reply that may
-    // quote examples before it. Taking everything after an opener rather than up to the next ```
-    // leaves the closing fence for the balanced-object scan to step over, which is what lets a report
-    // containing fences, and a reply truncated mid-fence, both recover.
-    for (const opener of [...text.matchAll(/```json[ \t]*\r?\n?/gi)].reverse()) {
-        const start = (opener.index ?? 0) + opener[0].length;
-        const value = text.slice(start).trim();
-        if (value)
-            candidates.push(value);
+    const lines = text.split(/\r?\n/);
+    let opener = -1;
+    for (let i = lines.length - 1; i >= 0 && opener < 0; i--)
+        if (/```json[ \t]*$/i.test(lines[i]))
+            opener = i;
+    if (opener < 0)
+        return text.trim();
+    const closer = lines.findIndex((line, i) => i > opener && /^[ \t]*```[ \t]*$/.test(line));
+    return lines.slice(opener + 1, closer < 0 ? undefined : closer).join("\n").trim();
+}
+/**
+ * A reply whose object does not parse or does not match its strict schema. Each issue is one zod
+ * path and message, so the re-ask and the failure detail name the field, not a sentence about it.
+ */
+export class ReplyInvalid extends Error {
+    kind;
+    issues;
+    constructor(kind, issues) {
+        super(`${kind}: ${issues.join("; ")}`);
+        this.kind = kind;
+        this.issues = issues;
     }
-    const start = text.indexOf("{");
-    if (start >= 0)
-        candidates.push(text.slice(start).trim());
-    if (candidates.length === 0)
-        throw new Error("Agent did not emit the required structured report");
-    for (const candidate of candidates) {
+}
+/** Parse a reply's object and validate it strictly; anything else is a ReplyInvalid. */
+export function parseReplyObject(kind, schema, text, structuredOutput) {
+    let raw = structuredOutput;
+    if (structuredOutput === undefined) {
         try {
-            parseJsonObjectCandidate(candidate);
-            return candidate;
+            raw = JSON.parse(extractAgentReportJsonText(text ?? ""));
         }
-        catch {
-            // Truncated at a fence inside a string, or prose that only looked like an object.
-        }
-    }
-    // Nothing parsed: hand back the preferred candidate so the caller reports on the real report.
-    return candidates[0];
-}
-/** Parse JSON, or the first balanced `{...}` object when the candidate is truncated prose. */
-export function parseJsonObjectCandidate(candidate) {
-    try {
-        return JSON.parse(candidate);
-    }
-    catch {
-        const start = candidate.indexOf("{");
-        if (start < 0)
-            throw new Error("Agent emitted malformed report JSON");
-        let depth = 0;
-        let inString = false;
-        for (let i = start; i < candidate.length; i++) {
-            const ch = candidate[i];
-            if (inString) {
-                if (ch === "\\")
-                    i++;
-                else if (ch === '"')
-                    inString = false;
-            }
-            else if (ch === '"')
-                inString = true;
-            else if (ch === "{")
-                depth++;
-            else if (ch === "}" && --depth === 0) {
-                try {
-                    return JSON.parse(candidate.slice(start, i + 1));
-                }
-                catch {
-                    throw new Error("Agent emitted malformed report JSON");
-                }
-            }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "not JSON";
+            throw new ReplyInvalid(kind, [`(root): the last \`\`\`json fenced block, or the whole reply when it has none, is not JSON (${reason})`]);
         }
-        throw new Error("Agent emitted malformed report JSON");
     }
+    const parsed = schema.safeParse(raw);
+    if (parsed.success)
+        return parsed.data;
+    throw new ReplyInvalid(kind, parsed.error.issues.slice(0, 20).map((issue) => {
+        const at = issue.path.reduce((path, key) => typeof key === "number" ? `${path}[${key}]` : path ? `${path}.${key}` : key, "");
+        return `${at || "(root)"}: ${issue.message}`;
+    }));
 }
 /**
  * Why this run could not decide an acceptance criterion.
@@ -474,37 +450,41 @@ function quoteCriterion(value) {
     const text = value.trim().replace(/\s+/g, " ");
     return `"${text.length > 120 ? `${text.slice(0, 117)}...` : text}"`;
 }
-/** Parse the agent's final fenced JSON block into a bounded report. */
-export function parseAgentReport(text, acceptance) {
-    let raw;
-    try {
-        raw = parseJsonObjectCandidate(extractAgentReportJsonText(text));
-    }
-    catch (error) {
-        if (error instanceof Error && /structured report|malformed report JSON/.test(error.message))
-            throw error;
-        throw new Error("Agent emitted malformed report JSON");
-    }
-    const stringList = z.array(z.string().trim().min(1).max(4_000)).max(100);
-    sanitizeReportShape(raw);
-    const parsed = z.object({
-        outcome: z.string().trim().min(1).max(20_000),
-        changes: stringList,
-        verification: stringList,
-        acceptance_results: z.array(z.object({ criterion: z.string().trim().min(1).max(4_000), status: z.enum(["met", "not_met", "unknown"]), unverified_reason: z.enum(UNVERIFIED_REASONS).optional(), unverified_detail: z.string().trim().min(1).max(500).optional() })).max(100),
-        evidence: z.array(z.object({
-            kind: z.enum(evidenceKinds), name: z.string().trim().min(1).max(500), uri: z.string().url().max(4_000).optional(),
-            digest: z.string().trim().min(1).max(500).optional(), details: stringList, acceptance_criteria: stringList,
-        })).max(100),
-        assumptions: stringList, risks: stringList, limitations: stringList,
-        head_commit: z.string().regex(/^[0-9a-f]{7,64}$/i).optional(),
-        pull_request_url: z.string().url().max(4_000).optional(),
-    }).strict().safeParse(raw);
-    if (!parsed.success) {
-        const issue = parsed.error.issues[0];
-        const at = issue?.path?.length ? ` at ${issue.path.join(".")}` : "";
-        throw new Error(`Agent report is invalid${at}: ${issue?.message ?? "unknown validation error"}`);
-    }
+const reportStringList = z.array(z.string().trim().min(1).max(4_000)).max(100);
+export const agentReportSchema = z.object({
+    outcome: z.string().trim().min(1).max(20_000),
+    changes: reportStringList,
+    verification: reportStringList,
+    acceptance_results: z.array(z.object({
+        criterion: z.string().trim().min(1).max(4_000), status: z.enum(["met", "not_met", "unknown"]),
+        unverified_reason: z.enum(UNVERIFIED_REASONS).optional(), unverified_detail: z.string().trim().min(1).max(500).optional(),
+    })).max(100),
+    evidence: z.array(z.object({
+        kind: z.enum(evidenceKinds), name: z.string().trim().min(1).max(500), uri: z.string().url().max(4_000).optional(),
+        digest: z.string().trim().min(1).max(500).optional(), details: reportStringList, acceptance_criteria: reportStringList,
+    })).max(100),
+    assumptions: reportStringList, risks: reportStringList, limitations: reportStringList,
+    head_commit: z.string().regex(/^[0-9a-f]{7,64}$/i).optional(),
+    pull_request_url: z.string().url().max(4_000).optional(),
+}).strict();
+/** Strict generation requires every key; explicit null carries an optional field's absence. */
+export const agentReportOutputSchema = agentReportSchema.extend({
+    acceptance_results: z.array(agentReportSchema.shape.acceptance_results.element.extend({
+        unverified_reason: z.enum(UNVERIFIED_REASONS).nullable().transform((value) => value ?? undefined),
+        unverified_detail: z.string().trim().min(1).max(500).nullable().transform((value) => value ?? undefined),
+    }).strict()).max(100),
+    evidence: z.array(agentReportSchema.shape.evidence.element.extend({
+        uri: z.string().url().max(4_000).nullable().transform((value) => value ?? undefined),
+        digest: z.string().trim().min(1).max(500).nullable().transform((value) => value ?? undefined),
+    }).strict()).max(100),
+    head_commit: z.string().regex(/^[0-9a-f]{7,64}$/i).nullable().transform((value) => value ?? undefined),
+    pull_request_url: z.string().url().max(4_000).nullable().transform((value) => value ?? undefined),
+});
+/** Parse the agent's final fenced JSON block or its native structured output into a bounded report. */
+export function parseAgentReport(text, acceptance, structuredOutput) {
+    const data = structuredOutput === undefined
+        ? parseReplyObject("report_invalid", agentReportSchema, text)
+        : parseReplyObject("report_invalid", agentReportOutputSchema, text, structuredOutput);
     // 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
@@ -518,8 +498,8 @@ export function parseAgentReport(text, acceptance) {
             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) }));
+    const acceptanceResults = data.acceptance_results.map((item) => ({ ...item, criterion: toApprovedText(item.criterion) }));
+    const evidence = 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("; ")
@@ -550,7 +530,7 @@ export function parseAgentReport(text, acceptance) {
     // completed work instead of throwing the whole implementation away.
     const mappedCriteria = new Set(evidence.flatMap((item) => item.acceptance_criteria.map(criterionKey)));
     return {
-        ...parsed.data,
+        ...data,
         evidence,
         acceptance_results: acceptanceResults.map((item) => {
             const { unverified_reason: reported, unverified_detail: detail, ...rest } = item;
@@ -588,86 +568,6 @@ export function normalizeEvidenceDigest(digest) {
         return `sha256:${trimmed.toLowerCase()}`;
     return trimmed;
 }
-/**
- * Tolerate benign agent-output noise before strict validation: drop empty/whitespace-only entries from
- * string arrays and remove empty optional scalars, so a single stray "" does not fail an otherwise-valid
- * delivery. Required non-empty scalars (outcome, evidence.name, criterion) stay strict — they cannot be
- * fabricated. Mutates `raw` in place.
- */
-function sanitizeReportShape(raw) {
-    if (!raw || typeof raw !== "object")
-        return;
-    const obj = raw;
-    const cleanList = (value) => Array.isArray(value)
-        ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim())
-        : value;
-    for (const key of ["changes", "verification", "assumptions", "risks", "limitations"]) {
-        if (key in obj)
-            obj[key] = cleanList(obj[key]);
-    }
-    if (Array.isArray(obj.evidence)) {
-        for (const item of obj.evidence) {
-            if (!item || typeof item !== "object")
-                continue;
-            const evidence = item;
-            if ("details" in evidence)
-                evidence.details = cleanList(evidence.details);
-            // Experimental lanes have repeatedly omitted this list on otherwise-useful test evidence.
-            // An empty mapping asserts nothing; later logic downgrades any now-unsupported "met" result.
-            if (!("acceptance_criteria" in evidence) || evidence.acceptance_criteria == null)
-                evidence.acceptance_criteria = [];
-            else
-                evidence.acceptance_criteria = cleanList(evidence.acceptance_criteria);
-            // Agents emit null/"" for optional fields they have no value for — treat as absent.
-            if ("digest" in evidence && (typeof evidence.digest !== "string" || evidence.digest.trim() === ""))
-                delete evidence.digest;
-            else if (typeof evidence.digest === "string")
-                evidence.digest = normalizeEvidenceDigest(evidence.digest);
-            // Drop non-URL / empty uris so an optional bad uri doesn't fail the whole report.
-            if ("uri" in evidence && (typeof evidence.uri !== "string" || !z.string().url().max(4_000).safeParse(evidence.uri).success))
-                delete evidence.uri;
-            // Witness is Bridge-authored provenance. An agent claiming it must not survive parse.
-            if ("witness" in evidence)
-                delete evidence.witness;
-        }
-    }
-    // Same rule for optional top-level scalars: null/"" means absent, not invalid.
-    for (const key of ["head_commit", "pull_request_url"]) {
-        if (key in obj && (typeof obj[key] !== "string" || obj[key].trim() === ""))
-            delete obj[key];
-    }
-    // And the same rule for keys Conduit does not model at all. An unknown key carrying a real value
-    // still fails validation below — it may be the agent asserting something outside the contract, and
-    // silently dropping that would hide it. An empty one is only noise, and discarding an otherwise
-    // valid delivery over it cost a full staging canary on 2026-07-22 ("assumptions_note": null).
-    for (const key of Object.keys(obj)) {
-        if (!reportKeys.has(key) && isSemanticallyEmpty(obj[key]))
-            delete obj[key];
-    }
-}
-/** Top-level keys the delivery contract models. Keep in step with the schema in parseAgentReport. */
-const reportKeys = new Set([
-    "outcome", "changes", "verification", "acceptance_results", "evidence",
-    "assumptions", "risks", "limitations", "head_commit", "pull_request_url",
-]);
-/**
- * Words agents write when a field has no value. Observed live: after `"assumptions_note": null` was
- * handled, the very next real run emitted `"assumptions_note": "none"` and failed the same way.
- * These carry no claim, so an unknown key holding one is noise rather than an assertion.
- */
-const noValueWords = new Set(["none", "n/a", "na", "nil", "null", "nothing", "not applicable", "-", "—"]);
-/** Absent-in-practice: null, undefined, blank/no-value string, or an empty array/object. `false` and `0` are values. */
-function isSemanticallyEmpty(value) {
-    if (value === null || value === undefined)
-        return true;
-    if (typeof value === "string")
-        return value.trim() === "" || noValueWords.has(value.trim().toLowerCase());
-    if (Array.isArray(value))
-        return value.length === 0;
-    if (typeof value === "object")
-        return Object.keys(value).length === 0;
-    return false;
-}
 /** A count the vendor printed, or undefined when the envelope holds no usable number. */
 function usageNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
@@ -745,6 +645,8 @@ export const claudeCodeDriver = {
         // The prompt goes on stdin (`claude -p` reads it there when no prompt argument is given): Linux
         // caps one argument at 128 KiB (MAX_ARG_STRLEN) and an assignment contract exceeds that.
         const args = ["-p", "--output-format", "json", "--max-turns", String(maxTurns)];
+        if (input.outputSchemaPath)
+            args.push("--json-schema", await readFile(input.outputSchemaPath, "utf8"));
         args.push(...modelArgs(claudeCodeDriver, input.model));
         if (input.resumeSessionId)
             args.push("--resume", input.resumeSessionId);
@@ -777,7 +679,10 @@ export const claudeCodeDriver = {
         if (code !== 0 || !message || message.is_error) {
             return { status: "failed", resultText: message?.result ?? null, sessionId, usage, signal: agentExitSignal({ exit_code: code, stderr, stdout, model: input.model }), error: boundedTail(message?.result || stderr || `agent exited with code ${code}`, 20_000) };
         }
-        return { status: "completed", resultText: message.result ?? "", sessionId, usage };
+        return {
+            status: "completed", resultText: message.result ?? "", sessionId, usage,
+            ...(input.outputSchemaPath ? { structuredOutput: message.structured_output ?? null } : {}),
+        };
     },
 };
 /**
@@ -803,6 +708,8 @@ export function codexExecArgs(input, sandbox) {
         ? ["exec", "resume", "--json", "-c", `sandbox_mode="${sandbox}"`]
         : ["exec", "--json", "--sandbox", sandbox];
     args.push(...modelArgs(codexDriver, input.model));
+    if (input.outputSchemaPath)
+        args.push("--output-schema", input.outputSchemaPath);
     const networkAccess = input.networkAccess
         ?? (sandbox === "workspace-write" && input.capabilities?.includes("external_network"));
     if (sandbox === "workspace-write" && networkAccess) {
@@ -916,7 +823,17 @@ export const codexDriver = {
         if (code !== 0) {
             return { status: "failed", resultText, sessionId: parsed.sessionId, usage: parsed.usage, signal: agentExitSignal({ exit_code: code, stderr, stdout, model: input.model }), error: boundedTail(stderr || stdout || `codex exited with code ${code}`, 20_000) };
         }
-        return { status: "completed", resultText, sessionId: parsed.sessionId, usage: parsed.usage };
+        let structuredOutput = null;
+        if (input.outputSchemaPath && parsed.resultText !== null) {
+            try {
+                structuredOutput = JSON.parse(parsed.resultText);
+            }
+            catch { /* Validation refuses null. */ }
+        }
+        return {
+            status: "completed", resultText, sessionId: parsed.sessionId, usage: parsed.usage,
+            ...(input.outputSchemaPath ? { structuredOutput } : {}),
+        };
     },
 };
 /**
@@ -2055,8 +1972,10 @@ export function boundedEnvironment(fuel, fuelSource = "conduit", extraEnv) {
         "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "no_proxy", "SSL_CERT_FILE", "NODE_EXTRA_CA_CERTS",
         // The machine's Rust toolchain and build cache. Without CARGO_TARGET_DIR an agent compiled every
         // dependency cold in its worktree, so no `cargo test` it started finished (acme-sim SV1b, 2026-10-10);
-        // CARGO_PROFILE_* keeps its build identical to the gate's, so the gate reuses what the agent built.
-        "CARGO_HOME", "RUSTUP_HOME", "CARGO_TARGET_DIR",
+        // CARGO_PROFILE_* and CARGO_INCREMENTAL keep its build identical to the gate's, so the gate reuses
+        // what the agent built; an incremental agent build next to a non-incremental gate build in one
+        // target dir left mixed objects that failed to link (acme-sim, 2026-10-15 and 2026-10-18).
+        "CARGO_HOME", "RUSTUP_HOME", "CARGO_TARGET_DIR", "CARGO_INCREMENTAL",
         ...Object.keys(process.env).filter((name) => name.startsWith("CARGO_PROFILE_")),
         ...(fuelSource === "local" ? LOCAL_VENDOR_ENV : [])];
     const env = Object.fromEntries(allowed.flatMap((name) => process.env[name] === undefined ? [] : [[name, process.env[name]]]));

package/dist/ensure-test-evidence.js

@@ -240,20 +240,33 @@ export function boundedDetailLines(lines, maxLines, identifiers = []) {
     // 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.
+    // A run of several suites prints one summary per suite, and only the last one sits in the tail:
+    // cargo's "test result: ok. 614 passed" for the cli binary says nothing about the core binary. A
+    // criterion settled by the totals (a test count delta) needs every summary, so they are kept too.
+    const summaries = middle.filter((line) => SUITE_SUMMARY.some((form) => form.test(line))).slice(0, NAMED_DETAIL_LINES_MAX);
     const named = identifiers.length === 0
         ? []
-        : [...new Set(middle.filter((line) => identifiers.some((id) => line.includes(id))))]
+        : [...new Set(middle.filter((line) => !summaries.includes(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;
+    const dropped = middle.length - summaries.length - named.length;
     return [
         ...lines.slice(0, head),
         `… ${dropped} line${dropped === 1 ? "" : "s"} omitted …`,
+        ...summaries,
         ...named,
         ...lines.slice(lines.length - tail),
     ];
 }
 const NAMED_DETAIL_LINES_MAX = 40;
+/** One suite's totals line: cargo, vitest, unittest, pytest, go test. */
+const SUITE_SUMMARY = [
+    /^test result: /,
+    /^\s*(Test Files|Tests)\s+\d/,
+    /^Ran \d+ tests?\b/,
+    /^=+ .*\b(passed|failed)\b.* in [\d.]+s =+$/,
+    /^(ok|FAIL)\s+\S+\s+[\d.]+s$/,
+];
 /**
  * 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