@tea-agent/loop-agent 0.35.2 → 0.35.4-beta.0

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

@@ -2199,6 +2199,26 @@ function pruneFrontendTasksForRisk(tasks, risk) {
         return { ...task, depends_on };
     });
 }
+/**
+ * AC-1: shared frontend writer node defaults. frontend-implement-pi and
+ * frontend-repair-pi share one prompt/contract/writeSet-guard surface and an
+ * identical writeSet; only id, depends_on, runIf, outputContract, and
+ * subtask_prompt differ per phase.
+ */
+function buildFrontendWriterNodeDefaults(input) {
+    return {
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: input.complexity,
+        writePolicy: "exclusive",
+        writeSet: input.writeSet,
+        allowedPaths: input.allowedPaths,
+        forbiddenPaths: input.forbiddenPaths,
+        skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
+        writerOutcomePolicy: { type: "implementation-outcome-v1" },
+    };
+}
 async function buildFrontendHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const mockCapability = sources.frontendMockCapability ?? {
@@ -2339,6 +2359,12 @@ async function buildFrontendHybridDagFromTask(sources) {
             `Every requirement MUST have a non-empty expectedOutcome. Every interaction MUST have non-empty trigger and expectedBehavior. UI states with applicable=true MUST have non-empty expectedBehavior. Empty strings or omitted fields for these will cause contract rejection.`,
         ].join("\n")
         : "";
+    const verificationTargetFileInstruction = [
+        `## Verification target file semantics`,
+        `verificationTargets[].file is the code file that the target verifies (the file the writer changes), NOT where the command is defined.`,
+        `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 strategy = resolveDagVerifyStrategy(taskConfig);
     const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
     const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
@@ -2532,6 +2558,10 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 outputMode: "structured-required",
                 retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
+                structuredContractOutput: {
+                    schemaId: "frontend-implementation-contract-v1",
+                    retryOnInvalid: true,
+                },
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
@@ -2545,6 +2575,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "End with exactly one fenced json object conforming to frontend-implementation-contract-v1. This node is the single contract JSON producer: the fenced block is the authoritative contract the prewrite gate materializes. Do not emit any raw JSON, JSON in prose, or a second fenced block anywhere in the response; the plan text must not contain other balanced JSON objects.",
                     "Each requirement must state its user-observable or logic-observable expectedOutcome. Each interaction must state its trigger and expectedBehavior. IDs plus file paths are not sufficient behavior semantics.",
                     requirementCoverageInstruction,
+                    "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.",
                     fixedVerificationContext,
                     sourceContext,
@@ -2584,6 +2616,10 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 outputMode: "structured-required",
                 retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
+                structuredContractOutput: {
+                    schemaId: "frontend-implementation-contract-v1",
+                    retryOnInvalid: true,
+                },
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
@@ -2598,6 +2634,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "End the response with exactly one fenced json object conforming to frontend-implementation-contract-v1. This node is the single contract JSON producer when the design review requests revision: the fenced block is the authoritative contract the prewrite gate materializes. Do not emit any raw JSON, JSON in prose, or a second fenced block anywhere in the response. Bind it to the supplied task sources; map every requirement and applicable UI state to concrete implementation and verification targets or an explicit blocking evidence gap. Do not include secrets or unsafe paths.",
                     "Preserve each requirement expectedOutcome and each interaction trigger/expectedBehavior in the revised 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,
                     fixedVerificationContext,
                     sourceContext,
                     frontendContractSchemaBlock,
@@ -2716,18 +2753,12 @@ async function buildFrontendHybridDagFromTask(sources) {
                         ? ["frontend-lint-baseline-shell"]
                         : []),
                 ],
-                role: "implementer",
-                executor: "pi",
-                toolProfile: "write",
-                complexity: resolveWriterComplexity(taskConfig),
-                writePolicy: "exclusive",
-                writeSet: implementPaths.writeSet,
-                allowedPaths: implementPaths.allowedPaths,
-                forbiddenPaths,
-                skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
-                writerOutcomePolicy: {
-                    type: "implementation-outcome-v1",
-                },
+                ...buildFrontendWriterNodeDefaults({
+                    complexity: resolveWriterComplexity(taskConfig),
+                    writeSet: implementPaths.writeSet,
+                    allowedPaths: implementPaths.allowedPaths,
+                    forbiddenPaths,
+                }),
                 outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
                     "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
@@ -2781,18 +2812,12 @@ async function buildFrontendHybridDagFromTask(sources) {
                 id: "frontend-repair-pi",
                 depends_on: ["frontend-verify-assess-shell", implementId],
                 runIf: "$.nodes['frontend-verify-assess-shell'].json.eligible == true",
-                role: "implementer",
-                executor: "pi",
-                toolProfile: "write",
-                complexity: resolveWriterComplexity(taskConfig),
-                writePolicy: "exclusive",
-                writeSet: implementPaths.writeSet,
-                allowedPaths: implementPaths.allowedPaths,
-                forbiddenPaths,
-                skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
-                writerOutcomePolicy: {
-                    type: "implementation-outcome-v1",
-                },
+                ...buildFrontendWriterNodeDefaults({
+                    complexity: resolveWriterComplexity(taskConfig),
+                    writeSet: implementPaths.writeSet,
+                    allowedPaths: implementPaths.allowedPaths,
+                    forbiddenPaths,
+                }),
                 outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
                 subtask_prompt: [
                     "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",

package/dist/workflows/dag/lifecycle.js

@@ -743,6 +743,7 @@ function findDoctorFailureNode(state) {
             nodeId: state.pausedByNodeId,
             status: node?.status,
             rawFailureCategory: node?.failureCategory,
+            skippedReason: node?.skippedReason,
         };
     }
     const errorEntry = Object.entries(state.nodes).find(([, node]) => node.status === "ERROR");
@@ -758,6 +759,7 @@ function findDoctorFailureNode(state) {
         nodeId: selected[0],
         status: selected[1].status,
         rawFailureCategory: selected[1].failureCategory,
+        skippedReason: selected[1].skippedReason,
     };
 }
 async function readRunOwnedBackendTestClassification(runDir) {
@@ -786,6 +788,7 @@ async function resolveDoctorFailureRouting(input) {
             normalizedFailureCategory: "unknown",
             nodeId: input.nodeId,
             productLineFailureCategory: classifiedCategory,
+            skippedReason: input.skippedReason,
         });
     }
     return routeDagFailure(input);
@@ -807,6 +810,7 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
         rawFailureCategory,
         normalizedFailureCategory: normalizedCategory,
         nodeId: failure.nodeId,
+        skippedReason: failure.skippedReason,
     });
     const evidence = failure.nodeId
         ? path.join(located.runDir, failure.nodeId, "result.summary.md")

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

@@ -4,6 +4,7 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHumanEscalationArtifacts, } from "./decision-envelope.js";
+import { FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT, FRONTEND_WRITER_NODE_IDS, isFrontendWriterAuthorized, readFrontendPrewriteResult, } from "./scheduler.js";
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
@@ -12,6 +13,8 @@ import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry,
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, parseJsonReviewVerdict, validateOutputProtocol, } from "./output-protocol.js";
+import { getStructuredContractValidator } from "./contract-output-registry.js";
+import "./contract-validator-registrations.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";
@@ -138,6 +141,20 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             buildProtocolRetryInstruction(task.outputProtocol, previousProtocolReason),
         ].join("\n");
     }
+    if (previousFailureCategory === "invalid-output" &&
+        task.structuredContractOutput &&
+        previousProtocolReason) {
+        return [
+            basePrompt,
+            "",
+            "<retry_instruction>",
+            "Previous attempt produced an invalid frontend implementation contract:",
+            previousProtocolReason,
+            "Return exactly one fenced json block conforming to the frontend-implementation-contract-v1 schema.",
+            "Fix every reported field violation: do not emit null for optional fields, do not misspell field names, and match the required types exactly.",
+            "</retry_instruction>",
+        ].join("\n");
+    }
     if (previousFailureCategory === "writer-empty-diff") {
         const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
         // When a completeness progress exists for this writer, fold the concrete
@@ -395,6 +412,21 @@ export async function executeDagNode(input) {
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
     };
     const failSkillSnapshot = (error) => failBeforePrompt(error, "skill-snapshot-integrity");
+    const skipFrontendWriter = async (admission) => {
+        const skippedAt = new Date().toISOString();
+        node.startedAt ??= skippedAt;
+        node.frontendWriterAdmission = admission;
+        node.status = "SKIPPED";
+        node.skippedReason = "frontend-prewrite-not-authorized";
+        node.finishedAt = skippedAt;
+        node.lastActivityAt = skippedAt;
+        node.durationMs = durationBetween(node.startedAt, node.finishedAt);
+        node.timing = { retryBackoffMs: 0, settlementCleanupMs: 0 };
+        state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
+        await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);
+        await input.persistState();
+        await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
+    };
     if (task.finalWriteSetApproval) {
         const authorization = parseAndValidateFinalWriteSetApproval({ task, spec, state });
         if (!authorization.ok) {
@@ -423,6 +455,30 @@ export async function executeDagNode(input) {
             effectiveWriteSet: [...authorization.effectiveWriteSet],
         };
     }
+    if (FRONTEND_WRITER_NODE_IDS.includes(nodeId)) {
+        const admission = await readFrontendPrewriteResult(runDir);
+        if (!admission.ok) {
+            await skipFrontendWriter(undefined);
+            return;
+        }
+        const decision = isFrontendWriterAuthorized(admission.result);
+        const record = {
+            schemaVersion: 1,
+            writerNodeId: nodeId,
+            decision,
+            sourceArtifact: FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT,
+            artifactHash: admission.artifactHash,
+            checkedAt: new Date().toISOString(),
+            reason: decision === "denied"
+                ? `classification: ${admission.result.classification}`
+                : null,
+        };
+        if (decision === "denied") {
+            await skipFrontendWriter(record);
+            return;
+        }
+        node.frontendWriterAdmission = record;
+    }
     let projectGovernanceContext;
     if (task.governanceStandardReview) {
         try {
@@ -689,6 +745,39 @@ export async function executeDagNode(input) {
                 previousProtocolReason = undefined;
             }
         }
+        // R1: structured contract nodes self-validate their output so schema,
+        // typo, and null violations surface as retryable invalid-output at the
+        // producing node instead of failing the whole run at the prewrite gate.
+        if (result.ok && task.structuredContractOutput) {
+            const validator = getStructuredContractValidator(task.structuredContractOutput.schemaId);
+            if (validator) {
+                const contractText = canonicalNodeOutput(result);
+                const contractCheck = await validator({
+                    runDir,
+                    text: contractText,
+                    sourceBinding: spec.sourceBinding,
+                });
+                if (!contractCheck.ok) {
+                    result = {
+                        ...result,
+                        ok: false,
+                        failureCategory: "invalid-output",
+                        stderr: [result.stderr, contractCheck.reason]
+                            .filter(Boolean)
+                            .join("\n"),
+                    };
+                    previousProtocolReason = contractCheck.reason;
+                }
+                else {
+                    previousProtocolReason = undefined;
+                }
+            }
+            else {
+                // DAG spec validation rejects unknown schemaIds; this is a
+                // defensive fallback for a registry that has not been populated.
+                console.warn(`[run-dag] warning: no structured contract validator registered for schemaId ${task.structuredContractOutput.schemaId}; skipping node self-check`);
+            }
+        }
         const attemptFinishedAt = new Date().toISOString();
         const attemptWallDurationMs = durationBetween(attemptStartedAt, attemptFinishedAt);
         totalAttemptWallDurationMs += attemptWallDurationMs;

package/dist/workflows/dag/recovery-recommendation.js

@@ -269,3 +269,61 @@ export function planDagRecovery(input) {
     }
     return planByNormalizedCategory(input);
 }
+/**
+ * Phase 6: route a frontend recovery outcome to a recovery CTA (read-only; never
+ * mutates a run's status). The six outcomes map to the existing recovery actions
+ * so the Console recovery page reuses the current CTA surface.
+ */
+export function recommendFrontendRecoveryOutcome(outcome) {
+    switch (outcome) {
+        case "none":
+            return {
+                action: "none",
+                summary: "未发生前端恢复；按普通终态展示。",
+                reason: "该 frontend-implementation 根没有触发自动恢复。",
+                humanRequired: false,
+                autoRetryEligible: false,
+            };
+        case "recovered":
+            return {
+                action: "none",
+                summary: "自动恢复成功；child 已重新实现并通过验证。",
+                reason: "parent 的 transient 失败已由 child 恢复，全链按 root 计一次成功。",
+                humanRequired: false,
+                autoRetryEligible: false,
+            };
+        case "candidate-contract-invalid":
+            return {
+                action: "manual-review",
+                summary: "方案输出无效：candidate JSON 无法解析/推导，重试用尽。",
+                reason: "建议人工检查需求或重新生成方案后再跑。",
+                humanRequired: true,
+                autoRetryEligible: false,
+            };
+        case "prewrite-blocked":
+            return {
+                action: "manual-review",
+                summary: "治理门禁阻断：source stale / writeSet 越界 / Mock policy / contract 违规。",
+                reason: "需人工修正任务边界/事实后重跑，不自动重试。",
+                humanRequired: true,
+                autoRetryEligible: false,
+            };
+        case "repair-exhausted":
+            return {
+                action: "rerun-after-fix",
+                summary: "自动修复未通过：verify 失败，1 次 repair 后 reverify 仍失败。",
+                reason: "建议 `dag rerun` 或人工排查。",
+                humanRequired: true,
+                autoRetryEligible: false,
+                commandHint: "loop-agent dag rerun --run-id <runId>",
+            };
+        case "auto-recovery-blocked":
+            return {
+                action: "manual-review",
+                summary: "自动恢复被阻止：rollback 无法证明完整或存在外部/越界修改。",
+                reason: "必须人工介入，禁止自动覆盖用户文件。",
+                humanRequired: true,
+                autoRetryEligible: false,
+            };
+    }
+}

package/dist/workflows/dag/report.js

@@ -441,6 +441,7 @@ export async function buildDagRunReportEntry(input) {
                 normalizedFailureCategory,
                 nodeId,
                 executor: node.executor,
+                skippedReason: node.skippedReason,
             });
             const followUp = node.status === "ERROR" || node.status === "SKIPPED"
                 ? recommendFollowUpForFailureCategory(node.failureCategory)
@@ -505,6 +506,7 @@ export async function buildDagRunReportEntry(input) {
             normalizedFailureCategory: normalizeDagFailureCategory(pausedNode.failureCategory, pausedNode.status),
             failureCategory: pausedNode.failureCategory,
             nodeId: input.state.pausedByNodeId,
+            skippedReason: pausedNode.skippedReason,
         }
         : firstActionableNode
             ? {
@@ -513,6 +515,7 @@ export async function buildDagRunReportEntry(input) {
                     normalizeDagFailureCategory(firstActionableNode.failureCategory, firstActionableNode.status),
                 failureCategory: firstActionableNode.failureCategory,
                 nodeId: firstActionableNode.nodeId,
+                skippedReason: input.state.nodes[firstActionableNode.nodeId]?.skippedReason,
             }
             : {
                 status: input.state.status,
@@ -529,6 +532,9 @@ export async function buildDagRunReportEntry(input) {
         rawFailureCategory: runRecoverySource.failureCategory,
         normalizedFailureCategory: runRecoverySource.normalizedFailureCategory,
         nodeId: "nodeId" in runRecoverySource ? runRecoverySource.nodeId : undefined,
+        skippedReason: "skippedReason" in runRecoverySource
+            ? runRecoverySource.skippedReason
+            : undefined,
     });
     const runFollowUp = input.state.status === "failed" ||
         input.state.status === "partial_failed"