@tea-agent/loop-agent 0.28.13 → 0.29.1

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

@@ -8,6 +8,8 @@ import { cleanupPlaywrightCliDefaultSession, createPlaywrightCliTool, PI_COMMAND
 import { dagCommandPolicyAllows, resolveDagCommandPolicy, } from "../workflows/dag/types.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
 import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { isWriterEmptyDiffRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
+import { assessBackendTestMdWriterCompleteness, assessBackendTestPytestWriterCompleteness, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 /** Bounded writer tools: no unrestricted bash; edit/write are policy-wrapped via SDK customTools. */
@@ -338,7 +340,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     }
     let beforeStatus;
     let beforePathFingerprints;
-    if (isWriteTask) {
+    /** tools-only: keep SDK path sandbox; skip git baseline + post-diff write-guard hard fail. */
+    const skipGitWriteGuard = isWriteTask && input.task.writeGuardPolicy === "tools-only";
+    if (isWriteTask && !skipGitWriteGuard) {
         try {
             beforeStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-before" });
             const beforeSnapshot = snapshotGitStatusPorcelain(beforeStatus);
@@ -680,7 +684,39 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             afterStatus: changeManifestAfterStatus ?? "",
         });
     }
-    if (writeGuardOk && !writerOutcomeViolation) {
+    let completenessFailure;
+    if (mapped.ok &&
+        writeGuardOk &&
+        !writerOutcomeViolation &&
+        isBackendTestCompletenessRetryCandidate(input.task)) {
+        try {
+            const progress = input.task.id === "generate-backend-pytest-pi"
+                ? await assessBackendTestPytestWriterCompleteness(input.cwd)
+                : await assessBackendTestMdWriterCompleteness(input.cwd);
+            await writeBackendTestWriterProgressArtifacts({
+                runDir: meta.runDir,
+                progress,
+                attempt: input.attempt ?? 1,
+                maxAttempts: input.task.retryPolicy?.maxAttempts ?? 3,
+            });
+            if (progress.status !== "PASS") {
+                const classified = classifyBackendTestWriterCompletenessFailure(progress);
+                completenessFailure = {
+                    failureCategory: classified.recoverable
+                        ? INCOMPLETE_WRITE_SET_RETRY_CATEGORY
+                        : "invalid-output",
+                    detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
+                };
+            }
+        }
+        catch (error) {
+            completenessFailure = {
+                failureCategory: "invalid-output",
+                detail: `backend-test completeness gate crashed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    if (writeGuardOk && !writerOutcomeViolation && !completenessFailure) {
         return mapped;
     }
     const stderrParts = [mapped.stderr];
@@ -690,6 +726,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     if (writerOutcomeViolation) {
         stderrParts.push(writerOutcomeViolation);
     }
+    if (completenessFailure) {
+        stderrParts.push(completenessFailure.detail);
+    }
     if (meta.writeGuardAttribution === "best-effort") {
         stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
     }
@@ -699,7 +738,13 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         stderr: stderrParts.filter(Boolean).join("\n\n"),
         failureCategory: mapped.ok
             ? writeGuardOk
-                ? "invalid-output"
+                ? completenessFailure
+                    ? completenessFailure.failureCategory
+                    : changeManifestChangedFiles?.length === 0 &&
+                        isWriterEmptyDiffRetryCandidate(input.task) &&
+                        isChangedWriterImplementationOutcome(mapped.assistantText || mapped.stdout)
+                        ? WRITER_EMPTY_DIFF_RETRY_CATEGORY
+                        : "invalid-output"
                 : "write-guard"
             : mapped.failureCategory,
         durationMs: mapped.durationMs || Date.now() - started,
@@ -776,6 +821,10 @@ function parseWriterImplementationOutcome(text) {
 function isWriterImplementationOutcome(value) {
     return (value === "changed" || value === "already-satisfied" || value === "blocked");
 }
+function isChangedWriterImplementationOutcome(text) {
+    const parsed = parseWriterImplementationOutcome(text);
+    return parsed.kind === "valid" && parsed.outcome === "changed";
+}
 function writerOutcomeDiagnostics(text, parsed, changedFiles) {
     const firstNonEmpty = text
         .split(/\r?\n/)

package/dist/executors/pi-playwright-cli-tool.js

@@ -197,15 +197,21 @@ function validateOpenArgs(args, baseUrl) {
     for (const arg of args) {
         assertNoControlMeta(arg);
         assertNoSessionFlag(arg);
-        if (arg === "--browser=chrome" || arg === "--headed") {
+        if (arg === "--browser=chrome" || arg === "--headless") {
             flags.add(arg);
             normalized.push(arg);
             continue;
         }
+        // Accept legacy --headed but normalize to headless for frontend-test CI/dogfood.
+        if (arg === "--headed") {
+            flags.add("--headless");
+            if (!normalized.includes("--headless"))
+                normalized.push("--headless");
+            continue;
+        }
         if (arg.startsWith("--browser=") ||
-            arg === "--browser" ||
-            arg === "--headless") {
-            throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headed only");
+            arg === "--browser") {
+            throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headless only");
         }
         if (/^[a-z][a-z0-9+.-]*:/i.test(arg) || arg.startsWith("http")) {
             url = arg;
@@ -213,12 +219,12 @@ function validateOpenArgs(args, baseUrl) {
         }
         throw new PlaywrightCliPolicyError("open-args", `unsupported open argument: ${arg}`);
     }
-    if (!flags.has("--browser=chrome") || !flags.has("--headed")) {
+    if (!flags.has("--browser=chrome") || !flags.has("--headless")) {
         // controller injects required flags when missing from model args
         if (!flags.has("--browser=chrome"))
             normalized.unshift("--browser=chrome");
-        if (!flags.has("--headed"))
-            normalized.push("--headed");
+        if (!flags.has("--headless"))
+            normalized.push("--headless");
     }
     if (!url) {
         throw new PlaywrightCliPolicyError("open-url-required", "open requires an absolute http(s) URL");
@@ -509,7 +515,7 @@ export function preparePlaywrightCliArgv(input, ctx) {
             catch {
                 throw new PlaywrightCliPolicyError("goto-url-invalid", "goto requires a URL relative to the controller baseUrl");
             }
-            const openLike = validateOpenArgs(["--browser=chrome", "--headed", target], ctx.baseUrl);
+            const openLike = validateOpenArgs(["--browser=chrome", "--headless", target], ctx.baseUrl);
             return openLike[openLike.length - 1];
         });
         if (args.length !== 1) {

package/dist/executors/shell-executor.js

@@ -18,6 +18,7 @@ import { materializeFrontendImplementationContract } from "../workflows/dag/fron
 import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
 import { renderFrontendTestL5Report } from "../workflows/dag/frontend-test-l5-report.js";
 import { validateFrontendCaseChecklist } from "../workflows/dag/frontend-test-case-checklist.js";
+import { materializeFrontendTestCaseManifest } from "../workflows/dag/frontend-test-case-manifest.js";
 import { renderFrontendTestHtmlReport } from "../workflows/dag/frontend-test-html-report.js";
 import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "../workflows/dag/frontend-worktree-diff.js";
@@ -30,6 +31,7 @@ import { materializeBackendTestExecutionContract } from "../workflows/dag/backen
 import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
+import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
 import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assertBackendPytestCollectionFresh, buildBackendPytestAssetInventory, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
@@ -768,6 +770,77 @@ async function executeBackendTestPipeline(input, meta) {
                     durationMs: Date.now() - started,
                 };
             }
+            // Scenario-param consistency (P1): assess -> deterministic repair <=1 -> reassess final.
+            try {
+                const initialAssessment = await assessBackendScenarioParamConsistency({
+                    workspaceRoot: input.cwd,
+                    phase: "initial",
+                    repairAttempt: 0,
+                    strictScenarioParamGate: Boolean((meta.spec.globalConstraints ?? []).some((item) => /strictScenarioParamGate\s*=\s*true/i.test(item))),
+                });
+                const initialArtifacts = await writeBackendScenarioParamArtifacts({
+                    runDir: meta.runDir,
+                    facts: initialAssessment.facts,
+                    markdown: initialAssessment.markdown,
+                });
+                outputs.push(`scenarioParamInitial=${initialArtifacts.reportPath}`, `scenarioParamInitialFacts=${initialArtifacts.factsPath}`);
+                let finalFacts = initialAssessment.facts;
+                let finalMarkdown = initialAssessment.markdown;
+                if (initialAssessment.facts.repairEligible) {
+                    const repair = await applyDeterministicScenarioParamRepairs({
+                        workspaceRoot: input.cwd,
+                        facts: initialAssessment.facts,
+                    });
+                    const auditPath = await writeScenarioParamRepairAudit({
+                        runDir: meta.runDir,
+                        audit: repair.audit,
+                        changedFiles: repair.changedFiles,
+                    });
+                    outputs.push(`scenarioParamRepairAudit=${auditPath}`, `scenarioParamRepaired=${repair.repaired.join(",") || "(none)"}`);
+                    const reassessment = await assessBackendScenarioParamConsistency({
+                        workspaceRoot: input.cwd,
+                        phase: "final",
+                        repairAttempt: 1,
+                        strictScenarioParamGate: initialAssessment.facts.strictScenarioParamGate,
+                    });
+                    finalFacts = reassessment.facts;
+                    finalMarkdown = reassessment.markdown;
+                }
+                else {
+                    finalFacts = {
+                        ...initialAssessment.facts,
+                        phase: "final",
+                        repairAttempt: 0,
+                        repairEligible: false,
+                    };
+                    finalMarkdown = initialAssessment.markdown.replace("Phase: initial", "Phase: final");
+                }
+                const finalArtifacts = await writeBackendScenarioParamArtifacts({
+                    runDir: meta.runDir,
+                    facts: finalFacts,
+                    markdown: finalMarkdown,
+                });
+                outputs.push(`scenarioParamFinal=${finalArtifacts.reportPath}`, `scenarioParamFinalFacts=${finalArtifacts.factsPath}`, `scenarioParamMismatch=${finalFacts.summary.mismatchCount}`, finalMarkdown);
+                if (finalFacts.strictScenarioParamGate &&
+                    finalFacts.summary.mismatchCount > 0) {
+                    return {
+                        ok: false,
+                        stdout: outputs.join("\n\n"),
+                        stderr: "backend-test strict scenario-param gate blocked residual MISMATCH before execute",
+                        failureCategory: "invalid-output",
+                        durationMs: Date.now() - started,
+                    };
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const report = "# Backend Test Scenario-Param Consistency\n\n## Status\n\nUNAVAILABLE\n\n## Findings\n\n- Scenario-param analysis crashed: " +
+                    message +
+                    "\n";
+                const reportPath = await writeRunReport(meta.runDir, "backend-test-scenario-param-consistency.md", report);
+                outputs.push(`scenarioParam=${reportPath}`, report);
+                // Advisory by default: do not fail the node on scenario-param infrastructure errors.
+            }
         }
         else if (pipeline === "markdown-manifest") {
             const sourceBinding = meta.spec.sourceBinding;
@@ -989,6 +1062,69 @@ async function executeBackendTestPipeline(input, meta) {
             });
             const markdownPath = await writeRunReport(meta.runDir, "backend-test.md", facts);
             const factsPath = await writeRunReport(meta.runDir, "backend-test-facts.md", facts);
+            // Structured failure analysis report (P2); emitted even when there are zero failures.
+            let scenarioParamFinalStatus = "UNAVAILABLE";
+            let scenarioParamRepairAttempt = 0;
+            const scenarioParamStatusByToken = new Map();
+            try {
+                const scenarioFacts = await readBackendScenarioParamFacts(path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json"));
+                scenarioParamFinalStatus =
+                    scenarioFacts.summary.mismatchCount > 0 ? "FAIL" : "PASS";
+                scenarioParamRepairAttempt = scenarioFacts.repairAttempt;
+                for (const entry of scenarioFacts.entries) {
+                    scenarioParamStatusByToken.set(entry.caseId, entry.status);
+                    scenarioParamStatusByToken.set(entry.tpId, entry.status);
+                }
+            }
+            catch {
+                // optional facts
+            }
+            const failureCases = parsed.cases.filter((item) => item.status === "failure" || item.status === "error");
+            const failureAnalysisMarkdown = renderBackendTestFailureAnalysis({
+                generatedAt: new Date().toISOString(),
+                htmlReportPath: "reports/backend-test.html",
+                total: parsed.tests,
+                passed: parsed.passed,
+                failed: parsed.failed + parsed.errors,
+                durationLabel: `${parsed.durationMs ?? 0}ms`,
+                environmentSummary: await readFile(path.join(reportsDir, "backend-test-environment.md"), "utf8").catch(() => "unavailable"),
+                scenarioParamFinalStatus,
+                repairAttempt: scenarioParamRepairAttempt,
+                failures: failureCases.map((result) => {
+                    const caseMatch = result.name.match(/\bBE-[A-Z0-9_-]+-\d{2,3}\b/);
+                    const tpMatch = result.name.match(/\bTP-[A-Z0-9-]+\b/);
+                    const caseId = caseMatch?.[0] ?? result.name;
+                    const scenarioParamStatus = (tpMatch && scenarioParamStatusByToken.get(tpMatch[0])) ||
+                        scenarioParamStatusByToken.get(caseId);
+                    const evidence = [result.message, result.details]
+                        .filter(Boolean)
+                        .join("\n");
+                    const statusMatch = /assert\s+(\d{3})\s*==\s*(\d{3})/i.exec(evidence) ||
+                        /expected[^\d]*(\d{3})[\s\S]{0,40}actual[^\d]*(\d{3})/i.exec(evidence);
+                    return {
+                        name: result.name,
+                        caseId,
+                        scenario: cases.find((item) => item.id === caseId)?.scenario ??
+                            cases.find((item) => item.id === caseId)?.title ??
+                            result.name,
+                        expectedCode: statusMatch?.[2] ?? statusMatch?.[1],
+                        actualCode: statusMatch?.[1] ?? statusMatch?.[2],
+                        message: result.message || result.status,
+                        scriptPath: result.classname,
+                        durationLabel: result.durationMs !== undefined
+                            ? `${result.durationMs}ms`
+                            : undefined,
+                        scenarioParamStatus,
+                        classification: classifyBackendTestFailureWithScenarioParam({
+                            message: result.message || "",
+                            details: result.details,
+                            scenarioParamStatus,
+                        }),
+                    };
+                }),
+            });
+            const failureAnalysisPath = await writeRunReport(meta.runDir, "backend-test-failure-analysis.md", failureAnalysisMarkdown);
+            outputs.push(`failureAnalysis=${failureAnalysisPath}`);
             // Deterministic L-5 dashboard: machine-computed metrics (not Pi-generated).
             // manifest is produced by an upstream finalize node; tolerate its absence
             // so a minimal DAG without manifest still gets a degraded dashboard.
@@ -1691,6 +1827,149 @@ async function executeFrontendTestEvidenceValidation(input) {
         };
     }
 }
+async function executeFrontendTestCaseManifest(input, meta) {
+    const started = Date.now();
+    try {
+        const gate = input.task.shell?.frontendTestCaseManifest ?? {};
+        const declaredAcIds = gate.declaredAcIds ??
+            (meta.spec.sourceBinding?.requirementIds ?? []).filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
+        const checklist = await validateFrontendCaseChecklist({
+            workspaceRoot: input.cwd,
+            declaredAcIds,
+        });
+        if (checklist.issues.length) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `frontend-test checklist blocked: ${JSON.stringify(checklist.issues)}`,
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+        const materialized = await materializeFrontendTestCaseManifest({
+            workspaceRoot: input.cwd,
+            maxCases: gate.maxCases,
+            declaredAcIds,
+        });
+        return {
+            ok: true,
+            stdout: `${JSON.stringify({ cases: materialized.cases })}
+`,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+/** Path-escape / cross-case evidence errors must hard-fail finalize (same class as validate.hardFail). */
+function isFrontendTestEvidencePathHardError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /unsafe evidence|escapes (?:evidence root|its allowed root)|evidence realpath|cross-case/i.test(message);
+}
+/**
+ * Lean finalize: evidence validate + result materialize in one shell.
+ * - Case-level missing/malformed evidence is advisory (issues / advisoryFindings);
+ *   the node still succeeds so reports can render incomplete/failed outcomes.
+ * - Path escape / unsafe evidence roots hard-fail the node.
+ * - Controller/contract errors (missing sourceBinding, empty manifest) still fail closed.
+ */
+async function executeFrontendTestResultFinalize(input, meta) {
+    const started = Date.now();
+    let advisoryStdout = "";
+    try {
+        const evidence = await validateFrontendCaseEvidence({
+            workspaceRoot: input.cwd,
+        });
+        advisoryStdout = `frontend case evidence validation cases=${evidence.cases} findings=${evidence.issues.length}${evidence.issues.length ? ` issues=${JSON.stringify(evidence.issues)}` : ""}`;
+        // Advisory findings must not block materialize; only hardFail (path escape) does.
+        if (evidence.hardFail) {
+            return {
+                ok: false,
+                stdout: advisoryStdout,
+                stderr: `frontend-test evidence hard-fail: ${JSON.stringify(evidence.issues)}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        const artifact = await materializeFrontendTestResult({
+            runDir: meta.runDir,
+            workspaceRoot: input.cwd,
+            artifactName: "frontend-test-result.json",
+            outputDir: "contracts",
+            sourceBinding: meta.spec.sourceBinding,
+        });
+        return {
+            ok: true,
+            stdout: `${advisoryStdout}\nStructured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        if (isFrontendTestEvidencePathHardError(error)) {
+            return {
+                ok: false,
+                stdout: advisoryStdout,
+                stderr: `frontend-test evidence hard-fail: ${detail}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        return {
+            ok: false,
+            stdout: advisoryStdout,
+            stderr: detail,
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+async function executeFrontendTestReports(input, meta) {
+    const started = Date.now();
+    try {
+        const writeL5 = input.task.shell?.frontendTestReports?.l5 !== false;
+        const lines = [];
+        if (writeL5) {
+            const l5 = await renderFrontendTestL5Report({
+                workspaceRoot: input.cwd,
+                runDir: meta.runDir,
+            });
+            lines.push(`Frontend L-5 report: ${l5.htmlPath}\nMarkdown: ${l5.markdownPath}\nStatus: ${l5.metrics.status}`);
+        }
+        const report = await renderFrontendTestHtmlReport({
+            workspaceRoot: input.cwd,
+            runDir: meta.runDir,
+        });
+        lines.push(`Frontend test report: ${report.htmlPath}\nMarkdown: ${report.markdownPath}\nOutcome: ${report.outcome}\nCases: ${report.caseCount}`);
+        return {
+            ok: true,
+            stdout: lines.join("\n"),
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
 async function executeFrontendLintBaseline(input, meta) {
     const started = Date.now();
     const shell = input.task.shell;
@@ -1927,15 +2206,24 @@ export async function executeDagShellNode(input, meta) {
     if (shell?.frontendTestCaseChecklist) {
         return executeFrontendTestCaseChecklist(input, meta);
     }
+    if (shell?.frontendTestCaseManifest) {
+        return executeFrontendTestCaseManifest(input, meta);
+    }
     if (shell?.frontendTestEvidenceValidation) {
         return executeFrontendTestEvidenceValidation(input);
     }
+    if (shell?.frontendTestResultFinalize) {
+        return executeFrontendTestResultFinalize(input, meta);
+    }
     if (shell?.frontendTestL5Report) {
         return executeFrontendTestL5Report(input, meta);
     }
     if (shell?.frontendTestHtmlReport) {
         return executeFrontendTestHtmlReport(input, meta);
     }
+    if (shell?.frontendTestReports) {
+        return executeFrontendTestReports(input, meta);
+    }
     if (shell?.backendTestPipeline) {
         return executeBackendTestPipelineWithWriteGuard(input, meta);
     }

package/dist/task/config-types.js

@@ -83,6 +83,27 @@ export const frontendTestConfigSchema = z.object({
      * Default false: pipeline success is result materialize + retrospect report, not full green.
      */
     strictOutcomeGate: z.boolean().optional(),
+    /**
+     * Maximum rerun attempts for blocked or missing-result frontend cases.
+     * Defaults to 2; the static graph always carries a single rerun select+map
+     * pair and bounds candidates within that pair via this value.
+     */
+    maxRerunAttempts: z.number().int().min(0).max(4).optional(),
+    /**
+     * Report chain toggles for the lean frontend-test DAG.
+     * - retrospect: opt-in Pi retrospective node (default off). Pipeline success
+     *   is frontend-test-result-v1 + main HTML/MD report, not the retrospect.
+     * - l5: write the deterministic L-5 dashboard from the merged reports node
+     *   (default true; the merged reports node always renders the main
+     *   HTML/MD report regardless of this flag).
+     */
+    reports: z
+        .object({
+        retrospect: z.boolean().optional(),
+        l5: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
 });
 export const convergenceConfigSchema = z.object({
     enabled: z.boolean().optional().default(false),