@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.3

package/dist/worker/materialize/frontend-split-task-materializer.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { computeFrontendSplitDigest } from "../../workflows/dag/frontend-split-orchestrator.js";
+const idSchema = z.string().trim().min(1);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const positiveIntegerSchema = z.number().int().positive();
+const pathSchema = z.string().trim().min(1);
+export const frontendSplitTaskMaterializationRequestSchema = z.object({
+    kind: z.enum(["child", "integration"]),
+    parentOperationId: idSchema,
+    manifestDigest: digestSchema,
+    generation: positiveIntegerSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+    payloadDigest: digestSchema,
+    allowedPaths: z.array(pathSchema),
+    writeSet: z.array(pathSchema),
+    verifyRefs: z.array(idSchema),
+}).strict();
+export const frontendSplitTaskMaterializationResultSchema = z.object({
+    idempotencyKey: digestSchema,
+    requestDigest: digestSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+}).strict();
+function identityPayload(request) {
+    return { kind: request.kind, parentOperationId: request.parentOperationId, manifestDigest: request.manifestDigest, generation: request.generation, taskId: request.taskId, operationId: request.operationId };
+}
+export class FrontendSplitTaskMaterializer {
+    backend;
+    completed = new Map();
+    inFlight = new Map();
+    constructor(backend) {
+        this.backend = backend;
+    }
+    async materialize(raw) {
+        const request = frontendSplitTaskMaterializationRequestSchema.parse(raw);
+        const idempotencyKey = computeFrontendSplitDigest(identityPayload(request));
+        const requestDigest = computeFrontendSplitDigest(request);
+        const existing = this.completed.get(idempotencyKey);
+        if (existing) {
+            if (existing.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return existing;
+        }
+        const pending = this.inFlight.get(idempotencyKey);
+        if (pending) {
+            const result = await pending;
+            if (result.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return result;
+        }
+        const promise = this.perform(request, idempotencyKey, requestDigest);
+        this.inFlight.set(idempotencyKey, promise);
+        try {
+            const result = await promise;
+            this.completed.set(idempotencyKey, result);
+            return result;
+        }
+        finally {
+            this.inFlight.delete(idempotencyKey);
+        }
+    }
+    async perform(request, idempotencyKey, requestDigest) {
+        const task = await this.backend.ensureTask({ idempotencyKey, taskId: request.taskId, payloadDigest: requestDigest, request });
+        if (!task.complete || task.taskId !== request.taskId)
+            throw new Error("frontend split task materialization incomplete or drifted");
+        const operation = await this.backend.ensureOperation({ idempotencyKey, taskId: request.taskId, operationId: request.operationId, payloadDigest: requestDigest, request });
+        if (!operation.complete || operation.taskId !== request.taskId || operation.operationId !== request.operationId)
+            throw new Error("frontend split operation materialization incomplete or drifted");
+        return frontendSplitTaskMaterializationResultSchema.parse({ idempotencyKey, requestDigest, taskId: request.taskId, operationId: request.operationId });
+    }
+}

package/dist/worker/observe/static/dag-node-purpose.js

@@ -39,20 +39,25 @@ const NODE_PURPOSE_BY_ID = {
 	"closeout-summary-pi": "把验证与交付事实写成简短交接摘要。",
 
 	"frontend-contract-pi": "把前端需求整理成可追踪契约：页面、状态、验收与边界。",
+	"frontend-contract-import-shell": "导入并固化前端实现契约，供后续设计、写入与验证节点使用。",
 	"frontend-scout-pi": "只读侦察前端结构、组件与接口用法，不改文件。",
 	"frontend-plan-pi": "选定实现与 Mock/API 策略，输出可执行的前端实现契约补丁。",
+	"frontend-design-policy-shell": "确定前端设计与 Mock/API 策略，冻结后续实现必须遵守的规则。",
 	"frontend-design-review-pi": "审查前端计划是否可写：通过则沿用原计划，否则要求修订。",
 	"frontend-plan-revision-pi": "按设计审查意见修订前端契约，不扩大范围。",
 	"frontend-final-design-review-pi": "复核修订后的前端计划，只有通过才能授权写入。",
 	"frontend-prewrite-gate-shell": "写入前门禁：核对契约、覆盖与 Mock 策略，通过才允许改前端。",
+	"frontend-writer-admission-shell": "核对契约、设计策略与 writeSet，满足准入条件后才允许 writer 写入。",
 	"frontend-lint-baseline-shell": "记录写入前的 lint 基线，供实现后对比，不阻断写入。",
 	"frontend-implement-pi": "按已批准契约改前端代码、状态与交互，留在 writeSet 内。",
 	"frontend-verify-assess-shell": "跑静态/行为/Mock 验证并评估能否有界修复。",
+	"frontend-verify-shell": "执行冻结的前端验证命令，产出可复查的通过或失败证据。",
 	"frontend-repair-pi": "只修评估为可修复的前端失败，不重开需求。",
 	"frontend-reverify-shell": "修复后用同一套冻结命令复验。",
 	"frontend-review-context-shell": "打包真实 diff 与有效验证证据，供审查节点使用。",
 	"frontend-review-pi": "对照契约审查前端实现与证据，给出通过或需修订。",
 	"frontend-review-gate-shell": "前端审查门禁：结论为通过才进入收口。",
+	"frontend-closeout-shell": "汇总实现、验证与遗留事项，形成确定性的前端收口事实。",
 	"frontend-closeout-pi": "汇总前端交付状态（含真实联调是否仍待完成）。",
 	"frontend-mock-assess-pi": "评估项目是否具备授权的 Mock 验证能力。",
 	"frontend-mock-contract-gate-shell": "Mock 契约门禁：策略与验证命令不一致则阻断。",

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-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/contract-validator-registrations.js

@@ -3,8 +3,7 @@
  * its schemaId in the contract output registry. Imported once by the node
  * executor; keeps per-contract imports out of the executor.
  */
-import { validateFrontendContractNodeOutput, validateFrontendPlanPatchNodeOutput, validateFrontendRevisionPatchNodeOutput, } from "./frontend-implementation-contract.js";
+import { validateFrontendContractNodeOutput, validateFrontendPlanPatchNodeOutput, } from "./frontend-implementation-contract.js";
 import { registerStructuredContractValidator } from "./contract-output-registry.js";
 registerStructuredContractValidator("frontend-implementation-contract-v1", validateFrontendContractNodeOutput);
 registerStructuredContractValidator("frontend-implementation-contract-plan-patch-v1", validateFrontendPlanPatchNodeOutput);
-registerStructuredContractValidator("frontend-implementation-contract-revision-patch-v1", validateFrontendRevisionPatchNodeOutput);

package/dist/workflows/dag/dag-retry-schema.js

@@ -0,0 +1,138 @@
+import { z } from "zod";
+/**
+ * Leaf module for the retry-policy schema surface: failure-category constants,
+ * the zod retry-policy schema, and the target-template transient retry profile
+ * literal.
+ *
+ * `types.ts` reads `dagRetryPolicySchema` / `TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE`
+ * during its own module initialization, and the retry-policy module transitively
+ * reaches `types.ts` (retry-policy → frontend-recovery-capsule →
+ * frontend-recovery-lineage → frontend-implementation-contract → types). With
+ * these definitions living in retry-policy itself, a run whose entry module is
+ * retry-policy (e.g. test/dag-node-retry.test.ts) evaluates `types.ts` while
+ * retry-policy is still initializing and reads an undefined
+ * `dagRetryPolicySchema`. Keeping this module a leaf (zod is its only import)
+ * makes the cycle resolve order-independently; retry-policy re-exports
+ * everything for source compatibility.
+ */
+/**
+ * Failure categories that are safe to auto-retry for read-only Pi nodes.
+ *
+ * These are failures with no repository write side-effects: model connection
+ * interruption, provider rate-limiting, temporary provider unavailability,
+ * request timeout, or a settled read-only turn with no assistant text.
+ *
+ * `quota` is intentionally NOT included: a quota exhaustion is an account
+ * billing/plan state, not a transient rate limit, and retrying immediately
+ * will not help and may waste budget.
+ */
+export const DEFAULT_DAG_RETRY_CATEGORIES = [
+    "timeout",
+    "network",
+    "rate-limit",
+    "unavailable",
+    "empty-output",
+];
+export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
+export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
+/** Recoverable model artifact/schema formatting failure on read-only structured nodes. */
+export const STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY = "invalid-output";
+/** Provider stopReason=length truncated the response before the JSON contract completed. */
+export const STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY = "structured-output-truncated";
+/**
+ * The review node emitted a verdict in response text (e.g. "VERDICT: pass")
+ * but never committed the authoritative typed terminal tool call
+ * (approve_review / request_review_changes). Read-only and safe to retry with
+ * a corrected instruction; the typed terminal is the only authority.
+ */
+export const REVIEW_TERMINAL_MISSING_RETRY_CATEGORY = "review-terminal-missing";
+/**
+ * The plan node issued too many read-only tool calls (read/grep/ls/find),
+ * blowing up the context window and eventually a 400 request-too-large. The
+ * plan should trust upstream typed facts instead of re-reading contract/scout
+ * outputs and source files repeatedly. Read-only and safe to retry with a
+ * reduced-reading instruction.
+ */
+export const READ_BURST_RETRY_CATEGORY = "read-burst";
+/**
+ * Provider returned a context-overflow error (400 request-too-large / context
+ * window exceeded). The SDK compacts and auto-retries once internally; when it
+ * still surfaces, the executor classifies this so retry policies and reports
+ * treat it as overflow (not empty-output) and can retry with a compacted
+ * session / fresh context.
+ */
+export const CONTEXT_OVERFLOW_RETRY_CATEGORY = "context-overflow";
+/** Retry only a proven no-op from an explicitly opt-in bounded Pi writer. */
+export const WRITER_EMPTY_DIFF_RETRY_CATEGORY = "writer-empty-diff";
+/** Retry when a backend-test writer finished but Completeness Gate found missing/broken targets. */
+export const INCOMPLETE_WRITE_SET_RETRY_CATEGORY = "incomplete-write-set";
+/**
+ * Provider/transport stall or absolute timeout on a Pi exclusive writer that
+ * left zero attributed workspace writes and zero write-tool calls. Safe to
+ * retry once because the attempt was a pure provider flake (no side effects).
+ * Partial writes keep the original `timeout` category and do NOT retry.
+ */
+export const WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY = "writer-clean-timeout";
+export const STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    STRUCTURED_OUTPUT_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
+];
+/** Categories allowed on nodes that declare a machine-readable outputProtocol. */
+export const PROTOCOL_AWARE_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    PROTOCOL_INVALID_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+];
+export const ALL_DAG_RETRY_CATEGORIES = [
+    ...DEFAULT_DAG_RETRY_CATEGORIES,
+    STRUCTURED_OUTPUT_RETRY_CATEGORY,
+    PROTOCOL_INVALID_RETRY_CATEGORY,
+    STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
+    WRITER_EMPTY_DIFF_RETRY_CATEGORY,
+    INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
+    WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,
+    REVIEW_TERMINAL_MISSING_RETRY_CATEGORY,
+    READ_BURST_RETRY_CATEGORY,
+    CONTEXT_OVERFLOW_RETRY_CATEGORY,
+];
+export const dagRetryCategorySchema = z.enum(ALL_DAG_RETRY_CATEGORIES);
+export const dagRetryBackoffSchema = z.enum(["exponential"]);
+/**
+ * Opt-in retry policy for a DagTask. Generated for safe read-only Pi nodes,
+ * except the single validation-gated writer-empty-diff policy. Validation
+ * rejects all other writers, dynamic, shell, static, and decision-gate nodes.
+ */
+export const dagRetryPolicySchema = z
+    .object({
+    /**
+     * Total number of attempts (including the first try). Must be 1..5.
+     * A value of 1 disables retry (one attempt, no retry).
+     */
+    maxAttempts: z.number().int().positive().max(5),
+    backoff: dagRetryBackoffSchema.default("exponential"),
+    /** Initial delay before the second attempt, in milliseconds. */
+    initialDelayMs: z.number().int().nonnegative().default(2000),
+    /** Upper bound on a single backoff delay, in milliseconds. */
+    maxDelayMs: z.number().int().nonnegative().default(30000),
+    /**
+     * Explicit set of failure categories eligible for retry. Defaults to
+     * {@link DEFAULT_DAG_RETRY_CATEGORIES}. `quota` and other categories
+     * are never retried.
+     */
+    retryCategories: z
+        .array(dagRetryCategorySchema)
+        .default([...DEFAULT_DAG_RETRY_CATEGORIES]),
+})
+    .superRefine((policy, ctx) => {
+    if (policy.maxDelayMs < policy.initialDelayMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "retryPolicy.maxDelayMs must be >= retryPolicy.initialDelayMs",
+            path: ["maxDelayMs"],
+        });
+    }
+});
+export const TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE = "standard-reviewed-supervised-v1";