@miraland-labs/conduit-bridge 0.16.41 → 0.16.42

package/dist/driver.js

@@ -28,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
@@ -97,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) {
@@ -300,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, " ");
@@ -336,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) {
@@ -358,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"

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";
@@ -1675,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,
@@ -1794,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/package.json

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