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

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.",
@@ -4375,7 +4376,27 @@ const headingAlias={'\u6a21\u5757\u7d22\u5f15':'Module Index','\u8986\u76d6\u830
 const allLines=readme.replace(/\\r\\n/g,'\\n').replace(/\\r/g,'\\n').split('\\n');
 let headingRepair=false;
 for(let i=0;i<allLines.length;i++){const alias=/^##\\s+(模块索引|覆盖范围|覆盖矩阵|场景分区)\\s*$/.exec(allLines[i].trim());if(alias){allLines[i]='## '+headingAlias[alias[1]];headingRepair=true;}}
-if(headingRepair)readme=allLines.join('\\n');
+let partitionRepair=false;
+const partHeadTrim=[];for(let i=0;i<allLines.length;i++){if(allLines[i].trim()==='## Scenario Partitions')partHeadTrim.push(i);}
+if(partHeadTrim.length===1){
+  const pStart=partHeadTrim[0]+1;let pEnd=allLines.length;for(let i=pStart;i<allLines.length;i++){if(/^##\\s+\\S/.test(allLines[i].trim())){pEnd=i;break;}}
+  const pCells=line=>line.split('|').slice(1,-1).map(v=>String(v||'').trim());
+  const pHeader=['Partition ID','Operation','Axis','Domain','Required Slots','Expected by Slot','Bind Rule'];
+  for(let i=pStart;i<pEnd;i++){
+    if(!allLines[i].includes('|')) continue;
+    const row=pCells(allLines[i]);
+    if(row.length<=7) continue;
+    if(pHeader.every((v,idx)=>row[idx]===v)) continue;
+    const pid=String(row[0]||'').trim();
+    const extras=row.slice(7).join(';').split(/[;,，；]/).map(v=>v.trim().split(bt).join('')).filter(Boolean);
+    const prefix='TP-'+pid.toUpperCase()+'-';
+    if(extras.length && extras.every(t=>/^TP-[A-Z0-9-]+$/i.test(t)&&(t.toUpperCase().startsWith(prefix)||t.toUpperCase().startsWith('TP-SP-')))){
+      allLines[i]='| '+row.slice(0,7).join(' | ')+' |';
+      partitionRepair=true;
+    }
+  }
+}
+if(headingRepair||partitionRepair)readme=allLines.join('\\n');
 const headings=[];for(let i=0;i<allLines.length;i++){if(allLines[i].trim()==='## Module Index')headings.push(i);}
 if(headings.length!==1){process.stderr.write((headings.length===0?'missing-module-index':'duplicate-module-index')+'; require exactly one exact ## Module Index section\\n');process.exit(2);}
 const start=headings[0]+1;let end=allLines.length;for(let i=start;i<allLines.length;i++){if(/^##\\s+\\S/.test(allLines[i].trim())){end=i;break;}}
@@ -4388,7 +4409,7 @@ const headerIndex=lines.findIndex(line=>{const row=cells(line);return expectedHe
 if(headerIndex<0){process.stderr.write('invalid-module-index-header: require exact business ownership and path columns\\n');process.exit(2);}
 const dataRows=lines.slice(headerIndex+2).map(cells).filter(row=>row.length>=8&&row[0]&&row[0]!=='Module Stem');
 const allowedSplit=new Set(['explicit-user-layout','primary-business-resource','independent-business-resource','output-budget']);
-const operationOwners=new Map();const canonicalSeen=new Set();const declaredModules=[];let planRepairApplied=headingRepair;
+const operationOwners=new Map();const canonicalSeen=new Set();const declaredModules=[];let planRepairApplied=headingRepair||partitionRepair;
 for(const row of dataRows){
   const rawStem=String(row[0]||'').trim(),resource=String(row[1]||'').trim(),operations=String(row[2]||'').split(';').map(value=>value.trim()).filter(Boolean),split=String(row[5]||'').trim();
   const mdMatches=[...String(row[6]||'').matchAll(rxMdPath)];
@@ -4430,7 +4451,7 @@ if(planRepairApplied){
   const table=['| '+expectedHeader.join(' | ')+' |','|'+expectedHeader.map(()=>'---').join('|')+'|',...declaredModules.map(item=>'| '+[item.stem,item.businessResource,item.ownedOperations.join('; '),item.ownedRuleKeys.join('; '),item.caseIds.join('; '),item.splitReason,'['+item.stem+'](./'+item.stem+'.md) '+item.markdownPath,item.pytestPath].join(' | ')+' |')].join('\\n');
   readme=[...allLines.slice(0,headings[0]+1),table,...allLines.slice(end)].join('\\n');
   fs.writeFileSync(planPath,readme,'utf8');
-} else if(headingRepair){
+} else if(headingRepair||partitionRepair){
   fs.writeFileSync(planPath,readme,'utf8');
 }
 for(const [operation,owners] of operationOwners){if(owners.length>1&&!owners.every(owner=>owner.split==='explicit-user-layout'||owner.split==='output-budget')){process.stderr.write('overlapping-operation-modules: '+operation+' -> '+owners.map(owner=>owner.stem).join(',')+'; merge by business resource or use an authoritative explicit-user-layout\\n');process.exit(2);}}
@@ -5075,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);

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

@@ -309,7 +309,10 @@ export async function rerunStandaloneTask(input) {
             state,
         });
     }
-    catch {
+    catch (error) {
+        if (state.terminalReason === "design-request-changes") {
+            throw new Error(`frontend design recovery feedback unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
         // Feedback is additive recovery context. A corrupt/missing historical
         // artifact must be reported honestly but must not block an otherwise
         // eligible full rerun.
@@ -378,7 +381,10 @@ export async function rerunStandaloneTask(input) {
             kind: "standalone-task-rerun",
         })
         : undefined;
-    if (recoveryLease?.kind === "held") {
+    const nestedAutoRecoveryLease = recoveryLease?.kind === "held" &&
+        recoveryLease.lease.kind === "auto-frontend-recovery" &&
+        recoveryLease.lease.requestId === input.requestId;
+    if (recoveryLease?.kind === "held" && !nestedAutoRecoveryLease) {
         return blockedResult({
             parentRunId: input.parentRunId,
             reason: input.reason,

package/dist/workflows/dag/runner.js

@@ -1087,7 +1087,7 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd, f
     if (hasFrontendWriter && !skipFrontendRecovery) {
         const admission = await readFrontendPrewriteResult(runDir);
         if (admission.ok) {
-            // M8: admission has only admitted|blocked. A blocked admission whose
+            // M8: admission uses the accepted/blocked state machine. A blocked admission whose
             // failureSource is frontend-plan-pi is the contract-invalid analog of
             // the old retryable-invalid path (candidate continuation may re-plan);
             // every other blocked admission is terminal.
@@ -1130,7 +1130,10 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd, f
                 if (continuationCount < frontendRecoveryQuota) {
                     recoveryTrigger = {
                         requestId: state.runId,
-                        failureSource: "frontend-design-review-pi",
+                        // The rejected design is a plan input defect. Reset from the
+                        // planner so the next child can incorporate the committed
+                        // findings before design review runs again.
+                        failureSource: "frontend-plan-pi",
                         failureOwner: classifyReviewIssueCategoryFailureOwner(designRequestFact.issueCategory),
                         protocolFailureReason: `frontend design review request_design_changes (issueCategory=${designRequestFact.issueCategory})`,
                         recoveryMode: "new-dag",
@@ -1295,10 +1298,12 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd, f
  * A parent-run atomic lease is acquired before `OperationStore.create`, then
  * its operation id is persisted into that lease before the controller may run.
  * `clientRequestId` remains a useful store-level replay key, but is not a
- * cross-process recovery admission boundary. The continuation DagSpec/reset
- * partition is frozen via `computeFrontendRecoveryPlanForSource` and
- * serialized under the run dir's bounded `.runtime/` namespace. `planHash` is
- * the second idempotency dimension of `actionParams`.
+ * cross-process recovery admission boundary. The reset partition is frozen via
+ * `computeFrontendRecoveryPlanForSource` and serialized under the run dir's
+ * bounded `.runtime/` namespace for audit. The operation invokes
+ * `dag rerun-task`, which regenerates a valid child DagSpec and carries typed
+ * parent feedback through the managed rerun path. `planHash` is the second
+ * idempotency dimension of `actionParams`.
  */
 async function createRecoveryOperation(input) {
     const { cwd, runDir, spec, state, trigger } = input;
@@ -1344,11 +1349,13 @@ async function createRecoveryOperation(input) {
         },
         cliArgs: [
             "dag",
-            "execute",
-            "--dag",
-            continuationPath,
-            "--cwd",
-            cwd,
+            "rerun-task",
+            "--run-id",
+            state.runId,
+            "--reason",
+            trigger.protocolFailureReason ?? "frontend automatic recovery",
+            "--request-id",
+            trigger.requestId,
             "--json",
         ],
     });

package/dist/workflows/dag/scheduler.js

@@ -4,7 +4,7 @@ import { isPauseOnHumanDecisionGate } from "./decision-envelope.js";
 import { evaluateConditionExpression } from "./dynamic-runtime/condition.js";
 import { sha256Hex } from "./frontend-implementation-contract.js";
 import { boundaryForTargetNode, computeFrontendShapeNodeDigest, evaluateFrontendShapeBoundary, } from "./frontend-shape-facts.js";
-import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, frontendWriterAdmissionResultV1Schema, } from "./frontend-writer-admission.js";
+import { FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT, frontendWriterAdmissionResultV1Schema, normalizeConcreteWriteSetPath, } from "./frontend-writer-admission.js";
 import { FRONTEND_RECOVERY_IMPORT_MANIFEST_REL_PATH, FRONTEND_RECOVERY_INTENT_REL_DIR, } from "./frontend-recovery-plan.js";
 export function isConditionSkippedReason(reason) {
     return Boolean(reason?.startsWith("condition "));
@@ -174,10 +174,7 @@ export async function readFrontendWriterAdmissionResult(runDir) {
 /** Authorize only the `accepted` classification (four-state admission).
  * `requires-human-approval`, `blocked`, and `stale` are all denied. */
 export function isFrontendWriterAuthorized(result) {
-    return result.classification === "accepted" ||
-        result.classification === "admitted"
-        ? "authorized"
-        : "denied";
+    return result.classification === "accepted" ? "authorized" : "denied";
 }
 /** Fail-closed: leave no PENDING nodes that look "still scheduled" after abort. */
 export function markPendingNodesControllerInterrupted(state, reason = "run aborted by controller (abortSignal)") {
@@ -417,6 +414,12 @@ export async function executeDagRanksOnce(input) {
                     continue;
                 }
                 const decision = isFrontendWriterAuthorized(admission.result);
+                const normalizedWriteSet = admission.result.writeSet
+                    .map(normalizeConcreteWriteSetPath)
+                    .filter((entry) => entry !== undefined);
+                const concreteWriteSetValid = (admission.result.writeSet.length > 0 &&
+                    normalizedWriteSet.length === admission.result.writeSet.length &&
+                    new Set(normalizedWriteSet).size === normalizedWriteSet.length);
                 node.frontendWriterAdmission = {
                     schemaVersion: 1,
                     writerNodeId: id,
@@ -428,12 +431,24 @@ export async function executeDagRanksOnce(input) {
                         ? `classification: ${admission.result.classification}`
                         : null,
                 };
-                if (decision === "denied") {
+                if (decision === "denied" || !concreteWriteSetValid) {
+                    node.frontendWriterAdmission.reason = decision === "denied"
+                        ? `classification: ${admission.result.classification}`
+                        : "admission writeSet is not a concrete unique path set";
                     node.status = "SKIPPED";
                     node.skippedReason = "frontend-prewrite-not-authorized";
                     node.finishedAt = checkedAt;
                     frontendAdmissionSettled.push(id);
                 }
+                else {
+                    node.runtimeWriteAuthorization = {
+                        schemaVersion: 1,
+                        status: "validated",
+                        approvalSourceNodeId: FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT,
+                        approvalDigest: admission.result.admissionDigest,
+                        effectiveWriteSet: normalizedWriteSet,
+                    };
+                }
             }
             if (frontendAdmissionSettled.length > 0)
                 await input.persistState();

package/docs/templates/backend-test-dag.json

@@ -148,7 +148,7 @@
 				"validate-backend-test-environment-shell"
 			],
 			"complexity": "MED",
-			"subtask_prompt": "This is a required plan-generation node. Read only the strict read set and return the complete Markdown plan in the assistant response. The runtime persists the response as a run-owned Harness artifact named generate-backend-md-plan-pi/plan.md. Do not write testcase/md/README.md or any project file; module case cards are written by downstream sharded nodes.\n\nOutput budget protocol (hard, max output <=16K per turn): Never paste full Matrix, case bodies, or source text into assistant chat. README holds only Scope+Matrix+module index; never inline full case bodies. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.\n\nReturn the complete plan as plain Markdown. Do not emit JSON or code fences. The plan must contain the exact English protocol headings ## Coverage Scope, ## Coverage Matrix, ## Scenario Partitions when applicable, and ## Module Index. Never translate those headings into 覆盖范围/覆盖矩阵/场景分区/模块索引.\n\nRead the upstream environment report only through the strict read set. Generate the Markdown-first backend test plan; it will be persisted under the current DAG run's Harness artifacts, not under testcase/md/.\n\nWrite human-readable content in Simplified Chinese by default. Keep English protocol literals exact: section headings, table headers, Partition IDs, TP IDs, Case IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and source citations. Never translate ## Module Index into ## 模块索引.\n\nCreate the concise plan entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in the plan artifact.\n\nBefore the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in the plan artifact using exactly `| Field | Value |`, immediately followed by the separator row `|---|---|`, and these six unique rows: `Change Classification`, `Coverage Policy`, `Affected Operations`, `Affected Rule Keys`, `Regression Floor`, `Scope Evidence`. Always set `Change Classification` to `new-operation` and `Coverage Policy` to `full-contract`; do NOT reason about whether operations are new or existing. Cover all in-scope rules from the requirement document at full depth; treat the product requirement as the coverage baseline and use API contract evidence (fields/status/enum/boundary/format) to supplement scenario dimensions. Scope is limited to operations/rules the requirement document (or its referenced API contract) explicitly describes; do not expand to unrelated operations that the requirement does not mention. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.\n\nCoverage depth is full over the in-scope rules: fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected operation the requirement describes, but do not re-test unrelated operations the requirement does not mention. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT.\n\nBefore writing cases, build the mandatory machine-readable Coverage Matrix inside the plan artifact itself. Its section heading line must be exactly `## Coverage Matrix` with no numeric prefix/suffix; never place the canonical Matrix only in a module file. Use this exact header: `| Rule Key | Priority | Source | Endpoint/Field | Dimension | Rule | Required Test Points | Case IDs | Status |`. Every data row must contain exactly 9 pipe-delimited cells and must never omit `Dimension`; use concise dimensions such as requirement, operation, response-status, requiredness, enum, boundary, format, business-state or error. Use only P0/P1/P2 and COVERED/PARTIAL/GAP/CONFLICT. Use stable `TP-<UPPERCASE-HYPHENATED-ID>` test points separated by semicolons.\n\nEach Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.\n\nCoverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.\n\nFor uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.\n\nMandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden. The Module Stem cell must contain only the plain filename stem; never put Markdown link syntax or a path in that cell.\n\nInclude 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.\n\nScenario 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.\n\nBefore 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.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.\n\nRead only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
+			"subtask_prompt": "This is a required plan-generation node. Read only the strict read set and return the complete Markdown plan in the assistant response. The runtime persists the response as a run-owned Harness artifact named generate-backend-md-plan-pi/plan.md. Do not write testcase/md/README.md or any project file; module case cards are written by downstream sharded nodes.\n\nOutput budget protocol (hard, max output <=16K per turn): Never paste full Matrix, case bodies, or source text into assistant chat. README holds only Scope+Matrix+module index; never inline full case bodies. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.\n\nReturn the complete plan as plain Markdown. Do not emit JSON or code fences. The plan must contain the exact English protocol headings ## Coverage Scope, ## Coverage Matrix, ## Scenario Partitions when applicable, and ## Module Index. Never translate those headings into 覆盖范围/覆盖矩阵/场景分区/模块索引.\n\nRead the upstream environment report only through the strict read set. Generate the Markdown-first backend test plan; it will be persisted under the current DAG run's Harness artifacts, not under testcase/md/.\n\nWrite human-readable content in Simplified Chinese by default. Keep English protocol literals exact: section headings, table headers, Partition IDs, TP IDs, Case IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and source citations. Never translate ## Module Index into ## 模块索引.\n\nCreate the concise plan entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in the plan artifact.\n\nBefore the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in the plan artifact using exactly `| Field | Value |`, immediately followed by the separator row `|---|---|`, and these six unique rows: `Change Classification`, `Coverage Policy`, `Affected Operations`, `Affected Rule Keys`, `Regression Floor`, `Scope Evidence`. Always set `Change Classification` to `new-operation` and `Coverage Policy` to `full-contract`; do NOT reason about whether operations are new or existing. Cover all in-scope rules from the requirement document at full depth; treat the product requirement as the coverage baseline and use API contract evidence (fields/status/enum/boundary/format) to supplement scenario dimensions. Scope is limited to operations/rules the requirement document (or its referenced API contract) explicitly describes; do not expand to unrelated operations that the requirement does not mention. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.\n\nCoverage depth is full over the in-scope rules: fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected operation the requirement describes, but do not re-test unrelated operations the requirement does not mention. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT.\n\nBefore writing cases, build the mandatory machine-readable Coverage Matrix inside the plan artifact itself. Its section heading line must be exactly `## Coverage Matrix` with no numeric prefix/suffix; never place the canonical Matrix only in a module file. Use this exact header: `| Rule Key | Priority | Source | Endpoint/Field | Dimension | Rule | Required Test Points | Case IDs | Status |`. Every data row must contain exactly 9 pipe-delimited cells and must never omit `Dimension`; use concise dimensions such as requirement, operation, response-status, requiredness, enum, boundary, format, business-state or error. Use only P0/P1/P2 and COVERED/PARTIAL/GAP/CONFLICT. Use stable `TP-<UPPERCASE-HYPHENATED-ID>` test points separated by semicolons.\n\nEach Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.\n\nCoverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.\n\nFor uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.\n\nMandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden. The Module Stem cell must contain only the plain filename stem; never put Markdown link syntax or a path in that cell.\n\nInclude 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.\n\nScenario 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.\n\nBefore 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.\n\n## Derived task contract: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Authoritative reference index\n\n[]\n\nFor each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.\n\nRead only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
 			"executor": "pi",
 			"role": "planner",
 			"toolProfile": "read-only",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.42.0-next.7",
+  "version": "0.42.0-next.9",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/dist/worker/console/static/assets/channel-BdTaMnYP.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./mermaid.core-Bagus6zF.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/worker/console/static/assets/classDiagram-JCYQIIEL-Cid7CSRK.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DPv743zu.js";import{_ as i}from"./mermaid.core-Bagus6zF.js";import"./chunk-5VM5RSS4-XTqNlzH4.js";import"./chunk-XXDRQBXY-B-A3ErBP.js";import"./chunk-KBJHAD2P-CV__aJTt.js";import"./chunk-2GRJ4B5K-BN8VNeh5.js";import"./index-Dkv0ezuE.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/classDiagram-v2-OCEON4UE-Cid7CSRK.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-GF5L2VYU-DPv743zu.js";import{_ as i}from"./mermaid.core-Bagus6zF.js";import"./chunk-5VM5RSS4-XTqNlzH4.js";import"./chunk-XXDRQBXY-B-A3ErBP.js";import"./chunk-KBJHAD2P-CV__aJTt.js";import"./chunk-2GRJ4B5K-BN8VNeh5.js";import"./index-Dkv0ezuE.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/worker/console/static/assets/stateDiagram-v2-UEYNNEHI-CIkoculx.js

@@ -1 +0,0 @@
-import{s as r,b as e,a,S as s}from"./chunk-5RXB4S5H-zxMQ5b8E.js";import{_ as i}from"./mermaid.core-Bagus6zF.js";import"./chunk-XXDRQBXY-B-A3ErBP.js";import"./chunk-KBJHAD2P-CV__aJTt.js";import"./chunk-2GRJ4B5K-BN8VNeh5.js";import"./index-Dkv0ezuE.js";var u={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{u as diagram};