@miraland-labs/conduit-bridge 0.14.5 → 0.14.7

package/dist/driver.js

@@ -15,7 +15,7 @@ function deliveryLanguageRule(language) {
     return null;
 }
 export const evidenceKinds = ["change", "test", "preview", "research", "documentation"];
-export const agentReportTemplate = '{"outcome": "one-paragraph summary", "changes": ["path — what changed"], "verification": ["command — result"], "acceptance_results": [{"criterion": "exact criterion text", "status": "met|not_met|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 — 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"}';
 /**
  * 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
@@ -136,26 +136,54 @@ export function buildAssignmentPrompt(context) {
     // A met claim with nothing backing it is rejected server-side ("Met acceptance criteria require
     // mapped evidence"). Observed live: six criteria marked met, evidence mapped to four, whole
     // delivery lost. Say it here rather than let the agent discover it by failing.
-    "- EVERY criterion you mark \"met\" must appear in the acceptance_criteria list of at least one evidence entry. A met criterion with no evidence mapped to it fails the whole delivery — mark it unknown instead, or add the evidence that supports it.", "", "When the work is finished, end your reply with exactly one fenced ```json block:", agentReportTemplate);
+    "- EVERY criterion you mark \"met\" must appear in the acceptance_criteria list of at least one evidence entry. A met criterion with no evidence mapped to it fails the whole delivery — mark it unknown instead, or add the evidence that supports it.", 
+    // The owner has to choose between returning the delivery and accepting it. Without a reason
+    // they cannot tell a check another attempt could make from one no attempt can, so a return
+    // spends a budget and comes back identical (initiative efa56ccd, twice).
+    "- Every criterion you mark \"unknown\" must carry unverified_reason: not_attempted when you simply did not check it and another run could; needs_authority when this package has no grant or capability for it; needs_environment when it needs a running or deployed system you cannot start here; needs_third_party when it needs an account or platform outside this workspace; needs_human_judgment when only a person can assess it. Say which one — it decides whether the owner returns the work or accepts it.", 
+    // A code can only say the class. The owner reads a sentence, and the sentence needs the
+    // particular: which app, which authority, which account. The run already knows it.
+    "- 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\".", "", "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. Prefers the last closed ```json fence,
- * then an unclosed ```json fence (truncated replies), then a balanced top-level object.
+ * 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.
  */
 export function extractAgentReportJsonText(text) {
-    const closed = [...text.matchAll(/```json\s*([\s\S]*?)```/gi)];
-    const fromFence = closed.at(-1)?.[1]?.trim();
-    if (fromFence)
-        return fromFence;
-    const unclosed = /```json\s*([\s\S]*)$/i.exec(text);
-    const fromUnclosed = unclosed?.[1]?.trim();
-    if (fromUnclosed)
-        return fromUnclosed;
+    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 start = text.indexOf("{");
-    if (start < 0)
+    if (start >= 0)
+        candidates.push(text.slice(start).trim());
+    if (candidates.length === 0)
         throw new Error("Agent did not emit the required structured report");
-    return text.slice(start).trim();
+    for (const candidate of candidates) {
+        try {
+            parseJsonObjectCandidate(candidate);
+            return candidate;
+        }
+        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) {
@@ -192,6 +220,54 @@ export function parseJsonObjectCandidate(candidate) {
         throw new Error("Agent emitted malformed report JSON");
     }
 }
+/**
+ * Why this run could not decide an acceptance criterion.
+ *
+ * `unknown` alone tells the owner a check did not happen, not whether asking again could change
+ * that. Only `not_attempted` is recoverable by a rework; the rest describe something this work
+ * package can never reach, so returning the delivery spends a review budget and comes back the
+ * same. The runner is the only place this is knowable: it finds out by hitting the wall.
+ *
+ * Keep this list equal to `UNVERIFIED_REASONS` in src/conductor/delivery.ts. The two packages
+ * cannot share code, and "unverified reason agreement" holds them equal.
+ */
+export const UNVERIFIED_REASONS = [
+    "not_attempted",
+    "needs_authority",
+    "needs_environment",
+    "needs_third_party",
+    "needs_human_judgment"
+];
+/**
+ * The identity of an acceptance criterion.
+ *
+ * The contract holds criteria as prose. The Planner model writes that prose and the agent model
+ * reports it back, and a model rewrites typographic punctuation while it retypes. Initiative
+ * efa56ccd wrote "non-main" with U+2011 NON-BREAKING HYPHEN, the agent reported an ASCII hyphen,
+ * and Conduit discarded a completed delivery. NFKC alone does not prevent this: it folds U+2011 to
+ * U+2010, which is also not ASCII. Thus this function folds the dash and quote families itself.
+ *
+ * Keep this function equal to `criterionKey` in src/conductor/delivery.ts. The two packages cannot
+ * share code, so the test "acceptance criterion identity agreement" holds them equal.
+ * Write the classes as escapes. These characters are invisible or look the same in an editor.
+ */
+export function criterionKey(value) {
+    return value
+        .normalize("NFKC")
+        .replace(/[\u00AD\u200B-\u200D\uFEFF]/g, "")
+        .replace(/[\u2010-\u2015\u2212\uFE58\uFE63\uFF0D]/g, "-")
+        .replace(/[\u2018\u2019\u201A\u201B\u2032]/g, "'")
+        .replace(/[\u201C\u201D\u201E\u201F\u2033]/g, '"')
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/[.\u3002]+$/, "")
+        .toLowerCase();
+}
+/** 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, " ");
+    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;
@@ -209,7 +285,7 @@ export function parseAgentReport(text, acceptance) {
         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"]) })).max(100),
+        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,
@@ -223,11 +299,48 @@ 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 reported = parsed.data.acceptance_results.map((item) => item.criterion);
-    if (new Set(reported).size !== reported.length || acceptance.some((criterion) => !reported.includes(criterion))) {
-        throw new Error("Agent report must include every acceptance criterion exactly once");
+    const reportedKeys = parsed.data.acceptance_results.map((item) => criterionKey(item.criterion));
+    const duplicated = parsed.data.acceptance_results
+        .filter((item, index) => reportedKeys.indexOf(criterionKey(item.criterion)) !== index)
+        .map((item) => item.criterion);
+    const missing = acceptance.filter((criterion) => !reportedKeys.includes(criterionKey(criterion)));
+    if (missing.length || duplicated.length) {
+        // Name the criterion. This text becomes the failure detail and the Conductor repair brief, and
+        // "one of them is wrong" gives the next run nothing to act on.
+        const detail = [
+            missing.length ? `missing: ${missing.map(quoteCriterion).join("; ")}` : "",
+            duplicated.length ? `reported more than once: ${duplicated.map(quoteCriterion).join("; ")}` : "",
+        ].filter(Boolean).join(" | ");
+        throw new Error(`Agent report must include every acceptance criterion exactly once (${detail})`);
     }
-    return { ...parsed.data, acceptance_results: parsed.data.acceptance_results.map((item) => ({ ...item, evidence_artifact_ids: [] })) };
+    // 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)));
+    return {
+        ...parsed.data,
+        acceptance_results: parsed.data.acceptance_results.map((item) => {
+            const { unverified_reason: reported, unverified_detail: detail, ...rest } = item;
+            const status = item.status === "met" && !mappedCriteria.has(criterionKey(item.criterion))
+                ? "unknown"
+                : item.status;
+            return {
+                ...rest,
+                status,
+                // An undecided criterion must say why. A missing reason reads as `not_attempted` — the
+                // recoverable case — rather than failing the report: the implementation is finished by
+                // this point, and a delivery is not worth discarding over one absent field. A decided
+                // criterion carries no reason at all, so the packet holds no key that means nothing.
+                ...(status === "unknown"
+                    ? {
+                        unverified_reason: reported ?? "not_attempted",
+                        ...(detail ? { unverified_detail: detail } : {}),
+                    }
+                    : {}),
+                evidence_artifact_ids: [],
+            };
+        }),
+    };
 }
 /**
  * Artifact publication receipts require `sha256:<64 hex>`. Agents often paste bare `shasum` output;
@@ -266,7 +379,11 @@ function sanitizeReportShape(raw) {
             const evidence = item;
             if ("details" in evidence)
                 evidence.details = cleanList(evidence.details);
-            if ("acceptance_criteria" in evidence)
+            // 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() === ""))

package/dist/ensure-pull-request.js

@@ -9,6 +9,24 @@ import { normalizeRepositoryUrl } from "./brief.js";
 const execFileAsync = promisify(execFile);
 /** Mirror execution.ts FORGE_TRANSPORT_PATTERN — keep local to avoid import cycles. */
 const FORGE_TRANSPORT_PATTERN = /unable to access '?https?:\/\/|error in the http2 framing layer|could not resolve host|connection (?:reset|timed out|refused)|\bcurl\b.*\b(?:52|55|56|92)\b|remote end hung up unexpectedly|\brpc failed\b|tls handshake|network is unreachable|operation timed out/i;
+/**
+ * Commits the attempt branch has and the base does not.
+ * Returns null when this checkout does not know the base. An unverifiable precondition must not
+ * stop a delivery that can be correct.
+ */
+export async function commitsAheadOfBase(workspace, base) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", workspace, "rev-list", "--count", `${base}..HEAD`], {
+            timeout: 30_000,
+            maxBuffer: 1_000_000,
+        });
+        const count = Number(stdout.trim());
+        return Number.isFinite(count) ? count : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function needsPullRequest(report, spec, grants) {
     return Boolean(grants.includes("pr_create")
         && (spec.change_scope?.length ?? 0) > 0
@@ -160,6 +178,7 @@ export async function pushOriginHead(workspace, options = {}) {
 export async function ensureDeliveryPullRequest(input) {
     const readHead = input.readHeadCommit ?? workspaceHeadCommit;
     const push = input.pushOriginHead ?? pushOriginHead;
+    const countAhead = input.countCommitsAhead ?? commitsAheadOfBase;
     let report = adoptPullRequestUrlFromEvidence(input.report, input.repositoryFingerprint);
     if ((input.spec.change_scope?.length ?? 0) > 0) {
         const head = await readHead(input.workspace);
@@ -170,6 +189,17 @@ export async function ensureDeliveryPullRequest(input) {
     }
     if (!needsPullRequest(report, input.spec, input.grants))
         return report;
+    // A briefed report-only repair commits nothing, because its brief tells it not to touch source
+    // files. GitHub then answers the pull-request call with an opaque 422 "No commits between main
+    // and <branch>" (initiative efa56ccd, attempt 874fa0e3). Prove the branch carries work first, and
+    // report the real condition instead of a forge validation error.
+    const base = input.spec.repository?.base_commit;
+    if (base) {
+        const ahead = await countAhead(input.workspace, base);
+        if (ahead === 0) {
+            throw new Error(`The attempt branch has no commit after base ${base.slice(0, 12)}; this run produced no change to deliver`);
+        }
+    }
     await push(input.workspace);
     const headAfterPush = await readHead(input.workspace);
     if (!report.head_commit || !commitsMatch(report.head_commit, headAfterPush)) {

package/dist/execution.js

@@ -912,7 +912,29 @@ async function runClaimedAssignment(client, config, driver, workspace, brief, ta
                 catch (repairError) {
                     parseError = repairError instanceof Error ? repairError.message : "Repaired delivery report was invalid";
                     if (repairTurn >= maxRepairs) {
-                        await queueTerminal(client, taskId, { action: "fail", body: { error: `Delivery report repair exhausted: ${parseError}`, retryable: false, idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}` } });
+                        const detail = `Delivery report repair exhausted: ${parseError}`;
+                        // Implementation finished; only its response envelope is invalid. Preserve the exact
+                        // tree and identify this narrow condition so the control plane can prepare repair
+                        // guidance instead of discarding the work and asking the owner to debug JSON.
+                        retainAttemptWorktree = true;
+                        const response = await queueTerminal(client, taskId, {
+                            action: "fail",
+                            body: {
+                                error: detail,
+                                retryable: false,
+                                failure: {
+                                    code: "delivery_report_invalid",
+                                    class: "contract",
+                                    disposition: "rework",
+                                    responsible_party: "conduit",
+                                    message: "Conduit could not prepare a valid delivery report from the completed agent run.",
+                                    next_action: "Conductor will prepare bounded recovery guidance. You do not need to edit technical constraints.",
+                                    diagnostic_detail: detail,
+                                },
+                                idempotency_key: `bridge:delivery-repair-invalid:${active.attemptId}`,
+                            },
+                        });
+                        retainAttemptWorktree = retainDiagnosticWorktree(response);
                         console.error(`Assignment ${taskId} exhausted its report-only repair: ${redactSecrets(parseError)}`);
                         const replyTail = previousReply.slice(-8_000);
                         console.error(`Assignment ${taskId} repaired reply tail (${previousReply.length} chars total, redacted): ${redactSecrets(replyTail) || "<empty>"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miraland-labs/conduit-bridge",
-  "version": "0.14.5",
+  "version": "0.14.7",
   "description": "Conduit Bridge CLI — join, connect, disconnect, multi-driver lanes, and run Claude Code / Codex / Cursor / OpenCode / Pi / Kiro / Antigravity agents for a Conduit organization",
   "type": "module",
   "bin": {