@tea-agent/loop-agent 0.39.0-next.26 → 0.39.0-next.27

package/dist/workflows/dag/init-hybrid.js

@@ -21,7 +21,6 @@ import { applySddEmbeddedEnhancements, probeRepoLocalSddSkills, } from "./sdd-em
 import { discoverProjectGovernancePresence } from "./project-governance-context.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
-import { REQUIREMENT_FACT_ROLES } from "../../task/source-prepare/artifact-meta.js";
 import { observeTaskContract } from "../../task/contract/observe.js";
 import { dagHasWriterExecution } from "./task-contract-binding.js";
 import { DEFAULT_VERIFY_TIMEOUT_MS, resolveVerifyPreset, } from "../../executors/shell-verification.js";
@@ -1502,27 +1501,11 @@ function buildSourceContextBlock(sources) {
             .relative(path.join(sources.taskDir, "source"), reference.path)
             .replaceAll(path.sep, "/");
         const referenceRef = toDagSourcePath(sources, reference.path);
-        // Fact-source roles (requirement/acceptance) carry the fields contracts
-        // depend on (AC/scope/columns). Inject them in full so a fixed excerpt
-        // cannot silently drop definitions; archival roles stay excerpted.
-        const isFactRole = reference.role !== undefined &&
-            REQUIREMENT_FACT_ROLES.has(reference.role);
-        const referenceExcerpt = isFactRole
-            ? {
-                text: reference.markdown.trim(),
-                truncated: false,
-                originalChars: reference.markdown.trim().length,
-                maxChars: Number.POSITIVE_INFINITY,
-            }
-            : excerptMarkdown(reference.markdown, {
-                sourceRef: referenceRef,
-            });
-        boundReadPaths.push(`- reference ${relativePath}${isFactRole ? " (full source)" : ""}: ${referenceRef}`);
-        parts.push(`## Task source reference: ${relativePath}`, `Bound readPath (use for Pi read-tool calls): ${referenceRef}`, ...(isFactRole
-            ? [
-                `Full source injected (role: ${reference.role}) — complete and authoritative; no excerpt truncation applied.`,
-            ]
-            : []), referenceExcerpt.text);
+        const referenceExcerpt = excerptMarkdown(reference.markdown, {
+            sourceRef: referenceRef,
+        });
+        boundReadPaths.push(`- reference ${relativePath}: ${referenceRef}`);
+        parts.push(`## Task source reference: ${relativePath}`, `Bound readPath (use for Pi read-tool calls): ${referenceRef}`, referenceExcerpt.text);
     }
     parts.push("## Bound source read paths", ...boundReadPaths, "Use these repository-readable paths for any Pi read-tool calls. Bound files under `.harness/tasks/<taskId>/source/**` are read-only inputs: reading them is allowed even though writing `.harness/**` is forbidden.", "Never resolve task-relative citations such as `source/需求.md` or `source/references/*` against the repository root, invent `source/<taskId>/...`, search for substitutes, or fall back to `docs/**` when a bound read fails.", "## Task config summary", `- taskId: ${sources.taskConfig.taskId}`, `- flow: ${sources.taskConfig.flow}`, `- complexity: ${sources.taskConfig.complexity}`, `- contextProfile: ${sources.taskConfig.contextProfile}`, `- allowedPaths: ${sources.taskConfig.allowedPaths.join(", ") || "(none — review before execute)"}`, `- forbiddenPaths: ${sources.taskConfig.forbiddenPaths.join(", ") || "(none)"}`, '- Pi DAG nodes are read-only unless toolProfile="write" is explicitly selected for a bounded writer node.', "- Agent DAG read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.", `- Derived execution contract and immutable references live under the Bound source read paths above (not as repo-root \`source/...\`).`);
     if (sources.taskConfig.hardConstraints.length > 0) {
@@ -1560,49 +1543,10 @@ async function loadMaterializedSourceReferences(sourceDir) {
     }
     await collect(referenceDir);
     referencePaths.sort((left, right) => left.localeCompare(right));
-    const roleByPath = await loadReferenceRoles(sourceDir);
-    return Promise.all(referencePaths.map(async (filePath) => {
-        const relative = path
-            .relative(sourceDir, filePath)
-            .replaceAll(path.sep, "/");
-        const role = roleByPath.get(relative);
-        return {
-            path: filePath,
-            markdown: await readFile(filePath, "utf-8"),
-            ...(role !== undefined ? { role } : {}),
-        };
-    }));
-}
-/**
- * Reads `source-manifest.json` into a materializedPath → role map so the DAG
- * generator can tell fact-source references (requirement/acceptance) apart
- * from archival ones (analysis/clarification/design). A missing or malformed
- * manifest yields an empty map; such references keep the bounded-excerpt
- * treatment instead of being injected in full.
- */
-async function loadReferenceRoles(sourceDir) {
-    const roleByPath = new Map();
-    const manifestPath = path.join(sourceDir, "source-manifest.json");
-    let raw;
-    try {
-        raw = await readFile(manifestPath, "utf-8");
-    }
-    catch {
-        return roleByPath;
-    }
-    try {
-        const manifest = JSON.parse(raw);
-        for (const document of manifest.documents ?? []) {
-            if (typeof document.materializedPath === "string" &&
-                typeof document.role === "string") {
-                roleByPath.set(document.materializedPath.replaceAll(path.sep, "/"), document.role);
-            }
-        }
-    }
-    catch {
-        // A malformed manifest must never break reference injection.
-    }
-    return roleByPath;
+    return Promise.all(referencePaths.map(async (filePath) => ({
+        path: filePath,
+        markdown: await readFile(filePath, "utf-8"),
+    })));
 }
 export async function loadTaskHybridSources(repoRoot, taskId) {
     const paths = getTaskPaths(repoRoot, taskId);
@@ -2433,7 +2377,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             "## Runtime contract skeleton (deterministic and protected)",
             JSON.stringify(frontendContractSkeleton),
             "",
-            "The initial planner emits an editable RFC 7386 patch against this skeleton. It MUST omit schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. The runtime merges and validates the final contract, then replaces the planner output with canonical full-contract JSON for downstream review.",
+            "The initial planner emits an editable RFC 7386 patch against this skeleton. It MUST omit schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. The runtime merges and validates the final contract, then writes a hash-bound canonical JSON artifact; downstream review and prewrite consume that artifact path, not planner stdout.",
             "",
             "## Forbidden fields (these are NOT in the schema; do not emit)",
             "- schemaId",
@@ -2550,11 +2494,6 @@ async function buildFrontendHybridDagFromTask(sources) {
         `Non-static targets (type unit/component/integration/mock) MUST set file to a concrete code file inside the implementation writeSet (task allowedPaths); the prewrite gate rejects any non-static target whose file falls outside the writeSet.`,
         `Command-level checks that run project-wide (all tests, typecheck, build, governance) MUST use type "static" and must NOT be bound as non-static targets with file=package.json/tsconfig.json/vite.config.ts/scripts/*. Static targets are exempt from the writeSet containment check.`,
     ].join("\n");
-    const mandatorySourceReadInstruction = [
-        "## Mandatory full source read before contracting",
-        "Before producing this contract/plan, use the Pi read tool to read the FULL bound source files (需求.md, 执行约束.md, and every `references/*` Bound readPath listed above) — the inline copies above may be truncated excerpts, and requirement/acceptance references are authoritative only in their full form.",
-        "Do not drop scope fields, acceptance criteria, non-goals, UI states, or column/field definitions that exist in the full sources but are absent from the inline excerpts; if a field appears in the full source, it belongs in the contract.",
-    ].join("\n");
     const strategy = resolveDagVerifyStrategy(taskConfig);
     const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
     const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
@@ -2751,7 +2690,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read task source and produce a concise frontend implementation contract.",
                     "Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations.",
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    mandatorySourceReadInstruction,
                     sourceContext,
                 ].join("\n\n"),
             },
@@ -2792,7 +2730,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "JSON-only patch output: one-line lead-in, then exactly ONE fenced json object (```json ... ```) containing only the editable RFC 7386 plan patch for the runtime contract skeleton. Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. Immediately after it, append exactly one ```openspec-citations``` fenced citation block. The runtime applies the patch, validates it, and promotes canonical full-contract JSON for downstream review. Do NOT emit a full contract, Markdown plan explanation, raw JSON, or any other fenced block. No file writes.",
+                outputContract: "JSON-only patch output: one-line lead-in, then exactly ONE fenced json object (```json ... ```) containing only the editable RFC 7386 plan patch for the runtime contract skeleton. Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. Immediately after it, append exactly one ```openspec-citations``` fenced citation block. The runtime applies the patch, validates it, and writes a hash-bound canonical JSON artifact for downstream review. Do NOT emit a full contract, Markdown plan explanation, raw JSON, or any other fenced block. No file writes.",
                 subtask_prompt: [
                     "Use frontend-contract-pi, frontend-scout-pi, task sources, and the generation-time Mock capability evidence to fill the runtime-owned frontend contract skeleton. Return JSON-only output containing only an editable RFC 7386 plan patch. The runtime already owns schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff; omit those protected paths even when their values look obvious.",
                     "The patch fields become the complete implementation plan after deterministic merge. Do not produce a separate plan document, prose mirror, or full contract.",
@@ -2806,7 +2744,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "verificationTargets[].commandLabel MUST be one of the frozen command labels listed above. Any other value will be rejected at contract materialization.",
                     verificationTargetFileInstruction,
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    mandatorySourceReadInstruction,
                     fixedVerificationContext,
                     sourceContext,
                     mockContextBlock,
@@ -2828,7 +2765,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 outputProtocol: REVIEW_VERDICT_OUTPUT_PROTOCOL,
                 outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings, Required Plan Corrections, and Checked Items. No file writes.",
                 subtask_prompt: [
-                    "Audit the frontend plan before implementation. frontend-plan-pi is emitted to you as canonical full-contract JSON after the runtime applied and validated the planner's editable patch against its protected skeleton; there is no separate plan prose.",
+                    "Audit the frontend plan before implementation. frontend-plan-pi is emitted as a hash-bound canonical JSON artifact after the runtime applied and validated the planner's editable patch against its protected skeleton; read that artifact with the read tool and do not infer the contract from stdout. There is no separate plan prose.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
                     "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence. A static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint. not-needed otherwise requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
@@ -2857,15 +2794,15 @@ async function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "When the initial design review requests revision, return a one-line lead-in followed by exactly ONE fenced json object (```json ... ```) containing an RFC 7386 merge-patch delta against the original frontend-implementation-contract-v1 (only the fields you change; null deletes a key; arrays and scalars replace; plain objects merge recursively). Immediately after it, append exactly one ```openspec-citations``` fenced citation block. Do NOT emit a full contract, Markdown explanation, or prose — the output is JSON-only; the gate applies the patch on the original contract and renders plan.md deterministically. Apart from the patch JSON fenced block and the openspec-citations block, do not emit any other fenced block or raw JSON. No file writes.",
+                outputContract: "When the initial design review requests revision, return a one-line lead-in followed by exactly ONE fenced json object (```json ... ```) containing an RFC 7386 merge-patch delta against the original frontend-implementation-contract-v1 (only the fields you change; null deletes a key; arrays and scalars replace; plain objects merge recursively). Immediately after it, append exactly one ```openspec-citations``` fenced citation block. Do NOT emit a full contract, Markdown explanation, or prose — the output is JSON-only; this node compiles the patch onto the original canonical artifact and writes a hash-bound revised contract. Apart from the patch JSON fenced block and the openspec-citations block, do not emit any other fenced block or raw JSON. No file writes.",
                 subtask_prompt: [
                     "Consume frontend-plan-pi (original contract JSON) and frontend-design-review-pi (first design review findings).",
                     "This node runs only when frontend-design-review-pi emitted VERDICT: request-revision. Produce an RFC 7386 merge-patch delta against the original contract JSON that addresses every Required Plan Correction from the design findings.",
-                    "The patch delta may update editable contract fields such as requirements, implementationSteps, targets.routes/publicApiChanges, uiStates, interactions, mockApi.strategy/activation/endpoints, dependencyPolicy, stylingStrategy, uiComponentChoices, verificationTargets, evidenceGaps, residualRisks, and realIntegrationGap. It must not modify protected schemaVersion, sourceBinding, riskLevel, targets.files, or mockApi.productionDefaultOff. Only include fields you change; omit unchanged fields (the gate applies the patch on the original contract). null deletes a key; arrays and scalars replace; plain objects merge recursively.",
+                    "The patch delta may update editable contract fields such as requirements, implementationSteps, targets.routes/publicApiChanges, uiStates, interactions, mockApi.strategy/activation/endpoints, dependencyPolicy, stylingStrategy, uiComponentChoices, verificationTargets, evidenceGaps, residualRisks, and realIntegrationGap. It must not modify protected schemaVersion, sourceBinding, riskLevel, targets.files, or mockApi.productionDefaultOff. Only include fields you change; omit unchanged fields (this node applies the patch on the original canonical artifact). null deletes a key; arrays and scalars replace; plain objects merge recursively.",
                     requirementCoverageInstruction,
                     "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
                     "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
-                    "Output in this exact order: (1) exactly one fenced json object containing the merge-patch delta — this is the only plan output the prewrite gate applies on the original contract; (2) exactly one openspec-citations citation fenced block appended immediately after it. Do NOT emit a full contract, Markdown explanation, or prose — the output is JSON-only. Do not emit any raw JSON or JSON objects in prose. Apart from the patch JSON fenced block and the openspec-citations block, do not emit any other fenced block. Do not include secrets or unsafe paths.",
+                    "Output in this exact order: (1) exactly one fenced json object containing the merge-patch delta — this node compiles it onto the original canonical artifact; (2) exactly one openspec-citations citation fenced block appended immediately after it. Do NOT emit a full contract, Markdown explanation, or prose — the output is JSON-only. Do not emit any raw JSON or JSON objects in prose. Apart from the patch JSON fenced block and the openspec-citations block, do not emit any other fenced block. Do not include secrets or unsafe paths.",
                     "Preserve each requirement expectedOutcome and each interaction trigger/expectedBehavior in the effective (merged) contract; do not reduce behavior semantics to IDs and paths.",
                     "verificationTargets[].commandLabel MUST be one of the frozen command labels listed above. Any other value will be rejected at contract materialization.",
                     verificationTargetFileInstruction,
@@ -6490,6 +6427,13 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
             spec = await buildSupervisedHybridDag(standard, sources);
     }
     applyProjectGovernanceReview(spec, template, sources);
+    // Backend implementation templates only (D1 outer gate): assign the two
+    // Pi extension buckets after all template-specific nodes exist.
+    if (template === "standard-dag" ||
+        template === "review-gated-dag" ||
+        template === "supervised-implementation") {
+        applyBackendPiExtensionBuckets(spec);
+    }
     // New generate path always emits DagSpec v4 + bindings.
     spec.version = 4;
     if (!spec.runtimeContract) {
@@ -6557,6 +6501,28 @@ function cloneTask(task, patch = {}) {
  * Dynamic, shell, static, and decision-gate nodes are skipped. Idempotent:
  * never overwrites an explicit retryPolicy a task already declares.
  */
+/**
+ * Backend-implementation Pi extension buckets (plan 2026-08-21 D3):
+ * - read side: every non-writer, non-closeout Pi node gets navigation
+ *   extensions (pi-codegraph + pi-lens);
+ * - write side: bounded writers get only pi-codegraph (pi-lens registers
+ *   ast_grep_replace, which can bypass the writeSet — not loading it is
+ *   simpler and safer than filtering after load);
+ * - everything else (closeout, shell, static, other templates) stays closed.
+ * Idempotent: never overwrites an explicit piExtensions a task declares.
+ */
+function applyBackendPiExtensionBuckets(spec) {
+    for (const task of spec.tasks) {
+        if (task.piExtensions !== undefined)
+            continue;
+        if (task.executor !== "pi")
+            continue;
+        if (task.id === "closeout-pi")
+            continue;
+        task.piExtensions =
+            task.toolProfile === "write" ? ["pi-codegraph"] : ["pi-codegraph", "pi-lens"];
+    }
+}
 function applyDefaultReadOnlyRetryPolicy(spec) {
     for (const task of spec.tasks) {
         if (task.retryPolicy !== undefined)

package/dist/workflows/dag/node-execution.js

@@ -15,6 +15,8 @@ import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from
 import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, parseJsonReviewVerdict, validateOutputProtocol, } from "./output-protocol.js";
 import { getStructuredContractValidator } from "./contract-output-registry.js";
 import "./contract-validator-registrations.js";
+import { allowedRepairReadPaths, auditRepairAttemptToolUse, buildStructuredOutputRepairPrompt, freezeStructuredOutputRepairContext, hasNonEmptyStructuredCandidate, isFrontendStructuredRepairSchemaId, isStructuredRepairableFailureCategory, persistStructuredAttemptRaw, sessionEventsByteLength, GOVERNANCE_BLOCKED_CATEGORY, STRUCTURED_REPAIR_EXHAUSTED_CATEGORY, } from "./structured-output-repair.js";
+import { readFrontendCanonicalCandidate } from "./frontend-implementation-contract.js";
 import { writeDagNodeJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { buildProjectGovernanceContext, readCompletedWriterChangeManifests, writeProjectGovernanceContext, } from "./project-governance-context.js";
 import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
@@ -135,6 +137,11 @@ function frontendStructuredArtifactRetryGuidance(schemaId) {
             "Return exactly this artifact and nothing else: one short lead-in line, then exactly one fenced json block containing only the editable RFC 7386 plan patch, immediately followed by exactly one fenced openspec-citations block.",
             "The runtime applies your patch to its protected contract skeleton. Do not emit schemaVersion, sourceBinding, riskLevel, targets.files, or mockApi.productionDefaultOff; do not emit the full contract.",
             "Do not emit Markdown headings, bullets, plan prose, explanations, raw JSON, or any other fenced block.",
+            "The openspec-citations fenced block contains one JSON object per line, each with path/section/line — for example:",
+            "```openspec-citations",
+            '{"path":".harness/tasks/<task>/source/需求.md","section":"Objective","line":5}',
+            '{"path":".harness/tasks/<task>/source/references/product-requirement.md","section":"FR-1","line":16}',
+            "```",
         ];
     }
     if (schemaId === "frontend-implementation-contract-revision-patch-v1") {
@@ -142,6 +149,11 @@ function frontendStructuredArtifactRetryGuidance(schemaId) {
             "Return exactly this artifact and nothing else: one short lead-in line, then exactly one fenced json block containing the RFC 7386 merge-patch delta, immediately followed by exactly one fenced openspec-citations block.",
             "The delta contains only the fields you change; null deletes a key, arrays and scalars replace, and plain objects merge recursively. Do not emit a full contract or a schemaVersion/targets section.",
             "Do not emit Markdown headings, bullets, plan prose, explanations, raw JSON, or any other fenced block.",
+            "The openspec-citations fenced block contains one JSON object per line, each with path/section/line — for example:",
+            "```openspec-citations",
+            '{"path":".harness/tasks/<task>/source/需求.md","section":"Objective","line":5}',
+            '{"path":".harness/tasks/<task>/source/references/product-requirement.md","section":"FR-1","line":16}',
+            "```",
         ];
     }
     return [
@@ -731,10 +743,17 @@ export async function executeDagNode(input) {
     let terminalResult;
     let previousFailureCategory;
     let previousProtocolReason;
+    let pendingStructuredArtifact;
+    let lastRepairAllowlist = [];
     for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
         const attemptStartedAt = new Date().toISOString();
         node.currentAttempt = attemptNumber;
         node.livenessStatus = "active";
+        // Capture the session-events.jsonl length BEFORE the executor appends this
+        // attempt's events, so the post-attempt repair tool audit can be scoped to
+        // exactly this attempt's segment (B1: earlier attempts legitimately use
+        // ls/find and must not be attributed to the repair attempt).
+        const attemptSessionEventsOffset = await sessionEventsByteLength(runDir, nodeId);
         let result;
         try {
             validateRepairArtifactGateBeforeShell({
@@ -757,12 +776,53 @@ export async function executeDagNode(input) {
                 (acc[i.path] ??= []).push(i.detail);
                 return acc;
             }, {});
+            let attemptPrompt = buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics);
+            if (attemptNumber > 1 &&
+                isFrontendStructuredRepairSchemaId(task.structuredContractOutput?.schemaId) &&
+                isStructuredRepairableFailureCategory(previousFailureCategory) &&
+                (await hasNonEmptyStructuredCandidate({
+                    runDir,
+                    nodeId,
+                    beforeAttempt: attemptNumber,
+                }))) {
+                const originalCanonical = task.structuredContractOutput?.schemaId ===
+                    "frontend-implementation-contract-revision-patch-v1"
+                    ? (await readFrontendCanonicalCandidate(runDir, "frontend-plan-pi"))
+                    : undefined;
+                const frozen = await freezeStructuredOutputRepairContext({
+                    runDir,
+                    runId: state.runId,
+                    taskId: spec.sourceBinding?.taskId ?? task.id,
+                    nodeId,
+                    nodeAttempt: attemptNumber,
+                    targetSchemaId: task.structuredContractOutput.schemaId,
+                    skeleton: task.structuredContractOutput?.skeleton,
+                    originalCanonical,
+                    latestStopReason: previousFailureCategory === "structured-output-truncated"
+                        ? "length"
+                        : previousFailureCategory,
+                });
+                lastRepairAllowlist = allowedRepairReadPaths({
+                    runDir,
+                    context: frozen.context,
+                    contextPath: frozen.relativePath,
+                });
+                attemptPrompt = await buildStructuredOutputRepairPrompt({
+                    runDir,
+                    context: frozen.context,
+                    contextPath: frozen.relativePath,
+                    contextSha256: frozen.sha256,
+                    maxAttempts,
+                    schemaGuidance: frontendStructuredArtifactRetryGuidance(task.structuredContractOutput.schemaId),
+                    previousReason: previousProtocolReason,
+                });
+            }
             result = await executeNode({
                 task,
                 cwd,
                 model,
                 ...(thinking ? { thinking } : {}),
-                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics),
+                prompt: attemptPrompt,
                 attempt: attemptNumber,
                 reportActivity,
                 timeoutMs: livenessPolicy.absoluteMaxWallClockMs,
@@ -778,6 +838,35 @@ export async function executeDagNode(input) {
                 durationMs: 0,
             };
         }
+        if (isFrontendStructuredRepairSchemaId(task.structuredContractOutput?.schemaId)) {
+            const rawText = canonicalNodeOutput(result);
+            if (rawText.trim().length > 0) {
+                await persistStructuredAttemptRaw({
+                    runDir,
+                    nodeId,
+                    attempt: attemptNumber,
+                    text: rawText,
+                });
+            }
+            if (attemptNumber > 1 && lastRepairAllowlist.length > 0) {
+                const audit = await auditRepairAttemptToolUse({
+                    runDir,
+                    nodeId,
+                    allowedPaths: lastRepairAllowlist,
+                    fromByteOffset: attemptSessionEventsOffset,
+                });
+                if (!audit.ok) {
+                    result = {
+                        ...result,
+                        ok: false,
+                        failureCategory: GOVERNANCE_BLOCKED_CATEGORY,
+                        stderr: [result.stderr, audit.reason]
+                            .filter(Boolean)
+                            .join("\n"),
+                    };
+                }
+            }
+        }
         // R0: executor ok=true still fails closed when outputProtocol is violated.
         // Valid semantic results (e.g. VERDICT: request-revision) pass validation.
         if (result.ok && task.outputProtocol) {
@@ -814,16 +903,17 @@ export async function executeDagNode(input) {
                     structuredContractOutput: task.structuredContractOutput,
                 });
                 if (!contractCheck.ok) {
-                    // A provider stopReason=length means the response was cut before the
-                    // JSON contract could complete; separate it from an ordinary bad
-                    // contract so the retry switches to a JSON-only output strategy.
                     const attemptStopReason = result.stopReason;
+                    const failureCategory = contractCheck.classification === "governance-blocked"
+                        ? GOVERNANCE_BLOCKED_CATEGORY
+                        : attemptStopReason === "length" ||
+                            contractCheck.classification === "truncated"
+                            ? "structured-output-truncated"
+                            : "invalid-output";
                     result = {
                         ...result,
                         ok: false,
-                        failureCategory: attemptStopReason === "length"
-                            ? "structured-output-truncated"
-                            : "invalid-output",
+                        failureCategory,
                         stderr: [result.stderr, contractCheck.reason]
                             .filter(Boolean)
                             .join("\n"),
@@ -838,6 +928,9 @@ export async function executeDagNode(input) {
                             stdout: contractCheck.normalizedText,
                         };
                     }
+                    if (contractCheck.artifact) {
+                        pendingStructuredArtifact = contractCheck.artifact;
+                    }
                     previousProtocolReason = undefined;
                 }
             }
@@ -908,13 +1001,26 @@ export async function executeDagNode(input) {
             break;
         const canRetry = retryPolicy !== undefined && attemptNumber < maxAttempts;
         const retryable = retryPolicy !== undefined &&
+            result.failureCategory !== GOVERNANCE_BLOCKED_CATEGORY &&
             (isRetryablePiFailureCategory(result.failureCategory, {
                 retryCategories: retryPolicy.retryCategories,
             }) ||
                 (result.failureCategory === "protocol-invalid" &&
                     task.outputProtocol?.retryOnInvalid === true));
-        if (!canRetry || !retryable)
+        if (!canRetry || !retryable) {
+            if (!canRetry &&
+                isFrontendStructuredRepairSchemaId(task.structuredContractOutput?.schemaId) &&
+                isStructuredRepairableFailureCategory(result.failureCategory)) {
+                result = {
+                    ...result,
+                    failureCategory: STRUCTURED_REPAIR_EXHAUSTED_CATEGORY,
+                };
+                terminalResult = result;
+                previousFailureCategory = result.failureCategory;
+                node.failureCategory = result.failureCategory;
+            }
             break;
+        }
         const delayMs = computeBackoffDelayMs(attemptNumber + 1, retryPolicy);
         if (delayMs > 0) {
             const backoffStartedAt = new Date().toISOString();
@@ -1063,6 +1169,11 @@ export async function executeDagNode(input) {
                 node.structuredArtifactSchemaId = "backend-test-result-v1";
             }
         }
+        else if (pendingStructuredArtifact) {
+            node.structuredArtifactPath = pendingStructuredArtifact.path;
+            node.structuredArtifactSha256 = pendingStructuredArtifact.sha256;
+            node.structuredArtifactSchemaId = pendingStructuredArtifact.schemaId;
+        }
     }
     const finishedAt = new Date().toISOString();
     node.finishedAt = finishedAt;

package/dist/workflows/dag/prompt.js

@@ -116,7 +116,21 @@ export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHA
             ].join("\n"));
             continue;
         }
-        if (!record || record.status !== "FINISHED" || !upstreamText)
+        if (!record || record.status !== "FINISHED")
+            continue;
+        if (record.structuredArtifactPath &&
+            record.structuredArtifactSchemaId ===
+                "frontend-implementation-contract-v1") {
+            sections.push([
+                `## Upstream output: ${depId}`,
+                "Validated structured artifact (read-only runner evidence — use read tool to fetch; do not edit). Do not infer the contract from stdout.",
+                `- path: ${record.structuredArtifactPath}`,
+                `- schema: ${record.structuredArtifactSchemaId}`,
+                `- sha256: ${record.structuredArtifactSha256 ?? "unknown"}`,
+            ].join("\n"));
+            continue;
+        }
+        if (!upstreamText)
             continue;
         const artifactKind = stdout ? "stdout" : "assistant";
         const artifactPath = stdout