@tea-agent/loop-agent 0.42.0-next.8 → 0.42.0-next.9

package/dist/executors/shell-executor.js

@@ -2299,19 +2299,38 @@ async function collectReviewRestartPhase(runDir, reviewNodeId) {
 }
 /** A+B (AC-009): deterministic §4.10 restart phase for a committed
  * `request_design_changes` fact. Mirrors the review collector. */
-/** Number of findings attached to the committed request_design_changes
- * terminal fact (0 when absent) — used for the admission advisory. */
-async function collectDesignReviewFindingCount(runDir, designNodeId) {
+/** Read the committed design request as a bounded structured capsule. */
+async function collectDesignReviewFindings(runDir, designNodeId) {
     try {
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, designNodeId, "design-typed-facts.jsonl"));
         const request = records.find((record) => record.phase === "committed" &&
             record.fact.kind ===
                 "request_design_changes");
-        const findings = (request?.fact).findings;
-        return Array.isArray(findings) ? findings.length : 0;
+        const fact = request?.fact;
+        const findings = Array.isArray(fact?.findings)
+            ? fact.findings.flatMap((finding) => {
+                if (!finding || typeof finding !== "object")
+                    return [];
+                const value = finding;
+                if (!(["Critical", "Important", "Minor", "Info"].includes(value.severity) &&
+                    typeof value.issue === "string" && value.issue.trim().length > 0))
+                    return [];
+                return [{
+                        severity: value.severity,
+                        ...(typeof value.file === "string" && value.file.trim() ? { file: value.file } : {}),
+                        ...(typeof value.line === "number" && Number.isInteger(value.line) && value.line > 0 ? { line: value.line } : {}),
+                        issue: value.issue,
+                        ...(typeof value.requiredChange === "string" && value.requiredChange.trim() ? { requiredChange: value.requiredChange } : {}),
+                    }];
+            }).slice(0, 16)
+            : [];
+        const evidenceRefs = Array.isArray(fact?.evidenceRefs)
+            ? fact.evidenceRefs.filter((ref) => typeof ref === "string" && ref.trim().length > 0).slice(0, 16)
+            : [];
+        return { findings, evidenceRefs };
     }
     catch {
-        return 0;
+        return { findings: [], evidenceRefs: [] };
     }
 }
 async function collectDesignRestartPhase(runDir, designNodeId) {
@@ -2625,17 +2644,15 @@ async function executeFrontendWriterAdmission(input, meta) {
     const shell = input.task.shell;
     const config = shell.frontendWriterAdmission;
     try {
-        // 1. Design verdict handling (r12 policy change). The typed terminal
+        // 1. Design verdict handling. The typed terminal
         // verdict is read from the committed typed design terminal fact, not
         // from the legacy first-line VERDICT text protocol (AC-003/AC-004).
-        // A request_design_changes verdict no longer blocks writer admission:
-        // it is downgraded to an advisory that rides along in the admission
-        // receipt (and reaches implement via the review node's upstream
-        // context). Blocking is owned by the deterministic gates (prewrite,
-        // write guard) and the final code review. A missing typed terminal
-        // verdict still fails closed. In small topology the design review node
-        // is absent and the check is vacuous.
+        // A request_design_changes verdict blocks writer admission and is copied
+        // into the receipt as a bounded advisory capsule for recovery. A missing
+        // typed terminal verdict still fails closed. In small topology the design
+        // review node is absent and the check is vacuous.
         let verdictPass = true;
+        let designRequested = false;
         let designAdvisory;
         if (config.designReviewFromNodeId) {
             const designKinds = await collectDesignTerminalKinds(meta.runDir, config.designReviewFromNodeId);
@@ -2643,11 +2660,16 @@ async function executeFrontendWriterAdmission(input, meta) {
                 verdictPass = false;
             }
             else if (designKinds[0] !== "approve_design") {
+                designRequested = true;
+                const designFindings = await collectDesignReviewFindings(meta.runDir, config.designReviewFromNodeId);
                 designAdvisory = {
-                    verdict: designKinds[0],
+                    verdict: "request_design_changes",
                     restartPhase: await collectDesignRestartPhase(meta.runDir, config.designReviewFromNodeId),
-                    findingCount: await collectDesignReviewFindingCount(meta.runDir, config.designReviewFromNodeId),
+                    findingCount: designFindings.findings.length,
+                    findings: designFindings.findings,
+                    evidenceRefs: designFindings.evidenceRefs,
                 };
+                verdictPass = false;
             }
         }
         // 2. Read the canonical contract + design-policy result.
@@ -2715,7 +2737,9 @@ async function executeFrontendWriterAdmission(input, meta) {
             allowedMockStrategies: config.allowedMockStrategies,
             workspaceFiles,
         });
-        // 6. Design verdict enforcement: request-revision is a blocked admission.
+        // 6. Design verdict enforcement: request_design_changes is a blocked
+        // admission. This keeps the writer fail-closed until the recovery plan
+        // has incorporated the reviewer's concrete findings.
         const failureSource = policyRaw.classification === "blocked"
             ? "frontend-design-policy-shell"
             : "frontend-writer-admission-shell";
@@ -2724,8 +2748,12 @@ async function executeFrontendWriterAdmission(input, meta) {
             : [
                 ...admission.findings,
                 {
-                    code: "design-approval-missing",
-                    message: "design review typed terminal verdict missing or ambiguous (fail closed)",
+                    code: designRequested
+                        ? "design-review-requested"
+                        : "design-approval-missing",
+                    message: designRequested
+                        ? "design review requested changes; writer admission is blocked until recovery incorporates the committed findings"
+                        : "design review typed terminal verdict missing or ambiguous (fail closed)",
                 },
             ];
         const classification = findings.length === 0 && admission.classification === "accepted"

package/dist/worker/observe/routes.js

@@ -278,6 +278,10 @@ export async function serveObserveStatic(req, res, staticDir, options = {}) {
         "Content-Length": content.byteLength,
         "X-Content-Type-Options": "nosniff",
         "X-Frame-Options": "SAMEORIGIN",
+        // Filenames are unhashed and Console/observe builds change in place;
+        // heuristic caching would let a stale operator-chrome.js (old nav,
+        // old capabilities) survive a Console restart/update.
+        "Cache-Control": "no-store",
     };
     if (contentType.startsWith("text/html") && options.htmlEnhancer) {
         const enhanced = options.htmlEnhancer(Buffer.from(content));

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

@@ -1482,6 +1482,13 @@ for top in ast.walk(tree):
                 for keyword in node.keywords:
                     if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
                         transport.append((keyword.value.id,positional.index(keyword.value.id)-call_offset))
+                    if keyword.arg is None and isinstance(keyword.value,ast.Name):
+                        alias=keyword.value.id
+                        assigned_value=assigned.get(alias)
+                        if isinstance(assigned_value,ast.Name) and assigned_value.id in positional:
+                            transport.append((assigned_value.id,positional.index(assigned_value.id)-call_offset))
+                        elif isinstance(assigned_value,ast.Call) and isinstance(assigned_value.func,ast.Name) and assigned_value.func.id == 'dict' and assigned_value.args and isinstance(assigned_value.args[0],ast.Name) and assigned_value.args[0].id in positional:
+                            transport.append((assigned_value.args[0].id,positional.index(assigned_value.args[0].id)-call_offset))
                 if isinstance(node.func,ast.Attribute) and node.func.attr.lower() in {'post','put','patch'} and len(node.args) >= 2:
                     candidate=node.args[1]
                     if isinstance(candidate,ast.Name) and candidate.id in positional:
@@ -1493,6 +1500,17 @@ for top in ast.walk(tree):
                     matched=node.args[nested_position] if nested_position >= 0 and nested_position < len(node.args) else None
                     if isinstance(matched,ast.Name) and matched.id in positional:
                         transport.append((matched.id,positional.index(matched.id)-call_offset))
+        # Assignment order in ast.walk is not source order. Re-scan **kwargs
+        # aliases once the complete local assignment table is available.
+        for node in ast.walk(top):
+            if not isinstance(node,ast.Call): continue
+            for keyword in node.keywords:
+                if keyword.arg is not None or not isinstance(keyword.value,ast.Name): continue
+                assigned_value=assigned.get(keyword.value.id)
+                if isinstance(assigned_value,ast.Name) and assigned_value.id in positional:
+                    transport.append((assigned_value.id,positional.index(assigned_value.id)-call_offset))
+                elif isinstance(assigned_value,ast.Call) and isinstance(assigned_value.func,ast.Name) and assigned_value.func.id == 'dict' and assigned_value.args and isinstance(assigned_value.args[0],ast.Name) and assigned_value.args[0].id in positional:
+                    transport.append((assigned_value.args[0].id,positional.index(assigned_value.args[0].id)-call_offset))
         for returned_name in returned_names:
             entries=mutated.get(returned_name,[])
             if entries:

package/dist/workflows/dag/backend-test-scenario-param.js

@@ -1476,6 +1476,32 @@ function hasSafeSameModulePayloadHelper(source, block, parameterNames) {
         return false;
     return Boolean(safeSameModuleDictHelper(source, call.name));
 }
+function observeBranchPayloadField(input) {
+    const region = scenarioFunctionRegion(input.source, input.tpId);
+    if (!region || !input.block)
+        return undefined;
+    const args = extractPytestParamTopLevelArgs(input.block);
+    const escapedField = input.field.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+    for (let index = 0; index < input.parameterNames.length; index += 1) {
+        const parameter = input.parameterNames[index];
+        const raw = args[index]?.trim();
+        if (!raw || !/^['\"](?:[^'\"\\\\]|\\\\.)*['\"]$/.test(raw))
+            continue;
+        const branchValue = raw.slice(1, -1).replace(/\\\\([\\\"'])/g, "$1");
+        const escapedParameter = parameter.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+        const escapedBranchValue = branchValue.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+        const branch = new RegExp(`(?:^|\\n)([ \\t]*)if\\s+${escapedParameter}\\s*==\\s*['\"]${escapedBranchValue}['\"]\\s*:\\s*([\\s\\S]*?)(?=\\n\\1(?:elif\\b|else\\s*:)|\\n\\1(?:if\\b|def\\b)|$)`, "m").exec(region)?.[2];
+        if (!branch)
+            continue;
+        const value = new RegExp(`['\"]${escapedField}['\"]\\s*:\\s*([^,}\\n]+)`).exec(branch)?.[1];
+        if (!value)
+            continue;
+        const observed = observeLiteralToken(value.trim(), input.field, input.constants);
+        if (observed)
+            return observed;
+    }
+    return undefined;
+}
 function observeDeterministicFunctionFieldOverride(input) {
     const region = scenarioFunctionRegion(input.source, input.tpId);
     if (!region)
@@ -1608,7 +1634,10 @@ export async function assessBackendScenarioParamConsistency(input) {
                     constants,
                 })
                 : undefined;
-            const observed = functionFieldOverride ?? helperFieldObserved ?? observeParamFeatures(block, inferred.field, constants, parameterNames);
+            const branchFieldObserved = source && inferred.field
+                ? observeBranchPayloadField({ source, tpId, block, parameterNames, field: inferred.field, constants })
+                : undefined;
+            const observed = functionFieldOverride ?? helperFieldObserved ?? branchFieldObserved ?? observeParamFeatures(block, inferred.field, constants, parameterNames);
             // Request-level / health checks often have no pytest.param payload row,
             // or only a TP-id label positional (no field value).
             const requestLevelNoParam = Boolean(source) &&

package/dist/workflows/dag/frontend-recovery-plan.js

@@ -26,7 +26,8 @@ export function deriveFrontendRecoveryFailureSource(result) {
  * Compute the frontend candidate-continuation reset partition:
  * - `frontend-plan-pi` failure → reset plan + design-review + policy/admission (+ descendants);
  * - `frontend-design-policy-shell` failure → reset policy/admission (+ descendants);
- * - admission/design-review failure → reset writer admission (+ descendants);
+ * - design-review rejection → reset plan + design review + admission (+ descendants);
+ * - other admission failures → reset writer admission (+ descendants);
  *
  * Everything upstream of the failure source is imported as verified parent facts.
  */

package/dist/workflows/dag/frontend-recovery-run.js

@@ -275,7 +275,35 @@ async function casUpdateFrontendRecoveryState(parentRunDir, expectedRevision, de
 async function materializeChildStaging(input) {
     const { cwd, parentRunDir, parentRunId, parentSpec, parentState, recovery, requestId, childRunId, stagingDir, createdAt, } = input;
     await prepareRunDir(stagingDir);
-    await writeJsonVerified(stagingDir, "run.json", parentSpec);
+    // Design-review rejection must be visible to the reset planner. Recovery
+    // children otherwise copy the old spec and only rerun design review, which
+    // deterministically re-rejects the unchanged plan. Bind the parent's typed
+    // findings into the child spec as ordinary rerun feedback.
+    let childSpec = parentSpec;
+    if (recovery.failureSource === "frontend-plan-pi") {
+        try {
+            const { deriveDagRerunFeedback } = await import("./rerun-feedback.js");
+            const taskId = parentSpec.taskContractBinding?.taskId ??
+                parentSpec.sourceBinding?.taskId ??
+                parentRunId;
+            const feedback = await deriveDagRerunFeedback({
+                parentRunId,
+                taskId,
+                runDir: parentRunDir,
+                spec: parentSpec,
+                state: parentState,
+            });
+            if (feedback)
+                childSpec = { ...parentSpec, rerunFeedback: feedback };
+        }
+        catch (error) {
+            // A design rejection cannot be safely retried without its typed
+            // findings. Fail closed instead of deterministically re-running the
+            // unchanged plan and producing another rejection.
+            throw new Error(`frontend recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    await writeJsonVerified(stagingDir, "run.json", childSpec);
     // Phase 5: writer transient partial-write recovery resets the writer subtree
     // (frontend-implement-pi) instead of the candidate producer; everything
     // upstream is imported as verified parent facts.
@@ -300,10 +328,10 @@ async function materializeChildStaging(input) {
             result: admissionRead.result,
         });
     }
-    const { ranks } = topoSortToRanks(parentSpec);
+    const { ranks } = topoSortToRanks(childSpec);
     const resetSet = new Set(plan.resetNodeIds);
     const importedSet = new Set(plan.importedNodeIds);
-    const tasksById = new Map(parentSpec.tasks.map((task) => [task.id, task]));
+    const tasksById = new Map(childSpec.tasks.map((task) => [task.id, task]));
     const nodes = {};
     const importedFacts = [];
     for (const nodeId of plan.importedNodeIds) {
@@ -328,7 +356,7 @@ async function materializeChildStaging(input) {
         }
         nodes[nodeId] = buildPendingNodeRecord(task);
     }
-    for (const task of parentSpec.tasks) {
+    for (const task of childSpec.tasks) {
         if (!resetSet.has(task.id) && !importedSet.has(task.id)) {
             throw new Error(`node ${task.id} missing from frontend recovery plan partition`);
         }
@@ -338,7 +366,7 @@ async function materializeChildStaging(input) {
     const canonicalContract = await copyArtifactVerified({
         parentRunDir,
         newRunDir: stagingDir,
-        relativePath: resolveCanonicalContractRelPath(parentSpec),
+        relativePath: resolveCanonicalContractRelPath(childSpec),
     });
     const writerAdmissionResult = await copyArtifactVerified({
         parentRunDir,

package/dist/workflows/dag/frontend-writer-admission.js

@@ -22,8 +22,9 @@ export const frontendWriterAdmissionClassificationSchema = z.enum([
     "requires-human-approval",
     "blocked",
     "stale",
-    // Legacy fixture alias: writeSet-external test helpers still emit `admitted`.
-    // Canonical producers always emit one of the four values above.
+    // Legacy artifacts remain parseable for diagnostics, but `admitted` is never
+    // accepted by the runtime authorization gate. Canonical producers always
+    // emit one of the four values above.
     "admitted",
 ]);
 /** A+B (AC-006): Micro topology uses `requirement-to-target-and-evidence`
@@ -78,16 +79,22 @@ export const frontendWriterAdmissionResultV1Schema = z
         path: z.string().optional(),
     })
         .strict()),
-    // r12 policy change: a request_design_changes verdict no longer blocks
-    // writer admission. The verdict and its findings ride along as
-    // advisory context for the implement node; blocking is owned by the
-    // deterministic gates (prewrite, write guard) and the final code
-    // review.
+    // Design findings are preserved as a bounded, structured capsule. A
+    // request_design_changes verdict is a blocking admission decision; the
+    // capsule is consumed by recovery and by any explicitly authorized retry.
     designReviewAdvisory: z
         .object({
         verdict: z.enum(["approve_design", "request_design_changes"]),
         restartPhase: z.string().min(1).optional(),
         findingCount: z.number().int().nonnegative(),
+        findings: z.array(z.object({
+            severity: z.enum(["Critical", "Important", "Minor", "Info"]),
+            file: z.string().min(1).optional(),
+            line: z.number().int().positive().optional(),
+            issue: z.string().min(1),
+            requiredChange: z.string().min(1).optional(),
+        }).strict()),
+        evidenceRefs: z.array(z.string().min(1)),
     })
         .strict()
         .optional(),
@@ -115,7 +122,7 @@ export function isConcreteWriteSetPath(value) {
     const path = value.trim();
     if (path === "" || path === "." || path === "./")
         return false;
-    if (path.startsWith("/") || path.includes("\\"))
+    if (path.startsWith("/") || path.includes("\\") || path.includes("*") || path.includes("?"))
         return false;
     const segments = path.split("/");
     if (segments.some((segment) => segment === ".." || segment === "**" || segment === "")) {
@@ -123,6 +130,32 @@ export function isConcreteWriteSetPath(value) {
     }
     return true;
 }
+export function normalizeConcreteWriteSetPath(value) {
+    const normalized = value.trim();
+    return isConcreteWriteSetPath(normalized) ? normalized : undefined;
+}
+/**
+ * Deterministically extract repository file paths that frozen verification
+ * commands operate on (`--config <file>`, `node --check <file>`). The plan's
+ * verification targets do not always name verification infrastructure (a
+ * vitest config, fixtures), yet verify-shell cannot run without it and the
+ * writer cannot create it unless the effective writeSet authorizes the file.
+ */
+export function collectVerificationCommandFiles(commands) {
+    const files = new Set();
+    const configRe = /--config\s+([\w@./-]+\.(?:js|mjs|cjs|ts|json))/g;
+    const checkRe = /node\s+--check\s+([\w@./-]+\.(?:js|mjs|cjs))/g;
+    for (const command of commands) {
+        for (const re of [configRe, checkRe]) {
+            for (const match of command.matchAll(re)) {
+                const file = match[1];
+                if (file && file.includes("/"))
+                    files.add(file);
+            }
+        }
+    }
+    return [...files].sort();
+}
 /** Derive the concrete writeSet from implementation targets ∪ non-static
  * verification target files. Entries are de-duplicated and lexicographically
  * sorted (frozen). */
@@ -146,7 +179,8 @@ export function deriveWriteSet(contract, options) {
         : candidates;
     const writeSet = new Set();
     for (const candidate of expanded) {
-        if (!isConcreteWriteSetPath(candidate)) {
+        const normalized = normalizeConcreteWriteSetPath(candidate);
+        if (!normalized) {
             findings.push({
                 code: "write-set-path-not-concrete",
                 message: `writeSet entry is not a concrete path: ${candidate}`,
@@ -154,7 +188,7 @@ export function deriveWriteSet(contract, options) {
             });
             continue;
         }
-        writeSet.add(candidate);
+        writeSet.add(normalized);
     }
     return { writeSet: [...writeSet].sort(), findings };
 }

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

@@ -3473,7 +3473,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "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.",
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_design or request_design_changes. Call exactly one of them; after calling one, do not call the other.",
                     "request_design_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
-                    "Your verdict is consumed only as deterministic data input by frontend-writer-admission-shell; it no longer drives any branch or gate. request_design_changes blocks writer admission (terminal).",
+                    "Your verdict is consumed as deterministic data input by frontend-writer-admission-shell. approve_design permits admission; request_design_changes blocks writer admission until a recovery plan incorporates every Critical/Important finding.",
                     "Request design changes 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 design changes 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.",
                     "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; when a decision=specified specReference.path is missing a ledger OpenSpec reference or successful read event; or when a decision=new component lacks a traceable task-source/PRD specReference. A PRD reference for decision=new is not an OpenSpec citation and must not be rejected merely for lacking an OpenSpec read event.",
@@ -3554,6 +3554,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Execute in fixed stages and report each in the delivery summary: (1) Contract confirm, (2) Tests sync, (3) Component/UI state implementation, (4) API/Mock wiring per contract.mockApi, (5) Focused checks behind frozen entrypoints only, (6) Diff cleanup.",
                     "Map every requirement id, expectedOutcome, interaction trigger/expectedBehavior, and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
                     "For every non-static verification target, treat target.id as a stable trace token and include that exact token in a real describe/it/test literal title (for example, it('[VT-DASHBOARD-SHELL] renders the dashboard', ...)). One test title may carry multiple target ids when it proves multiple grouped behaviors; comments and ordinary strings do not count as trace evidence.",
+                    "Before reporting Tests Changed as done, self-audit with the executor's rule: collect ONLY the string literals passed directly to describe(/it(/test( calls in each test file and confirm every non-static target id for that file appears inside one of those literals. A token in a comment, a variable, or a non-title string does not satisfy the trace check; if any id is missing from the literal titles, edit the title strings before finishing.",
                     "Begin implementation after the contract and its target files are confirmed. Do not spend the turn collecting optional context. If the canonical contract lacks behavior needed to edit safely, stop and state the blocking reason in the summary instead of reopening broad discovery.",
                     "Your implementation status is derived by the executor from mechanical facts (persisted write-tool events, run delta, write guard, requirement coverage, focused-check failures), never from any IMPLEMENTATION_OUTCOME first line. Do not emit an IMPLEMENTATION_OUTCOME first line.",
                     "The node runs a bounded micro-loop: after each write attempt the executor re-runs frozen focused checks and records a per-round diff checkpoint; the write guard stays active every round. Only repair local issues attributable to the current diff (syntax/type/import/format/unit-assert/obvious omission). Never change requirements, design, writeSet, or verification strictness inside the loop.",
@@ -5095,7 +5096,7 @@ async function buildBackendTestHybridDag(sources) {
                 ]
                 : []),
             "Include exactly one `## Module Index` table with this exact header: `| Module Stem | Business Resource | Owned Operations | Owned Rule Keys | Case IDs | Split Reason | Markdown Path | Pytest Path |`. Use canonical relative links `[label](./<stem>.md)` inside the Markdown Path cell followed by the resolved `${layout.markdownDir}/<stem>.md` path. Split Reason is exactly one of `explicit-user-layout`, `primary-business-resource`, `independent-business-resource`, or `output-budget`. Group by stable business resource/domain, not by CRUD operation, AC, parameter/field axis, scenario type or regression purpose: one resource's list/detail/create/update/delete and its filters/response assertions/regression floor belong in one module. Multiple modules owning the same exact `METHOD /path` are forbidden unless every such row is `explicit-user-layout` from primary-requirement path pairs or has a documented `output-budget` proof. Keep the total module count at the smallest safe value and never exceed 8 modules. Name model-derived modules with stable lowercase business stems such as `health` or `resource_notes`; explicit-user-layout preserves the primary requirement filename stem even when it is more specific. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix. Pure hexadecimal/hash-like opaque stems and test-purpose-only stems are forbidden. Do not use Case-ID-like module filenames. The relative link target, Markdown Path, Pytest Path and downstream automation mapping must be one-to-one and exact; for model-derived modules the default pair remains `testcase/md/<module>.md` and `testcase/test_<module>.py`, while explicit-user-layout preserves the primary requirement paths. Do not hand-write a conflicting module count in prose; the Module Index row count is the only count truth.",
-            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. Scheme A: Case count may be smaller than the enum count, but every exact slot still needs an independent variant Test Point and pytest.param id; never use SINGLE/MULTIPLE aliases as coverage. Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
+            "Scenario Partitions (query/filter axes): inspect every affected GET/list operation for query/path parameters whose bound source documents a finite enum or classification domain. If at least one such axis exists, add exactly one machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row and one row per eligible axis. If no affected axis has a source-backed finite domain, omit the entire `## Scenario Partitions` heading and section; do not emit an explanatory prose-only section. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. Scheme A: Case count may be smaller than the enum count, but every exact slot still needs an independent variant Test Point and pytest.param id; never use SINGLE/MULTIPLE aliases as coverage. Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
             "Before finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
             intake.boundedSourceContext,

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

@@ -6,6 +6,7 @@ import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.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 { collectVerificationCommandFiles, } from "./frontend-writer-admission.js";
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
@@ -1282,6 +1283,52 @@ export async function executeDagNode(input) {
             await skipFrontendWriter(record);
             return;
         }
+        // The admission artifact is the effective authorization boundary. Never
+        // leave the writer using the broad task glob after the shell has frozen a
+        // concrete set: doing so makes the receipt auditable but unenforceable.
+        // Files referenced by frozen verification commands are unioned in: the
+        // plan's verification targets do not always name verification
+        // infrastructure, yet verify-shell cannot run without it and the writer
+        // must be authorized to create it.
+        const admissionWriteSetEntries = admission.result.writeSet.map((entry) => entry.trim().replace(/\\/g, "/").replace(/^\.\//, ""));
+        const frozenVerificationBundle = spec.tasks.find((specTask) => specTask.shell?.frontendVerificationBundle)?.shell?.frontendVerificationBundle;
+        const verificationCommandFiles = frozenVerificationBundle
+            ? collectVerificationCommandFiles([
+                ...(frozenVerificationBundle.staticCommands ?? []),
+                ...(frozenVerificationBundle.behaviorCommands ?? []),
+                ...(frozenVerificationBundle.mockCommands ?? []),
+                ...(frozenVerificationBundle.lintCommands ?? []),
+            ])
+            : [];
+        const extraVerificationFiles = verificationCommandFiles.filter((file) => !admissionWriteSetEntries.includes(file) &&
+            file &&
+            !file.includes("*") &&
+            !file.includes("?") &&
+            !file.split("/").some((segment) => segment === "..") &&
+            task.allowedPaths.some((allowed) => pathMatchesPattern(file, allowed)) &&
+            !task.forbiddenPaths.some((forbidden) => pathMatchesPattern(file, forbidden)));
+        const admittedWriteSet = [
+            ...new Set([...admissionWriteSetEntries, ...extraVerificationFiles]),
+        ];
+        if (admittedWriteSet.length === 0 ||
+            new Set(admittedWriteSet).size !== admittedWriteSet.length ||
+            admittedWriteSet.some((entry) => !entry ||
+                entry.includes("*") ||
+                entry.includes("?") ||
+                entry.split("/").some((segment) => segment === "..") ||
+                !task.allowedPaths.some((allowed) => pathMatchesPattern(entry, allowed)) ||
+                task.forbiddenPaths.some((forbidden) => pathMatchesPattern(entry, forbidden)))) {
+            await failBeforePrompt(new Error("frontend writer admission contains an invalid effective writeSet"), "final-write-set-approval-invalid");
+            return;
+        }
+        task = { ...task, writeSet: admittedWriteSet };
+        node.runtimeWriteAuthorization = {
+            schemaVersion: 1,
+            status: "validated",
+            approvalSourceNodeId: FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT,
+            approvalDigest: admission.result.admissionDigest,
+            effectiveWriteSet: [...admittedWriteSet],
+        };
         node.frontendWriterAdmission = record;
     }
     let projectGovernanceContext;
@@ -1457,6 +1504,26 @@ export async function executeDagNode(input) {
             return;
         }
     }
+    if (FRONTEND_WRITER_NODE_IDS.includes(nodeId)) {
+        // Design-review findings are not reliable in the provider's prose output
+        // (typed terminal nodes commonly return an empty assistant message). Inject
+        // the bounded admission capsule explicitly so an authorized retry has the
+        // reviewer's concrete issue/evidence context.
+        try {
+            const admission = await readFrontendPrewriteResult(runDir);
+            const advisory = admission.ok ? admission.result.designReviewAdvisory : undefined;
+            if (advisory?.findings?.length || advisory?.evidenceRefs?.length) {
+                prompt = `${prompt}\n\n<design_review_findings>\n${JSON.stringify({
+                    verdict: advisory.verdict,
+                    findings: advisory.findings.slice(0, 16),
+                    evidenceRefs: advisory.evidenceRefs.slice(0, 16),
+                })}\n</design_review_findings>\nAddress every Critical/Important finding before writing.`;
+            }
+        }
+        catch {
+            // Admission is already enforced above; prompt enrichment is best effort.
+        }
+    }
     node.resolvedSkills = resolvedSkills;
     await writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills);
     let model = resolveModelForTask(task, spec.executorModels);
@@ -1568,6 +1635,9 @@ export async function executeDagNode(input) {
                 return acc;
             }, {});
             let attemptPrompt = buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics, frontendPlanRetryStep);
+            if (task.id === "frontend-scout-pi" && attemptNumber > 1) {
+                attemptPrompt = `${attemptPrompt}\n\nSCOUT RETRY (reuse existing evidence): preserve all committed target-surface/design-evidence facts and do not re-read files already covered by the prior attempt. Inspect only unresolvedPaths or missing target-surface fields, then commit the minimal correction. If the existing facts are complete, commit the same canonical facts without broad rediscovery.`;
+            }
             if (attemptNumber > 1 &&
                 // The plan node (frontend-plan-pi) is a typed-facts ladder task:
                 // its retry is driven by the §5.1 ladder (compact-terminal-first
@@ -1793,6 +1863,9 @@ export async function executeDagNode(input) {
             sdkAttempted: result.sdkAttempted,
             tokensUsed: result.tokensUsed,
             parsedEvents: result.parsedEvents,
+            stopReason: result.stopReason,
+            thinkingObserved: result.thinkingObserved,
+            writeToolCallCount: result.writeToolCallCount,
             artifactPath: `${nodeId}/attempt-${attemptNumber}.json`,
         };
         if (retryPolicy !== undefined) {
@@ -1874,6 +1947,9 @@ export async function executeDagNode(input) {
             retryPolicy === undefined
                 ? result.parsedEvents
                 : sumAttemptMetric(attempts, (attempt) => attempt.parsedEvents);
+        node.stopReason = result.stopReason;
+        node.thinkingObserved = result.thinkingObserved;
+        node.writeToolCallCount = result.writeToolCallCount;
         node.lastActivityAt = attemptFinishedAt;
         if (result.failureCategory === "termination-unconfirmed") {
             node.needsAttentionReason = "attempt-termination-unconfirmed";

package/dist/workflows/dag/rerun-feedback.js

@@ -399,6 +399,65 @@ export async function deriveDagRerunFeedback(input) {
                 },
             });
         }
+        // Preserve actionable writer failures even when the run stopped before a
+        // final review node could commit typed findings. This is especially
+        // important for provider length exhaustion: the next run must see the
+        // stop reason/tool statistics instead of repeating the same prompt.
+        const writerNodeId = ["frontend-implement-pi", "implement-pi"].find((nodeId) => {
+            const node = input.state.nodes[nodeId];
+            return (node?.status === "ERROR" &&
+                [
+                    "empty-output",
+                    "invalid-output",
+                    "writer-thinking-exhausted",
+                    "writer-budget-exhausted",
+                    "incomplete-write-set",
+                    "partial-success-with-context-overflow",
+                ].includes(node.failureCategory ?? ""));
+        });
+        if (writerNodeId) {
+            const writerNode = await readNodeRecord(input.runDir, pass, undefined, writerNodeId, input.state.nodes[writerNodeId]);
+            if (writerNode) {
+                const writerFeedback = [
+                    `writer failure category: ${writerNode.failureCategory ?? "unknown"}`,
+                    writerNode.stopReason ? `provider stopReason: ${writerNode.stopReason}` : "",
+                    typeof writerNode.writeToolCallCount === "number"
+                        ? `write tool calls: ${writerNode.writeToolCallCount}`
+                        : "",
+                    writerNode.stderr?.trim() ?? "",
+                    canonicalNodeOutput(writerNode),
+                ]
+                    .filter(Boolean)
+                    .join("\n\n");
+                const parentSourceBindingHash = sourceBindingHash(input.spec);
+                return withDigest({
+                    schemaVersion: 1,
+                    kind: "unresolved-terminal-feedback",
+                    parentRunId: input.parentRunId,
+                    taskId: input.taskId,
+                    sourceNodeId: writerNodeId,
+                    verdict: "request-revision",
+                    failureCategory: writerNode.failureCategory,
+                    feedbackText: scrubAndBoundFeedbackText(writerFeedback, input.runDir, input.state.cwd),
+                    evidenceRefs: [
+                        {
+                            nodeId: writerNodeId,
+                            preservedNodeRecordPath: `${writerNodeId}.json`,
+                        },
+                    ],
+                    attemptSummary: { completedPasses: 1, maxPasses: 1 },
+                    binding: {
+                        ...(parentSourceBindingHash
+                            ? { sourceCanonicalHash: parentSourceBindingHash }
+                            : {}),
+                        ...(input.spec.taskContractBinding?.canonicalHash
+                            ? { taskContractCanonicalHash: input.spec.taskContractBinding.canonicalHash }
+                            : {}),
+                        status: "unknown",
+                    },
+                });
+            }
+        }
         return undefined;
     }
     const completedPasses = pass?.pass ?? Math.max(1, input.state.convergence?.currentPass ?? 1);