@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/workflows/dag/artifact-bindings.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { canonicalSha256 } from "../../shared/context-transfer.js";
+export function buildArtifactBindingGraph(spec) {
+    const consumers = new Map();
+    for (const task of spec.tasks) {
+        for (const binding of task.consumesArtifacts ?? []) {
+            const nodeIds = consumers.get(binding.artifactId) ?? [];
+            nodeIds.push(task.id);
+            consumers.set(binding.artifactId, nodeIds);
+        }
+    }
+    const artifacts = spec.tasks
+        .flatMap((task) => (task.producesArtifacts ?? []).map((artifact) => ({
+        ...artifact,
+        producerNodeId: task.id,
+        directConsumerNodeIds: [...(consumers.get(artifact.artifactId) ?? [])].sort(),
+    })))
+        .sort((a, b) => a.artifactId.localeCompare(b.artifactId));
+    const available = artifacts.length > 0;
+    const payload = { schemaVersion: 1, artifacts };
+    return {
+        ...payload,
+        available,
+        ...(available ? {} : { reasonCode: "ARTIFACT_BINDING_UNAVAILABLE" }),
+        artifactGraphSha256: canonicalSha256(payload),
+    };
+}
+function collectDescendants(spec, roots) {
+    const children = new Map();
+    for (const task of spec.tasks) {
+        for (const parent of task.depends_on) {
+            const values = children.get(parent) ?? [];
+            values.push(task.id);
+            children.set(parent, values);
+        }
+    }
+    const queue = [...roots];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const nodeId = queue.shift();
+        if (seen.has(nodeId))
+            continue;
+        seen.add(nodeId);
+        queue.push(...(children.get(nodeId) ?? []));
+    }
+    return spec.tasks.map((task) => task.id).filter((nodeId) => seen.has(nodeId));
+}
+export function computeArtifactImpact(spec, artifactId) {
+    const graph = buildArtifactBindingGraph(spec);
+    const artifact = graph.artifacts.find((entry) => entry.artifactId === artifactId);
+    if (!artifact || artifact.directConsumerNodeIds.length === 0)
+        return undefined;
+    const affectedNodeIds = collectDescendants(spec, artifact.directConsumerNodeIds);
+    const affectedSet = new Set(affectedNodeIds);
+    const importedNodeIds = spec.tasks
+        .map((task) => task.id)
+        .filter((nodeId) => !affectedSet.has(nodeId));
+    return {
+        artifactId,
+        producerNodeId: artifact.producerNodeId,
+        directConsumerNodeIds: artifact.directConsumerNodeIds,
+        effectiveFromNodeId: affectedNodeIds[0],
+        affectedNodeIds,
+        importedNodeIds,
+    };
+}
+function runtimeArtifactFields(node, kind) {
+    if (kind === "structured") {
+        return {
+            path: node.structuredArtifactPath,
+            sha256: node.structuredArtifactSha256,
+            schemaId: node.structuredArtifactSchemaId,
+        };
+    }
+    if (kind === "assistant") {
+        return { path: node.assistantArtifactPath, sha256: node.assistantSha256 };
+    }
+    return { path: node.stdoutArtifactPath, sha256: node.stdoutSha256 };
+}
+export async function materializeDeclaredArtifactFacts(input) {
+    const facts = [];
+    for (const declaration of input.task.producesArtifacts ?? []) {
+        const runtime = runtimeArtifactFields(input.node, declaration.kind);
+        const base = { ...declaration, revisionEligible: false };
+        if (!runtime.path || !runtime.sha256) {
+            facts.push({
+                ...base,
+                status: "missing",
+                reasonCode: "ARTIFACT_NOT_MATERIALIZED",
+            });
+            continue;
+        }
+        const relativePath = path
+            .relative(input.runDir, runtime.path)
+            .split(path.sep)
+            .join("/");
+        if (relativePath !== declaration.path) {
+            facts.push({
+                ...base,
+                status: "mismatch",
+                sha256: runtime.sha256,
+                reasonCode: "ARTIFACT_PATH_MISMATCH",
+            });
+            continue;
+        }
+        if (declaration.schemaId !== runtime.schemaId) {
+            facts.push({
+                ...base,
+                status: "mismatch",
+                sha256: runtime.sha256,
+                reasonCode: "ARTIFACT_SCHEMA_MISMATCH",
+            });
+            continue;
+        }
+        let bytes;
+        try {
+            bytes = await readFile(runtime.path);
+        }
+        catch {
+            facts.push({
+                ...base,
+                status: "missing",
+                reasonCode: "ARTIFACT_NOT_MATERIALIZED",
+            });
+            continue;
+        }
+        const actualSha256 = createHash("sha256").update(bytes).digest("hex");
+        if (actualSha256 !== runtime.sha256) {
+            facts.push({
+                ...base,
+                status: "mismatch",
+                sha256: actualSha256,
+                bytes: bytes.byteLength,
+                reasonCode: "ARTIFACT_HASH_MISMATCH",
+            });
+            continue;
+        }
+        facts.push({
+            ...base,
+            status: "materialized",
+            sha256: actualSha256,
+            bytes: bytes.byteLength,
+            revisionEligible: declaration.revisionPolicy === "replace-file",
+        });
+    }
+    return facts;
+}

package/dist/workflows/dag/artifact-revision-schema-registry.js

@@ -0,0 +1,31 @@
+import { backendPytestCollectionFactsSchema, backendTestExecutionReadinessSchema } from "./backend-test-pytest-collection.js";
+import { backendTestCaseManifestSchema } from "./backend-test-case-manifest.js";
+import { backendTestAnalysisContractSchema } from "./backend-test-analysis-contract.js";
+import { backendTestExecutionContractSchema } from "./backend-test-execution-contract.js";
+import { backendTestCaseCoverageFactsSchema } from "./backend-test-case-coverage-analysis.js";
+import { frontendImplementationContractSchema } from "./frontend-implementation-contract.js";
+/**
+ * Standalone artifact revision schema registry (exec-plan
+ * 2026-08-25-console-node-context-artifact-rerun W4.3 / M4 exit criteria).
+ *
+ * Maps a frozen produced-artifact `schemaId` to a deterministic zod validator
+ * that can check candidate revision bytes without run context. Declared
+ * schemaIds without an entry here are rejected fail-closed with
+ * ARTIFACT_REVISION_SCHEMA_INVALID — an artifact cannot be staged until its
+ * schema is registered. Never guessed, never silently passed.
+ */
+const ARTIFACT_REVISION_SCHEMAS = Object.freeze({
+    "backend-test-pytest-collection-v3": backendPytestCollectionFactsSchema,
+    "backend-test-execution-readiness-v2": backendTestExecutionReadinessSchema,
+    "backend-test-case-manifest-v1": backendTestCaseManifestSchema,
+    "backend-test-analysis-v2": backendTestAnalysisContractSchema,
+    "backend-test-execution-v1": backendTestExecutionContractSchema,
+    "backend-test-case-coverage-facts-v4": backendTestCaseCoverageFactsSchema,
+    "frontend-implementation-contract-v1": frontendImplementationContractSchema,
+});
+export function resolveArtifactRevisionSchema(schemaId) {
+    return ARTIFACT_REVISION_SCHEMAS[schemaId];
+}
+export function listArtifactRevisionSchemaIds() {
+    return Object.keys(ARTIFACT_REVISION_SCHEMAS).sort();
+}

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -668,6 +668,92 @@ function automationLabelBody(body, labels) {
     const match = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:]\\s*(.*)$`, "mi").exec(automation);
     return match?.[1]?.replaceAll("`", "").trim() ?? "";
 }
+const BINDING_NEGATION_OR_AMBIGUITY = /(?:不是|并非|非变体|非断言|非横切|可能|待定|或者|\b(?:TBD|unknown)\b)/i;
+function explicitBindingModeFromLine(line) {
+    if (BINDING_NEGATION_OR_AMBIGUITY.test(line))
+        return undefined;
+    const modes = TEST_POINT_BINDING_MODES.filter((mode) => AUTOMATION_BINDING_LABELS[mode].some((label) => line.includes(label)));
+    return modes.length === 1 ? modes[0] : undefined;
+}
+/**
+ * Canonicalize only explicit, unambiguous Test Point classification marks.
+ * The model occasionally writes `TP-X（变体测试点）`, `[场景断言测试点] TP-X`
+ * or a pipe-delimited equivalent. Those forms carry deterministic semantics,
+ * but are not the machine contract consumed by automationLabelBody(). Keep the
+ * original prose and materialize the same binding under `### 自动化映射` as the
+ * canonical single-line labels. Never infer a mode from ordinary prose.
+ */
+export function canonicalizeBackendTestMarkdownTestPointBindings(markdown) {
+    const headings = [...markdown.matchAll(CASE_HEADING)];
+    let output = "";
+    let cursor = 0;
+    const unsafeTestPoints = [];
+    const canonicalizedTestPoints = [];
+    for (let index = 0; index < headings.length; index += 1) {
+        const heading = headings[index];
+        const start = heading.index;
+        const end = headings[index + 1]?.index ?? markdown.length;
+        const body = markdown.slice(start, end);
+        output += markdown.slice(cursor, start);
+        cursor = end;
+        const declared = listTokens(body, CASE_SECTION_ALIASES.testPoints, TEST_POINT);
+        const current = testPointBindingFacts(body, declared);
+        const currentByMode = new Map(TEST_POINT_BINDING_MODES.map((mode) => [
+            mode,
+            current.testPointBindings.filter((item) => item.mode === mode).map((item) => item.testPoint),
+        ]));
+        const unresolved = new Set(current.unclassifiedTestPoints);
+        for (const line of body.split(/\r?\n/)) {
+            const mode = explicitBindingModeFromLine(line);
+            if (!mode)
+                continue;
+            const tokens = orderedUnique(line.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
+            for (const token of tokens) {
+                if (!unresolved.has(token))
+                    continue;
+                const existingModes = TEST_POINT_BINDING_MODES.filter((candidate) => (currentByMode.get(candidate) ?? []).includes(token));
+                if (existingModes.length > 0)
+                    continue;
+                currentByMode.set(mode, orderedUnique([...(currentByMode.get(mode) ?? []), token]));
+                unresolved.delete(token);
+                canonicalizedTestPoints.push(token);
+            }
+        }
+        unsafeTestPoints.push(...unresolved);
+        if (unresolved.size === current.unclassifiedTestPoints.length) {
+            output += body;
+            continue;
+        }
+        const automationMarker = /^###\s+(?:自动化映射|Automation Mapping)\s*$/mi.exec(body);
+        if (!automationMarker) {
+            output += body;
+            continue;
+        }
+        const automationStart = automationMarker.index + automationMarker[0].length;
+        const rest = body.slice(automationStart);
+        const nextSection = /^###\s+/m.exec(rest);
+        const automationEnd = automationStart + (nextSection?.index ?? rest.length);
+        let automation = body.slice(automationStart, automationEnd);
+        for (const mode of TEST_POINT_BINDING_MODES) {
+            const labels = AUTOMATION_BINDING_LABELS[mode];
+            const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+            const canonicalLine = `- ${AUTOMATION_BINDING_LABELS[mode][0]}：${(currentByMode.get(mode) ?? []).join("; ") || "无"}`;
+            const linePattern = new RegExp(`^\\s*[-*+]\\s*(?:${escaped})\\s*[：:].*$`, "mi");
+            if (linePattern.test(automation))
+                automation = automation.replace(linePattern, canonicalLine);
+            else
+                automation = `${automation.replace(/\s*$/, "")}\n${canonicalLine}\n`;
+        }
+        output += body.slice(0, automationStart) + automation + body.slice(automationEnd);
+    }
+    output += markdown.slice(cursor);
+    return {
+        markdown: output,
+        changed: output !== markdown,
+        unsafeTestPoints: orderedUnique(unsafeTestPoints),
+        canonicalizedTestPoints: orderedUnique(canonicalizedTestPoints),
+    };
+}
 export function inspectBackendTestMarkdownTestPointBindings(markdown) {
     const headings = [...markdown.matchAll(CASE_HEADING)];
     return headings.map((heading, index) => {
@@ -1312,8 +1398,16 @@ export async function analyzeBackendTestCaseCoverage(input) {
 function normalizeModuleStem(markdownPath) {
     return path.posix.basename(markdownPath).replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
-function expectedScript(markdownPath, layout) {
+function expectedScript(markdownPath, layout, declaredScripts = []) {
     const resolved = layout ?? resolveBackendTestLayout(undefined);
+    if (declaredScripts.length === 1) {
+        const candidate = declaredScripts[0].replaceAll("\\", "/").replace(/^\.\//, "");
+        const prefix = resolved.scriptDir === "." ? "" : `${resolved.scriptDir}/`;
+        const relative = prefix && candidate.startsWith(prefix) ? candidate.slice(prefix.length) : candidate;
+        if ((!prefix || candidate.startsWith(prefix)) && !relative.includes("..") && /^test_[A-Za-z0-9_.-]+\.py$/.test(path.posix.basename(candidate))) {
+            return candidate;
+        }
+    }
     return `${resolved.scriptDir}/test_${normalizeModuleStem(markdownPath)}.py`;
 }
 function symbolCaseId(symbol) {
@@ -1863,7 +1957,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const layout = input.layout ?? resolveBackendTestLayout(undefined);
     const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     const modulePaths = orderedUnique(cases.map((item) => item.markdownPath));
-    const scripts = orderedUnique(cases.flatMap((item) => [...item.declaredScripts, expectedScript(item.markdownPath, layout)]));
+    const scripts = orderedUnique(cases.flatMap((item) => [expectedScript(item.markdownPath, layout, item.declaredScripts)]));
     const allSymbols = [];
     const scriptFiles = [];
     for (const script of scripts) {
@@ -1876,7 +1970,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const findings = [];
     const entries = [];
     for (const testCase of cases) {
-        const expected = expectedScript(testCase.markdownPath, layout);
+        const expected = expectedScript(testCase.markdownPath, layout, testCase.declaredScripts);
         const declared = testCase.declaredScripts[0];
         const refs = allSymbols.filter((item) => item.caseIds.includes(testCase.caseId));
         const actualScripts = orderedUnique(refs.map((item) => item.script));
@@ -2034,8 +2128,9 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     for (const [signature, owners] of duplicateSignatureGroups)
         findings.push(`duplicate execution signature ${signature}: ${orderedUnique(owners).join(", ")}`);
     const exactModuleCount = modulePaths.filter((modulePath) => {
-        const expected = expectedScript(modulePath, layout);
         const moduleCases = cases.filter((item) => item.markdownPath === modulePath);
+        const moduleDeclaredScripts = orderedUnique(moduleCases.flatMap((item) => item.declaredScripts));
+        const expected = expectedScript(modulePath, layout, moduleDeclaredScripts);
         return moduleCases.every((item) => item.declaredScripts.length === 1 && item.declaredScripts[0] === expected) && scriptFiles.some((file) => path.relative(input.workspaceRoot, file).replaceAll(path.sep, "/") === expected);
     }).length;
     const caseEntries = entries.filter((entry) => entry.cardinality !== "0:1");

package/dist/workflows/dag/backend-test-markdown-workflow.js

@@ -285,6 +285,7 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         moduleIndexHeadingCount,
         declaredStems: [],
         declaredMdFiles: [],
+        declaredScriptByMarkdown: {},
         declaredMissing: [],
         unmanifested: [],
     });
@@ -306,6 +307,15 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         return invalid("duplicate", moduleIndexHeadingCount);
     }
     const declaredStems = extractDeclaredModuleIndexFilenames(readme);
+    const declaredScriptByMarkdown = {};
+    const mdPrefix = escapeRegExp(`${resolved.markdownDir}/`);
+    const scriptPrefix = escapeRegExp(`${resolved.scriptDir}/`);
+    for (const line of readme.split(/\r?\n/)) {
+        const markdown = new RegExp(`(${mdPrefix}[A-Za-z0-9_.-]+\\.md)`).exec(line)?.[1];
+        const pytest = new RegExp(`(${scriptPrefix}[A-Za-z0-9_./-]+\\.py)`).exec(line)?.[1];
+        if (markdown && pytest)
+            declaredScriptByMarkdown[markdown] = pytest;
+    }
     if (declaredStems.length === 0) {
         return invalid("empty-unparsable", moduleIndexHeadingCount);
     }
@@ -345,6 +355,7 @@ export async function resolveBackendTestManifestModules(workspaceRoot, layout) {
         moduleIndexHeadingCount,
         declaredStems,
         declaredMdFiles: declaredMdFiles.sort(),
+        declaredScriptByMarkdown,
         declaredMissing: declaredMissing.sort(),
         unmanifested: unmanifested.sort(),
     };
@@ -694,7 +705,8 @@ export async function validateBackendMarkdownCases(input) {
             if (!hasAssertableExpectedResult(expected)) {
                 findings.push(`${testCase.id} has no structured expected result`);
             }
-            const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
+            const expectedScript = manifest.declaredScriptByMarkdown[relativeFile] ??
+                expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
             const mappedScripts = extractMappedPytestScripts(testCase.body);
             if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
                 // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and keep only assertion/cross-cutting TPs.

package/dist/workflows/dag/backend-test-result-contract.js

@@ -934,7 +934,7 @@ export async function materializeBackendTestResultFromPytestHtml(input) {
         outcome = "command-error";
     }
     const commandSummary = input.commandSummary ??
-        `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest -v -p no:cacheprovider --html=${htmlRelativePath} --self-contained-html`;
+        `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python reports/backend-test-pytest-launcher.py reports/backend-test-pytest-targets.txt ${htmlRelativePath} -> pytest.main(-v -p no:cacheprovider --self-contained-html)`;
     assertNoSecrets("commandSummary", commandSummary);
     const result = backendTestResultContractSchema.parse({
         schemaVersion: 1,

package/dist/workflows/dag/backend-test-writer-completeness.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { z } from "zod";
 import { BACKEND_TEST_MAX_MODULE_COUNT, isOpaqueHashBackendTestModuleStem, isPriorityOnlyBackendTestModuleStem, } from "./backend-test-module-stem.js";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
-import { inspectBackendTestMarkdownTestPointBindings } from "./backend-test-case-coverage-analysis.js";
+import { canonicalizeBackendTestMarkdownTestPointBindings, inspectBackendTestMarkdownTestPointBindings, } from "./backend-test-case-coverage-analysis.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -47,8 +47,16 @@ const progressSchema = z
         path: z.string().optional(),
         detail: z.string(),
         recoverable: z.boolean(),
+        failureSubreason: z.literal("markdown-test-point-binding-format").optional(),
+        affectedCases: z.array(z.string()).optional(),
+        testPointIds: z.array(z.string()).optional(),
+        canonicalizationEligible: z.boolean().optional(),
+        canonicalizationOutcome: z.enum(["not-attempted", "changed", "already-canonical", "unsafe", "revalidation-failed"]).optional(),
     })
         .strict()),
+    canonicalizationOutcome: z.enum(["not-attempted", "changed", "already-canonical", "unsafe", "revalidation-failed"]).optional(),
+    canonicalizedTestPointCount: z.number().int().min(0).optional(),
+    lightweightRepairEligible: z.boolean().optional(),
 })
     .strict();
 async function exists(filePath) {
@@ -520,6 +528,9 @@ export async function assessBackendTestShardChildCompleteness(input) {
     const actualPaths = [];
     const missingPaths = [];
     const brokenPaths = [];
+    let canonicalizationOutcome = role === "md-generate" ? "already-canonical" : undefined;
+    let canonicalizedTestPointCount = 0;
+    let lightweightRepairEligible = false;
     for (const target of targetPaths) {
         // Rendered map-child writeSet entries are concrete (e.g.
         // testcase/md/health.md / testcase/test_orders.py); glob-only entries are
@@ -538,16 +549,44 @@ export async function assessBackendTestShardChildCompleteness(input) {
             continue;
         }
         actualPaths.push(target);
-        const body = await readFile(absolute, "utf8");
+        let body = await readFile(absolute, "utf8");
         if (role === "md-generate") {
+            const beforeBindings = inspectBackendTestMarkdownTestPointBindings(body);
+            const canonicalization = canonicalizeBackendTestMarkdownTestPointBindings(body);
+            if (canonicalization.changed) {
+                await writeFile(absolute, canonicalization.markdown, "utf8");
+                body = canonicalization.markdown;
+                canonicalizationOutcome = "changed";
+                canonicalizedTestPointCount += canonicalization.canonicalizedTestPoints.length;
+            }
+            const afterBindings = inspectBackendTestMarkdownTestPointBindings(body);
+            const unresolved = afterBindings.flatMap((entry) => entry.unclassifiedTestPoints);
+            const bindingCases = afterBindings
+                .filter((entry) => entry.unclassifiedTestPoints.length > 0 || entry.duplicateBindingTestPoints.length > 0)
+                .map((entry) => entry.caseId);
             const structural = moduleStructurallyComplete(body);
             if (!structural.ok) {
+                lightweightRepairEligible = bindingCases.length > 0;
+                if (bindingCases.length > 0)
+                    canonicalizationOutcome = canonicalization.changed ? "revalidation-failed" : "unsafe";
                 brokenPaths.push(target);
+                const bindingFormatIssue = bindingCases.length > 0;
                 issues.push({
                     code: "T5",
                     path: target,
                     detail: moduleStructuralDetail(structural),
                     recoverable: true,
+                    ...(bindingFormatIssue
+                        ? {
+                            failureSubreason: "markdown-test-point-binding-format",
+                            affectedCases: orderedUnique(bindingCases),
+                            testPointIds: orderedUnique(unresolved),
+                            canonicalizationEligible: canonicalization.canonicalizedTestPoints.length > 0,
+                            canonicalizationOutcome: canonicalization.changed
+                                ? (unresolved.length === 0 ? "changed" : "revalidation-failed")
+                                : (beforeBindings.some((entry) => entry.unclassifiedTestPoints.length > 0) ? "unsafe" : "already-canonical"),
+                        }
+                        : {}),
                 });
             }
         }
@@ -586,6 +625,9 @@ export async function assessBackendTestShardChildCompleteness(input) {
         brokenPaths: orderedUnique(brokenPaths),
         targetPaths: recoverableTargets,
         issues,
+        ...(role === "md-generate"
+            ? { canonicalizationOutcome, canonicalizedTestPointCount, lightweightRepairEligible }
+            : {}),
     };
 }
 export async function assessBackendTestMdWriterCompleteness(workspaceRoot, layout) {
@@ -853,7 +895,7 @@ export async function writeBackendTestWriterProgressArtifacts(input) {
         "## Issues",
         "",
         ...(input.progress.issues.length
-            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}`)
+            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}${issue.failureSubreason ? `; failureSubreason=${issue.failureSubreason}; canonicalizationOutcome=${issue.canonicalizationOutcome ?? "not-attempted"}; canonicalizationEligible=${issue.canonicalizationEligible ?? false}; affectedCases=${(issue.affectedCases ?? []).join(",") || "none"}; testPointIds=${(issue.testPointIds ?? []).join(",") || "none"}` : ""}`)
             : ["- None"]),
         "",
         `<!-- sha256:${createHash("sha256").update(JSON.stringify(parsed)).digest("hex")} -->`,

package/dist/workflows/dag/budget-enforcement.js

@@ -8,9 +8,19 @@ export function initRunBudgetLedger(state, budget) {
     state.budgetLedger = createBudgetLedger(budget);
 }
 function wallTimeMs(state, now = Date.now()) {
+    const lineage = state.continuation?.budgetLineage;
+    if (lineage) {
+        return (lineage.inheritedConsumed.wallTimeMs +
+            Math.max(0, now - new Date(lineage.inheritedAt).getTime()));
+    }
     return Math.max(0, now - new Date(state.startedAt).getTime());
 }
 function repairPasses(state) {
+    const lineage = state.continuation?.budgetLineage;
+    if (lineage) {
+        return (lineage.inheritedConsumed.repairPasses +
+            Math.max(0, (state.convergence?.currentPass ?? 1) - 1));
+    }
     return state.convergence?.currentPass ?? 0;
 }
 export function applyHardBudgetBreach(state, breach) {