@tea-agent/loop-agent 0.43.0-next.8 → 0.43.0

package/dist/executors/pi-executor.js

@@ -1023,7 +1023,74 @@ export function shouldRetryWithFallback(stderr, stdout) {
         stdout,
         timedOut: false,
     });
-    return ["quota", "rate-limit", "unavailable", "network"].includes(category);
+    return [
+        "quota",
+        "rate-limit",
+        "unavailable",
+        "upstream-unavailable",
+        "network",
+    ].includes(category);
+}
+/**
+ * Provider/transport failure text, with model-authored content excluded.
+ *
+ * The captured stdout is a JSONL session transcript: it carries assistant text,
+ * tool arguments and saved findings verbatim. Matching provider vocabulary
+ * against that whole stream let model content drive the verdict (smoke r28: the
+ * reviewer's own finding id `FDR-R28-UNAUTHORIZED-APP-CSS` was read as an auth
+ * failure, which is not retryable, so a completed review was reported as a node
+ * error). Only error-shaped channels may classify a transport failure:
+ * stderr, error events, and the error fields of a message record.
+ */
+export function extractProviderFailureText(stdout) {
+    const parts = [];
+    for (const rawLine of stdout.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (!line.startsWith("{")) {
+            // Non-JSON child output (warnings, CLI errors) is not model-authored.
+            parts.push(line);
+            continue;
+        }
+        let record;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isRecord(parsed))
+                continue;
+            record = parsed;
+        }
+        catch {
+            // An unparseable line may be truncated model content: skip it.
+            continue;
+        }
+        const type = typeof record.type === "string" ? record.type : "";
+        const isErrorEvent = type === "error" || type === "agent_error" || type.endsWith("_error");
+        const errorMessage = typeof record.errorMessage === "string" ? record.errorMessage : "";
+        const errorField = record.error;
+        const message = isRecord(record.message) ? record.message : undefined;
+        const messageErrorMessage = typeof message?.errorMessage === "string" ? message.errorMessage : "";
+        const messageErrored = message?.stopReason === "error";
+        if (!isErrorEvent &&
+            !errorMessage &&
+            errorField === undefined &&
+            !messageErrorMessage) {
+            continue;
+        }
+        parts.push([type, errorMessage, messageErrorMessage, messageErrored ? "stopReason error" : ""]
+            .filter(Boolean)
+            .join(" "));
+        if (typeof errorField === "string") {
+            parts.push(errorField);
+        }
+        else if (isRecord(errorField)) {
+            parts.push(["message", "errorMessage", "reason", "code", "status", "type"]
+                .map((key) => (errorField[key] === undefined ? "" : String(errorField[key])))
+                .filter(Boolean)
+                .join(" "));
+        }
+    }
+    return parts.join("\n");
 }
 export function classifyPiFailure(input) {
     if (input.exitCode === 0 && input.assistantText.trim())
@@ -1034,7 +1101,9 @@ export function classifyPiFailure(input) {
         return "timeout";
     if (input.outputTooLarge)
         return "output-too-large";
-    const combined = `${input.stderr}\n${input.stdout}`.toLowerCase();
+    // Provider/transport verdicts read error-shaped channels only; the raw stdout
+    // stream embeds assistant text, tool arguments and findings verbatim.
+    const combined = `${input.stderr}\n${extractProviderFailureText(input.stdout)}`.toLowerCase();
     // Context overflow (400 request-too-large / context window exceeded).
     // Must be detected BEFORE the generic rate-limit/quota phrases: an overflow
     // error often contains "too many tokens" / "maximum context" which would
@@ -1052,8 +1121,21 @@ export function classifyPiFailure(input) {
         return "rate-limit";
     if (/quota|usage limit|reached[^\n.]{0,60}limit|5\s*小时|5小时|insufficient_quota|billing/.test(combined))
         return "quota";
-    if (/\bunauthorized\b|\bhttp\s*40[13]\b|invalid api key|authentication (?:failed|required|error)|auth(?:entication)? failed/.test(combined))
+    // Error words must stand alone: the captured stream also contains
+    // model-authored identifiers, and smoke r28 lost a whole run because the
+    // reviewer's own finding id `FDR-R28-UNAUTHORIZED-APP-CSS` matched a bare
+    // `\bunauthorized\b`, turning a retryable empty-output into a terminal
+    // `auth`. Identifier delimiters (`-`/`_`/alphanumerics) disqualify a match.
+    if (/(?<![\w-])unauthorized(?![\w-])|\bhttp\s*40[13]\b|invalid api key|(?<![\w-])authentication (?:failed|required|error)(?![\w-])|(?<![\w-])auth(?:entication)? failed(?![\w-])/.test(combined))
         return "auth";
+    // Gateway reachability first: a 502/503 body means the provider was
+    // unreachable, not that the request lacked a capability. Reporting the
+    // generic category here previously let an upstream outage surface as the
+    // plan ladder's `unsupported-provider-capability`, which reads as a model
+    // capability mismatch and sent the incident diagnosis in the wrong
+    // direction (2026-09-11).
+    if (/\bhttp\s*50[23]\b|(?:^|\D)50[23](?:\D|$)|service temporarily unavailable|bad gateway|upstream (?:is )?(?:unavailable|down|unreachable)|网关(?:暂时)?不可用/.test(combined))
+        return "upstream-unavailable";
     if (/unknown provider|unknown model|(?:provider|model|service|gateway)\s+(?:is\s+)?unavailable|overloaded|at capacity|temporarily unavailable/.test(combined))
         return "unavailable";
     if (/network\s*(?:error|failure|issue|timeout|unreachable|reset|abort)|networkerror|connection (?:reset|error|refused|closed|timed\s*out)|request timed out|socket hang up|econn\w*|etimedout|fetch failed|dns (?:error|failure|lookup failed)/.test(combined))

package/dist/executors/pi-sdk-executor.js

@@ -322,6 +322,21 @@ async function createSdkSession(sdk, input, shared) {
         extensionToolExtras.push(...computeExtensionToolAllowlistExtras([{ name: SIFT_RETRIEVE_TOOL_NAME }], input.toolNames));
     }
     const sessionToolNames = [...input.toolNames, ...extensionToolExtras];
+    // Pre-session protocol self-check: createAgentSession silently drops a
+    // custom tool whose name is absent from this allowlist (the post-create
+    // mismatch check cannot see the omission either — expected and actual are
+    // both false). The model would then be prompted to call tools that do not
+    // exist and burn attempts discovering it (smoke r10/r14 class of failure),
+    // so fail before any model call, naming the dropped tools.
+    if (input.requireAllowlistedCustomTools && Array.isArray(input.customTools) && input.customTools.length > 0) {
+        const allowlist = new Set(sessionToolNames);
+        const dropped = input.customTools
+            .map((tool) => (isRecord(tool) && typeof tool.name === "string" ? tool.name : undefined))
+            .filter((name) => typeof name === "string" && !allowlist.has(name));
+        if (dropped.length > 0) {
+            throw new Error(`pi session custom tools would be silently dropped (absent from the activation allowlist): ${dropped.join(", ")}; allowlist: [${sessionToolNames.join(", ")}]`);
+        }
+    }
     if (input.requireWriterCustomTools) {
         if (!Array.isArray(input.customTools) || input.customTools.length === 0) {
             throw new Error("pi writer tool policy missing customTools; refusing to create uncontrolled writer session");
@@ -707,6 +722,9 @@ async function executeSingleSdkAttemptInternal(options) {
                 ? { customTools: writerCustomTools }
                 : {}),
             ...(requireWriterCustomTools ? { requireWriterCustomTools: true } : {}),
+            ...(options.writerToolPolicy?.requireAllowlistedCustomTools
+                ? { requireAllowlistedCustomTools: true }
+                : {}),
             ...(options.piExtensionPaths && options.piExtensionPaths.length > 0
                 ? { additionalExtensionPaths: options.piExtensionPaths }
                 : {}),

package/dist/executors/shell-executor.js

@@ -470,6 +470,54 @@ function parseCheckRepoSubcheckDurations(result) {
     }
     return durations;
 }
+/**
+ * Frozen-command evidence for the review node: which commandId/label/lane each
+ * executed command belongs to, its exit status, and the lint lane's status
+ * (explicitly `not-configured` when the task declares no lint commands).
+ *
+ * The review protocol requires exit evidence ("typecheck, build, and test are
+ * required successful final exits") while the verification trace only proves
+ * command/file/target binding, so this artifact is what makes that requirement
+ * satisfiable at all (smoke r31: the reviewer had to request changes for a
+ * check no context could support).
+ */
+export function buildFrontendVerificationEvidence(input) {
+    const directory = buildFrontendVerifyCommandDirectory({
+        staticLabels: input.bundle.staticEvidence?.commandLabels ?? [],
+        staticCommandTexts: input.bundle.staticEvidence?.commandTexts ?? [],
+        behaviorLabels: input.bundle.behaviorEvidence?.commandLabels ?? [],
+        behaviorCommandTexts: input.bundle.behaviorEvidence?.commandTexts ?? [],
+        mockLabels: input.bundle.mockEvidence?.commandLabels ?? [],
+        mockCommandTexts: input.bundle.mockEvidence?.commandTexts ?? [],
+        lintLabels: input.bundle.lintEvidence?.commandLabels ?? [],
+        lintCommandTexts: input.bundle.lintEvidence?.commandTexts ?? [],
+    });
+    const entryByCommand = new Map(directory.map((entry) => [entry.command.trim(), entry]));
+    return {
+        schemaVersion: 1,
+        schemaId: "frontend-verification-evidence-v1",
+        nodeId: input.nodeId,
+        runId: input.runId,
+        capturedAt: new Date().toISOString(),
+        allPassed: input.results.every((result) => result.ok),
+        lintStatus: input.lintStatus,
+        lintConfigured: input.lintConfigured,
+        commands: input.results.map((result, index) => {
+            const entry = entryByCommand.get(result.command.trim());
+            return {
+                index: index + 1,
+                commandId: entry?.commandId ?? null,
+                label: entry?.label ?? null,
+                lane: entry?.lane ?? null,
+                command: result.command,
+                ok: result.ok,
+                exitCode: result.exitCode,
+                failureCategory: result.failureCategory,
+                reused: result.reused === true,
+            };
+        }),
+    };
+}
 export function buildShellResultSummaryMarkdown(input) {
     const lines = [
         "# Shell execution summary",
@@ -1915,7 +1963,7 @@ async function executePipelineCommands(input, meta, overrideCommands) {
  * of inventing refs. */
 async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandIds) {
     try {
-        const { restorePlanPatchFromCommittedFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
+        const { restorePlanPatchFromCommittedFacts } = await import("../workflows/dag/frontend-implementation-contract.js");
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, "frontend-plan-pi", "plan-typed-facts.jsonl"));
         const patch = restorePlanPatchFromCommittedFacts(records);
         const targets = patch
@@ -2127,6 +2175,27 @@ async function executeFrontendVerificationBundle(input, meta) {
         command: result.command,
         reused: result.reused === true,
     }));
+    // Auditable per-command evidence for the review node (smoke r31): the review
+    // protocol treats shell exit status as authoritative, but the review context
+    // only carried the verification trace's command/file/target *binding*
+    // status, so a reviewer could not confirm the frozen commands actually
+    // exited 0 and had to request changes for missing evidence. Written before
+    // either the failure or the success path returns.
+    const lintConfigured = (bundle.lintCommands?.length ?? 0) > 0;
+    await writeDagRunJsonArtifact(meta.runDir, "contracts/frontend-verification-evidence.json", buildFrontendVerificationEvidence({
+        nodeId: input.task.id,
+        runId: meta.runId,
+        bundle,
+        results,
+        // The review protocol's lint vocabulary is
+        // passed | baseline-debt | failed | unavailable; a task that declares
+        // no lint commands reports `unavailable` plus lintConfigured:false
+        // rather than inventing a value outside that catalog (smoke r33).
+        lintStatus: lintConfigured
+            ? (lintAssessment?.status ?? "unavailable")
+            : "unavailable",
+        lintConfigured,
+    }));
     // Lint baseline-debt is tolerated, so a lint-only failure must not become the
     // verification failure. A shared lint/static or lint/behavior command is
     // different: once reused by a non-lint lane, its failure belongs to that lane
@@ -2320,16 +2389,22 @@ async function readRunDirJson(runDir, relativePath) {
 }
 /** Committed typed review terminal kinds from the review node's typed event
  * store (AC-003: typed terminal tools are the only authoritative verdict). */
-async function collectReviewTerminalKinds(runDir, reviewNodeId) {
+export async function collectReviewTerminalKinds(runDir, reviewNodeId) {
     try {
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, reviewNodeId, "review-typed-facts.jsonl"));
+        // The store also holds findings and scope checkpoints; only the verdict
+        // kinds decide "missing or ambiguous" (fail closed on 0 or 2+).
+        const terminalKinds = new Set([
+            "approve_review",
+            "request_review_changes",
+        ]);
         return records
             .filter((record) => record.phase === "committed")
             .map((record) => {
             const kind = record.fact.kind;
             return typeof kind === "string" ? kind : "";
         })
-            .filter(Boolean);
+            .filter((kind) => terminalKinds.has(kind));
     }
     catch {
         return [];
@@ -2339,16 +2414,24 @@ async function collectReviewTerminalKinds(runDir, reviewNodeId) {
  * event store (M8: the committed approve_design / request_design_changes fact
  * is the only authoritative verdict; the legacy first-line VERDICT text is
  * never read for writer admission). Fail-closed on a missing/unreadable store. */
-async function collectDesignTerminalKinds(runDir, designNodeId) {
+export async function collectDesignTerminalKinds(runDir, designNodeId) {
     try {
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, designNodeId, "design-typed-facts.jsonl"));
+        // The store also holds findings and scope checkpoints; only the verdict
+        // kinds decide "missing or ambiguous" (fail closed on 0 or 2+). Without
+        // this filter any recorded finding makes admission read the committed
+        // verdict as ambiguous and blocks the writer (r11 decision-path smoke).
+        const terminalKinds = new Set([
+            "approve_design",
+            "request_design_changes",
+        ]);
         return records
             .filter((record) => record.phase === "committed")
             .map((record) => {
             const kind = record.fact.kind;
             return typeof kind === "string" ? kind : "";
         })
-            .filter(Boolean);
+            .filter((kind) => terminalKinds.has(kind));
     }
     catch {
         return [];
@@ -2511,7 +2594,7 @@ async function executeFrontendDesignPolicy(input, meta) {
         // M9a the plan node's assistantText is a pure Markdown narrative; the
         // compile authority is the committed plan ledger ⊕ runtime skeleton.
         // Fail closed on missing committed facts — never fall back to text.
-        const { readCommittedOriginFacts, checkCommittedOriginFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
+        const { readCommittedOriginFacts, checkCommittedOriginFacts } = await import("../workflows/dag/frontend-committed-facts.js");
         // A+B (AC-001/003): fail-closed committed contract/scout typed facts.
         // Missing/uncommitted facts block here; never fall back to text parsing.
         const committedContractFacts = await readCommittedOriginFacts(meta.runDir, "frontend-contract-pi", "contract-typed-facts.jsonl");
@@ -2630,7 +2713,7 @@ async function executeFrontendDesignPolicy(input, meta) {
             });
         }
         // Byte freshness is necessary but not sufficient: require the same ledger
-        // semantic checks as the shadow prewrite gate before production writer
+        // semantic checks as the canonical admission policy before production writer
         // admission can be materialized.
         if (meta.spec.sourceBinding) {
             const ledgerCheck = await checkFrontendSourceFidelityLedger({
@@ -2974,6 +3057,7 @@ async function executeFrontendCloseout(input, meta) {
         const contract = frontendImplementationContractSchema.parse(JSON.parse(contractRaw));
         const trace = context.verificationTrace;
         const verificationTargets = (trace?.targets ?? []).map((target) => ({
+            mode: contract.verificationTargets.find((entry) => entry.id === target.id)?.mode ?? "static",
             status: target.status === "ok" ? "ok" : "failed",
         }));
         const mockEvidenceBound = contract.mockApi.strategy !== "not-needed" &&
@@ -3015,6 +3099,8 @@ async function executeFrontendCloseout(input, meta) {
             coverageMatrix: verificationTargets.map((target, index) => ({
                 verificationTargetId: trace?.targets?.[index]?.id ?? `vt-${index}`,
                 status: target.status === "ok" ? "passed" : "failed",
+                evidence: trace?.targets?.[index]?.evidence ?? "unavailable",
+                behaviorCoverage: "unconfirmed",
             })),
             lintStatus: "unavailable",
             integrationFacts,

package/dist/executors/shell-verification.js

@@ -138,6 +138,9 @@ export function renderVerifyReport(results) {
 export async function executeCommand(command, defaultTimeoutMs = DEFAULT_VERIFY_TIMEOUT_MS) {
     return new Promise((resolve, reject) => {
         const [binary, ...args] = command.args;
+        if (binary === undefined) {
+            throw new Error("verify command requires a non-empty args array");
+        }
         const timeoutMs = command.timeoutMs ?? defaultTimeoutMs;
         const startedAt = Date.now();
         const child = spawn(binary, args, {

package/dist/executors/shell-write-guard.js

@@ -94,48 +94,43 @@ const DAG_RUNS_PREFIX = ".harness/dag-runs/";
  * They are not product evidence and must not fail exclusive write guards.
  * Intentional report/product writes remain governed by writePolicy/writeSet.
  */
-export function isEphemeralToolCachePath(filePath) {
-    const normalized = normalizePath(filePath);
-    if (!normalized)
-        return false;
+const EPHEMERAL_CACHE_DIRS = [
     // CodeGraph extension sync side effect (plan 2026-08-21 D7): a loaded
     // pi-codegraph extension keeps an existing .codegraph/ index fresh at
     // session start; those index files are extension-owned run state, not
     // writer output, so they never count as write-guard violations.
-    if (normalized === ".codegraph" || normalized.startsWith(".codegraph/")) {
-        return true;
-    }
-    if (normalized === ".pytest_cache" ||
-        normalized.startsWith(".pytest_cache/")) {
-        return true;
-    }
-    if (normalized === ".mypy_cache" || normalized.startsWith(".mypy_cache/")) {
-        return true;
-    }
-    if (normalized === ".ruff_cache" || normalized.startsWith(".ruff_cache/")) {
-        return true;
-    }
+    ".codegraph",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
     // playwright-cli default session dumps (console/page/network) under repo cwd.
     // Real browser case evidence must still be written under testcase/** explicitly.
-    if (normalized === ".playwright-cli" ||
-        normalized.startsWith(".playwright-cli/")) {
-        return true;
-    }
-    if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
-        return true;
-    }
+    ".playwright-cli",
+];
+const EPHEMERAL_CACHE_DIR_PREFIXES = [
     // vite/vitest runtime caches live under node_modules/.vite (e.g.
     // node_modules/.vite/vitest/results.json). node_modules is the gitignored
     // dependency tree — tool cache writes there are never a writer's product
     // change and must not trip the write guard.
-    if (normalized.startsWith("node_modules/.vite/")) {
-        return true;
-    }
-    if (/(?:^|\/)__pycache__(?:\/|$)/.test(normalized))
-        return true;
-    if (/\.(?:pyc|pyo)$/.test(normalized))
-        return true;
-    return false;
+    "node_modules/.vite",
+];
+const EPHEMERAL_CACHE_FILES = new Set([".coverage"]);
+const EPHEMERAL_CACHE_PATH_PATTERNS = [
+    /(?:^|\/)__pycache__(?:\/|$)/,
+    /\.(?:pyc|pyo)$/,
+];
+function isExactOrChildPath(value, names) {
+    return names.some((name) => value === name || value.startsWith(`${name}/`));
+}
+export function isEphemeralToolCachePath(filePath) {
+    const normalized = normalizePath(filePath);
+    if (!normalized)
+        return false;
+    return (isExactOrChildPath(normalized, EPHEMERAL_CACHE_DIRS) ||
+        EPHEMERAL_CACHE_DIR_PREFIXES.some((prefix) => normalized.startsWith(`${prefix}/`)) ||
+        EPHEMERAL_CACHE_FILES.has(normalized) ||
+        normalized.startsWith(".coverage.") ||
+        EPHEMERAL_CACHE_PATH_PATTERNS.some((pattern) => pattern.test(normalized)));
 }
 /** MVP post-run guard: only paths that changed during the shell node are checked. */
 export function validateShellWriteGuard(input) {

package/dist/governance/exec-plans.js

@@ -174,7 +174,7 @@ function localIndexReference(rawReference) {
         .trim()
         .replace(/^<|>$/g, "")
         .split(/[?#]/, 1)[0]
-        .replaceAll("\\", "/");
+        ?.replaceAll("\\", "/") ?? "";
     if (!normalized.endsWith(".md") || normalized.includes("/"))
         return null;
     // Naming-convention placeholders (e.g. `YYYY-MM-DD-<topic>.md`) and other
@@ -332,6 +332,8 @@ function findInsertionPointForActiveEntry(lines) {
     // trailing section (blank-line separated context), or at the end.
     for (let i = 0; i < lines.length; i += 1) {
         const line = lines[i];
+        if (line === undefined)
+            break;
         if (/^[-*]\s+已归档/.test(line))
             return i;
         if (/^[-*]\s+`[^`]+\.md`/.test(line)) {
@@ -357,7 +359,8 @@ function removeIndexEntries(indexContent, file) {
     const lines = indexContent.split(/\r?\n/);
     const filtered = lines.filter((line) => {
         const linkMatch = line.match(/\[[^\]]*\]\(([^)]+)\)/);
-        if (linkMatch && path.basename(linkMatch[1]) === file)
+        const linkTarget = linkMatch?.[1];
+        if (linkTarget !== undefined && path.basename(linkTarget) === file)
             return false;
         if (line.includes(`\`${file}\``))
             return false;
@@ -375,7 +378,7 @@ function collapseBlankRuns(lines) {
         result.push(line);
         prevBlank = isBlank;
     }
-    while (result.length > 0 && result[result.length - 1].trim() === "") {
+    while (result.length > 0 && result[result.length - 1]?.trim() === "") {
         result.pop();
     }
     return result;

package/dist/infrastructure/console/app-data.js

@@ -45,6 +45,9 @@ export function openConsoleAppData(options) {
         chats: path.join(repoNamespace, "chats"),
         chatSessions: path.join(repoNamespace, "chat-sessions"),
         chatEvents: path.join(repoNamespace, "chat-events"),
+        browserProfile: path.join(repoNamespace, "browser-profile"),
+        browserDownloads: path.join(repoNamespace, "browser-downloads"),
+        browserScreenshots: path.join(repoNamespace, "browser-screenshots"),
         resourcePreferences: path.join(repoNamespace, "resource-preferences.json"),
     };
     for (const dir of [
@@ -60,6 +63,9 @@ export function openConsoleAppData(options) {
         paths.chats,
         paths.chatSessions,
         paths.chatEvents,
+        paths.browserProfile,
+        paths.browserDownloads,
+        paths.browserScreenshots,
         path.dirname(paths.resourcePreferences),
     ]) {
         ensureSecureDir(dir);

package/dist/shared/artifacts-core.js

@@ -81,6 +81,8 @@ function isUnchangedNewTaskTemplate(step, content) {
 }
 function firstRequiredSectionIsEmpty(step, content) {
     const [, firstSectionHeading] = REQUIRED_HEADINGS[step];
+    if (!firstSectionHeading)
+        return false;
     const headingIndex = content.indexOf(firstSectionHeading);
     if (headingIndex < 0) {
         return false;

package/dist/shared/backend-dogfood-preflight.js

@@ -0,0 +1,47 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { buildControllerIdentityFromEntry, readBuildStamp } from "./package-metadata.js";
+export function sha256File(file) {
+    return `sha256:${createHash("sha256").update(readFileSync(file)).digest("hex")}`;
+}
+export function classifyBackendDogfoodProvenance(input) {
+    if (input.tarballPath)
+        return { kind: "local-tarball", version: input.identity.packageVersion, tarballSha256: sha256File(input.tarballPath) };
+    if (input.distTag)
+        return { kind: "published-npm", version: input.identity.packageVersion, distTag: input.distTag };
+    return { kind: "local-candidate", version: input.identity.packageVersion };
+}
+export function buildBackendDogfoodIdentityEvidence(input) {
+    const controller = buildControllerIdentityFromEntry({ requested: input.controllerEntry, entry: path.resolve(input.controllerEntry) });
+    if (!controller)
+        throw new Error("BACKEND_DOGFOOD_IDENTITY_UNRESOLVED");
+    const fingerprint = controller.packageFingerprint.value;
+    if (fingerprint !== input.expectedFingerprint)
+        throw new Error(`BACKEND_DOGFOOD_CONTROLLER_MISMATCH: expected ${input.expectedFingerprint}, got ${fingerprint}`);
+    const consoleIdentity = input.consoleHost
+        ? undefined
+        : buildControllerIdentityFromEntry({
+            requested: input.consoleControllerEntry ?? path.join(controller.packageRoot, "bin", "agent-worker.js"),
+            entry: input.consoleControllerEntry ?? path.join(controller.packageRoot, "bin", "agent-worker.js"),
+        });
+    if (!input.consoleHost && !consoleIdentity)
+        throw new Error("BACKEND_DOGFOOD_CONSOLE_IDENTITY_UNRESOLVED");
+    const consoleHost = {
+        packageName: String(input.consoleHost?.packageName ?? consoleIdentity?.packageName),
+        packageVersion: String(input.consoleHost?.packageVersion ?? consoleIdentity?.packageVersion),
+        packageFingerprint: String(input.consoleHost?.packageFingerprint ?? consoleIdentity?.packageFingerprint.value),
+    };
+    const expected = `${controller.packageName}@${controller.packageVersion}@${fingerprint}`;
+    const actual = `${consoleHost.packageName}@${consoleHost.packageVersion}@${consoleHost.packageFingerprint}`;
+    if (actual !== expected)
+        throw new Error(`BACKEND_DOGFOOD_CONSOLE_IDENTITY_MISMATCH: expected ${expected}, got ${actual}`);
+    return {
+        schemaVersion: 1,
+        controller,
+        provenance: classifyBackendDogfoodProvenance({ identity: controller, distTag: input.distTag, tarballPath: input.tarballPath }),
+        buildCommitSha: readBuildStamp(controller.packageRoot)?.gitSha ?? null,
+        consoleHost,
+        dagController: { packageName: controller.packageName, packageVersion: controller.packageVersion, packageFingerprint: fingerprint },
+    };
+}

package/dist/shared/dag-failure-category.js

@@ -59,6 +59,9 @@ const RAW_TO_NORMALIZED = {
     quota: "executor",
     "rate-limit": "executor",
     unavailable: "executor",
+    // Gateway reachability outage: still an executor-class failure, but named so
+    // reports do not read as a capability mismatch.
+    "upstream-unavailable": "executor",
     // Context window overflow (400 request-too-large): the session needs
     // compaction / fresh context before retrying — an executor-side
     // environment condition, not a plan-quality defect.

package/dist/shared/git-progress.js

@@ -112,6 +112,8 @@ function globToRegExp(pattern) {
     let regex = '^';
     for (let i = 0; i < normalized.length; i += 1) {
         const char = normalized[i];
+        if (char === undefined)
+            continue;
         const next = normalized[i + 1];
         if (char === '*' && next === '*') {
             const afterGlobstar = normalized[i + 2];

package/dist/shared/one-shot-prompt-args.js

@@ -8,6 +8,8 @@ export function createOneShotPromptParseAccum() {
 }
 export function parseOneShotCommonFlag(args, index, accum) {
     const arg = args[index];
+    if (arg === undefined)
+        return { kind: "not-common" };
     if (arg === "--stdin") {
         accum.fromStdin = true;
         return { kind: "consumed", nextIndex: index };