@tea-agent/loop-agent 0.28.1-beta.1 → 0.28.2-beta.1

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.28.1] - 2026-08-05
+
+### 改进
+
+- cut npm test wall clock to ~264s and archive finished plans
+- avoid routing maintenance tasks to frontend dag
+- make openspec evidence non-blocking
+- disable frontend lint generation
+- tolerate prose before frontend contract json
+- fix frontend topology and verdict tests
+- reduce llm protocol validation failures
+- fix frontend prewrite contract normalization
+
+### 修复
+
+- stabilize identity-sensitive tests
+- fail closed on backend writer no-op
+- validate frontend contract before writing
+- add structured frontend contract node
+- harden verification and JSON parsing
+- accept inline pass verdict
+- normalize empty model fields
+
 ## [0.28.0] - 2026-08-05
 
 ### 重点更新

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

@@ -141,7 +141,14 @@ export function buildDagPiUserMessage(task, persona, step) {
     const writePolicy = task.writePolicy ?? "read-only (default)";
     if (isDagPiWriteTask(task)) {
         const outcomeInstruction = task.writerOutcomePolicy
-            ? "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. Use changed only after producing a non-empty bounded diff; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed."
+            ? [
+                "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked. Use changed only after producing a non-empty bounded diff; use already-satisfied only when the contract is already met and no file changed; use blocked when implementation cannot proceed.",
+                task.writerOutcomePolicy.requireChangedFiles
+                    ? "This generation node requires a non-empty bounded diff; already-satisfied cannot complete it successfully."
+                    : undefined,
+            ]
+                .filter((value) => Boolean(value))
+                .join(" ")
             : undefined;
         return [
             `You are executing hybrid DAG node "${task.id}" (role=${role}, piStep=${step}, writePolicy=${writePolicy}).`,
@@ -635,7 +642,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 "writer outcome validation failed: actual diff is unavailable";
         }
         else {
-            const outcomeValidation = validateWriterImplementationOutcome(mapped.assistantText || mapped.stdout, changeManifestChangedFiles);
+            const outcomeValidation = validateWriterImplementationOutcome(mapped.assistantText || mapped.stdout, changeManifestChangedFiles, {
+                requireChangedFiles: input.task.writerOutcomePolicy.requireChangedFiles === true,
+            });
             if (!outcomeValidation.ok) {
                 writerOutcomeViolation = outcomeValidation.reason;
             }
@@ -678,22 +687,41 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
-export function validateWriterImplementationOutcome(text, changedFiles) {
+export function validateWriterImplementationOutcome(text, changedFiles, options) {
     const parsed = parseWriterImplementationOutcome(text);
     const diagnostics = writerOutcomeDiagnostics(text, parsed, changedFiles.length);
-    // The workspace diff is authoritative. The model outcome is advisory and
-    // may be missing, malformed, or inconsistent without blocking a completed
-    // writer. An explicit blocked signal remains a hard failure.
-    if (parsed.candidates.some((candidate) => candidate.outcome === "blocked")) {
+    if (parsed.kind !== "valid") {
         return {
             ok: false,
-            reason: `writer outcome validation failed: explicit blocked outcome; ${diagnostics}`,
+            reason: `writer outcome validation failed: ${parsed.kind} outcome; ${diagnostics}; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked`,
         };
     }
-    return {
-        ok: true,
-        outcome: changedFiles.length > 0 ? "changed" : "already-satisfied",
-    };
+    const outcome = parsed.outcome;
+    if (outcome === "blocked") {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully; ${diagnostics}`,
+        };
+    }
+    if (outcome === "changed" && changedFiles.length === 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: changed outcome has an empty diff; ${diagnostics}`,
+        };
+    }
+    if (outcome === "already-satisfied" && changedFiles.length > 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: already-satisfied outcome has a non-empty diff; ${diagnostics}`,
+        };
+    }
+    if (options?.requireChangedFiles === true && changedFiles.length === 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: node requires a non-empty diff; ${diagnostics}`,
+        };
+    }
+    return { ok: true, outcome };
 }
 function parseWriterImplementationOutcome(text) {
     const lines = text.split(/\r?\n/);

package/dist/executors/pi-executor.js

@@ -261,7 +261,7 @@ export function extractAssistantTextFromPiJson(stdout) {
             const event = JSON.parse(trimmed);
             parsedEvents += 1;
             const candidate = extractAssistantTextFromEvent(event);
-            if (candidate)
+            if (candidate !== undefined)
                 assistantText = candidate;
         }
         catch {
@@ -331,23 +331,24 @@ function readNumericUsageField(record, keys) {
     return null;
 }
 function extractAssistantTextFromEvent(event) {
-    if (event.type === "turn_end" && isRecord(event.message)) {
-        return extractAssistantTextFromMessage(event.message);
-    }
-    if (event.type === "message_end" && isRecord(event.message)) {
+    if ((event.type === "turn_end" || event.type === "message_end") &&
+        isRecord(event.message) &&
+        event.message.role === "assistant") {
         return extractAssistantTextFromMessage(event.message);
     }
     if (event.type === "agent_end" && Array.isArray(event.messages)) {
         for (let i = event.messages.length - 1; i >= 0; i -= 1) {
             const message = event.messages[i];
-            if (isRecord(message)) {
-                const text = extractAssistantTextFromMessage(message);
-                if (text)
-                    return text;
+            if (isRecord(message) && message.role === "assistant") {
+                // The terminal assistant message is authoritative even when it only
+                // contains thinking/tool content. Do not walk farther back and reuse a
+                // stale progress sentence as the final node output.
+                return extractAssistantTextFromMessage(message);
             }
         }
+        return "";
     }
-    return "";
+    return undefined;
 }
 function extractAssistantTextFromMessage(message) {
     if (message.role !== "assistant" || !Array.isArray(message.content))
@@ -472,7 +473,7 @@ export class PiJsonlStreamCollector {
     }
     consumeEvent(event) {
         const candidate = extractAssistantTextFromEvent(event);
-        if (candidate) {
+        if (candidate !== undefined) {
             if (candidate.length > MAX_ASSISTANT_TEXT_CHARS) {
                 this.outputTooLarge = true;
                 this.assistantText = candidate.slice(0, MAX_ASSISTANT_TEXT_CHARS);
@@ -964,11 +965,11 @@ export function classifyPiFailure(input) {
         return "quota";
     if (/rate.?limit/.test(combined))
         return "rate-limit";
-    if (/unauthorized|forbidden|invalid api key|authentication|auth failed/.test(combined))
+    if (/\bunauthorized\b|\bhttp\s*40[13]\b|invalid api key|authentication (?:failed|required|error)|auth(?:entication)? failed/.test(combined))
         return "auth";
     if (/unknown provider|unknown model|model.*unavailable|provider.*unavailable|\bunavailable\b|overloaded|capacity|temporarily unavailable/.test(combined))
         return "unavailable";
-    if (/network|econnreset|etimedout|socket hang up|connection reset|dns|fetch failed/.test(combined))
+    if (/network|econnreset|etimedout|socket hang up|connection reset|connection error|request timed out|dns|fetch failed/.test(combined))
         return "network";
     if (input.exitCode === 0 && !input.assistantText.trim())
         return "empty-output";

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

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
-import { appendFile, lstat, mkdir, readFile, realpath, stat } from "node:fs/promises";
+import { appendFile, lstat, mkdir, readFile, realpath, stat, } from "node:fs/promises";
 import path from "node:path";
-import { processTreeSpawnOptions, terminateProcessTree } from "./process-tree.js";
+import { processTreeSpawnOptions, terminateProcessTree, } from "./process-tree.js";
 import { resolvePlaywrightCliLauncher } from "./playwright-cli-launcher.js";
 import { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, } from "../shared/playwright-cli-command-policy.js";
 export { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, };
@@ -55,10 +55,14 @@ function normalizePosix(value) {
 }
 function isSafeRelativePosix(value) {
     const normalized = normalizePosix(value);
-    if (!normalized || path.posix.isAbsolute(normalized) || path.win32.isAbsolute(normalized)) {
+    if (!normalized ||
+        path.posix.isAbsolute(normalized) ||
+        path.win32.isAbsolute(normalized)) {
         return false;
     }
-    return normalized.split("/").every((part) => part.length > 0 && part !== "." && part !== "..");
+    return normalized
+        .split("/")
+        .every((part) => part.length > 0 && part !== "." && part !== "..");
 }
 export function redactPlaywrightCliArgs(command, args) {
     return args.map((arg) => {
@@ -168,7 +172,9 @@ function assertNoControlMeta(arg) {
     }
 }
 function assertNoSessionFlag(arg) {
-    if (SESSION_FLAG.test(arg) || arg === "--session" || arg.startsWith("--session=")) {
+    if (SESSION_FLAG.test(arg) ||
+        arg === "--session" ||
+        arg.startsWith("--session=")) {
         throw new PlaywrightCliPolicyError("named-session-forbidden", "named browser sessions are forbidden; use the default session only");
     }
 }
@@ -176,10 +182,13 @@ function isProductionHost(hostname) {
     const host = hostname.toLowerCase();
     if (host === "localhost" || host === "127.0.0.1" || host === "::1")
         return false;
-    if (host.endsWith(".local") || host.endsWith(".test") || host.endsWith(".localhost")) {
+    if (host.endsWith(".local") ||
+        host.endsWith(".test") ||
+        host.endsWith(".localhost")) {
         return false;
     }
-    return /(?:^|\.)prod(?:uction)?(?:\.|$)/i.test(host) || /(?:^|\.)(?:www\.)?[^.]*(?:prod|production)/i.test(host);
+    return (/(?:^|\.)prod(?:uction)?(?:\.|$)/i.test(host) ||
+        /(?:^|\.)(?:www\.)?[^.]*(?:prod|production)/i.test(host));
 }
 function validateOpenArgs(args, baseUrl) {
     const flags = new Set();
@@ -193,7 +202,9 @@ function validateOpenArgs(args, baseUrl) {
             normalized.push(arg);
             continue;
         }
-        if (arg.startsWith("--browser=") || arg === "--browser" || arg === "--headless") {
+        if (arg.startsWith("--browser=") ||
+            arg === "--browser" ||
+            arg === "--headless") {
             throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headed only");
         }
         if (/^[a-z][a-z0-9+.-]*:/i.test(arg) || arg.startsWith("http")) {
@@ -247,14 +258,17 @@ function validateOpenArgs(args, baseUrl) {
 function resolveEvidenceRelative(rawPath, ctx) {
     const evidenceDir = normalizePosix(ctx.evidenceDir).replace(/\/$/, "");
     const evidencePrefix = `testcase/frontend/evidence/${ctx.caseId}`;
-    if (!(evidenceDir === evidencePrefix || evidenceDir.startsWith(`${evidencePrefix}/`))) {
+    if (!(evidenceDir === evidencePrefix ||
+        evidenceDir.startsWith(`${evidencePrefix}/`))) {
         throw new PlaywrightCliPolicyError("evidence-dir-invalid", `evidenceDir must be under ${evidencePrefix}`);
     }
     const candidate = normalizePosix(rawPath);
     if (!candidate || candidate.includes("\0")) {
         throw new PlaywrightCliPolicyError("path-empty", "empty output path");
     }
-    if (path.win32.isAbsolute(candidate) || path.posix.isAbsolute(candidate) || /^[a-zA-Z]:\//.test(candidate)) {
+    if (path.win32.isAbsolute(candidate) ||
+        path.posix.isAbsolute(candidate) ||
+        /^[a-zA-Z]:\//.test(candidate)) {
         throw new PlaywrightCliPolicyError("path-absolute", "absolute output paths are forbidden");
     }
     if (candidate.split("/").includes("..")) {
@@ -267,7 +281,8 @@ function resolveEvidenceRelative(rawPath, ctx) {
     if (candidate.startsWith(`${evidenceDir}/`) || candidate === evidenceDir) {
         return candidate;
     }
-    if (candidate.startsWith("testcase/frontend/evidence/") && !candidate.startsWith(`${evidencePrefix}/`)) {
+    if (candidate.startsWith("testcase/frontend/evidence/") &&
+        !candidate.startsWith(`${evidencePrefix}/`)) {
         throw new PlaywrightCliPolicyError("path-cross-case", "output path escapes current case evidenceDir");
     }
     throw new PlaywrightCliPolicyError("path-outside-evidence", `output path must stay under ${evidenceDir}`);
@@ -292,9 +307,7 @@ function resolveScreenshotFilename(rawFilename, ctx) {
     }
 }
 function isSafeBareScreenshotFilename(value) {
-    return (!value.includes("/") &&
-        !value.includes("\\") &&
-        isSafeRelativePosix(value));
+    return (!value.includes("/") && !value.includes("\\") && isSafeRelativePosix(value));
 }
 function isPlaywrightCliElementRef(value) {
     return /^e[1-9]\d*$/.test(value);
@@ -390,7 +403,8 @@ function normalizePdfOrSnapshotArgs(command, args, ctx) {
         target = arg;
     }
     if (filename === undefined) {
-        if (command === "snapshot" && (target === undefined || isPlaywrightCliElementRef(target))) {
+        if (command === "snapshot" &&
+            (target === undefined || isPlaywrightCliElementRef(target))) {
             return target ? [target] : [];
         }
         throw new PlaywrightCliPolicyError("output-filename-required", `${command} requires --filename <file>`);
@@ -432,7 +446,9 @@ function rewriteArgsForPaths(command, args, ctx) {
             i += 1;
             continue;
         }
-        if (inputCommands.has(command) && !arg.startsWith("-") && /\.[a-z0-9]+$/i.test(arg)) {
+        if (inputCommands.has(command) &&
+            !arg.startsWith("-") &&
+            /\.[a-z0-9]+$/i.test(arg)) {
             assertInputPathAllowed(arg, ctx);
             rewritten.push(normalizePosix(arg));
             continue;
@@ -530,19 +546,17 @@ async function validatePlaywrightCliInputFiles(command, args, ctx) {
         if (!isSafeRelativePosix(candidate)) {
             throw new PlaywrightCliPolicyError("input-path-unsafe", "upload/drop input must be a safe path relative to inputRoot");
         }
+        // Resolve both sides with realpath before containment checks. macOS temp
+        // paths often enter via /var/... while realpath returns /private/var/...,
+        // which would otherwise false-positive as path escape.
         const lexical = path.resolve(ctx.repoRoot, candidate);
-        const relative = path.relative(root, lexical);
-        if (relative.startsWith("..") || path.isAbsolute(relative)) {
-            throw new PlaywrightCliPolicyError("input-path-outside", "upload/drop input escapes inputRoot");
-        }
         const info = await lstat(lexical);
         if (!info.isFile() || info.isSymbolicLink()) {
             throw new PlaywrightCliPolicyError("input-not-regular-file", "upload/drop input must be a regular non-symlink file");
         }
         const resolved = await realpath(lexical);
-        const resolvedRelative = path.relative(root, resolved);
-        if (resolvedRelative.startsWith("..") || path.isAbsolute(resolvedRelative)) {
-            throw new PlaywrightCliPolicyError("input-realpath-escape", "upload/drop input realpath escapes inputRoot");
+        if (!pathIsContained(root, resolved)) {
+            throw new PlaywrightCliPolicyError("input-path-outside", "upload/drop input escapes inputRoot");
         }
         if (!(await stat(resolved)).isFile()) {
             throw new PlaywrightCliPolicyError("input-not-regular-file", "upload/drop input must resolve to a regular file");
@@ -609,7 +623,10 @@ async function validatePlaywrightCliOutputPath(command, args, ctx) {
             throw outputRealpathUnsafe("output evidence directory must be an existing non-symlink directory");
         }
     }
-    const relativeParts = path.relative(repoRoot, target).split(path.sep).filter(Boolean);
+    const relativeParts = path
+        .relative(repoRoot, target)
+        .split(path.sep)
+        .filter(Boolean);
     let current = repoRoot;
     let nearestExistingDirectory = repoRoot;
     let targetExists = false;
@@ -638,12 +655,13 @@ async function validatePlaywrightCliOutputPath(command, args, ctx) {
     let evidenceReal;
     let nearestExistingReal;
     try {
-        [repoReal, caseEvidenceReal, evidenceReal, nearestExistingReal] = await Promise.all([
-            realpath(repoRoot),
-            realpath(caseEvidenceRoot),
-            realpath(evidenceDir),
-            realpath(nearestExistingDirectory),
-        ]);
+        [repoReal, caseEvidenceReal, evidenceReal, nearestExistingReal] =
+            await Promise.all([
+                realpath(repoRoot),
+                realpath(caseEvidenceRoot),
+                realpath(evidenceDir),
+                realpath(nearestExistingDirectory),
+            ]);
     }
     catch {
         throw outputRealpathUnsafe("cannot resolve output containment realpath");
@@ -662,7 +680,8 @@ async function validatePlaywrightCliOutputPath(command, args, ctx) {
         catch {
             throw outputRealpathUnsafe("cannot resolve existing output target realpath");
         }
-        if (!pathIsContained(evidenceReal, targetReal) || !pathIsContained(repoReal, targetReal)) {
+        if (!pathIsContained(evidenceReal, targetReal) ||
+            !pathIsContained(repoReal, targetReal)) {
             throw outputRealpathUnsafe("existing output target realpath escapes containment");
         }
     }
@@ -757,8 +776,9 @@ function nextSequence(nodeId) {
 export async function executePlaywrightCliCommand(input, ctx, signal) {
     const startedAt = new Date();
     const sequence = nextSequence(ctx.nodeId);
-    const timeoutSeconds = Math.max(1, Math.min(600, Number(input.timeoutSeconds ?? ctx.defaultTimeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) ||
-        DEFAULT_TIMEOUT_SECONDS));
+    const timeoutSeconds = Math.max(1, Math.min(600, Number(input.timeoutSeconds ??
+        ctx.defaultTimeoutSeconds ??
+        DEFAULT_TIMEOUT_SECONDS) || DEFAULT_TIMEOUT_SECONDS));
     let command = String(input.command ?? "");
     let args = [];
     let errorClass;
@@ -810,15 +830,35 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         }
     }
     catch (error) {
-        errorClass = error instanceof PlaywrightCliPolicyError ? error.code : "playwright-cli-unavailable";
+        errorClass =
+            error instanceof PlaywrightCliPolicyError
+                ? error.code
+                : "playwright-cli-unavailable";
         const finishedAt = new Date();
         const receipt = {
-            schemaVersion: 1, caseId: ctx.caseId, sequence, command,
-            argsRedacted: redactPlaywrightCliArgs(command, args), startedAt: startedAt.toISOString(), finishedAt: finishedAt.toISOString(),
-            exitCode: null, durationMs: finishedAt.getTime() - startedAt.getTime(), outputSha256: createHash("sha256").update("").digest("hex"), toolVersion: ctx.toolVersion ?? "unknown", errorClass,
+            schemaVersion: 1,
+            caseId: ctx.caseId,
+            sequence,
+            command,
+            argsRedacted: redactPlaywrightCliArgs(command, args),
+            startedAt: startedAt.toISOString(),
+            finishedAt: finishedAt.toISOString(),
+            exitCode: null,
+            durationMs: finishedAt.getTime() - startedAt.getTime(),
+            outputSha256: createHash("sha256").update("").digest("hex"),
+            toolVersion: ctx.toolVersion ?? "unknown",
+            errorClass,
         };
         await appendReceipt(ctx, receipt);
-        return { ok: false, exitCode: null, stdout: "", stderr: error instanceof Error ? error.message : String(error), timedOut: false, receipt, errorClass };
+        return {
+            ok: false,
+            exitCode: null,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            timedOut: false,
+            receipt,
+            errorClass,
+        };
     }
     const runner = ctx.runCommand ?? defaultPlaywrightCliCommandRunner;
     let runResult;
@@ -836,7 +876,13 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         });
     }
     catch (error) {
-        runResult = { exitCode: null, stdout: "", stderr: error instanceof Error ? error.message : String(error), timedOut: false, signal: null };
+        runResult = {
+            exitCode: null,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            timedOut: false,
+            signal: null,
+        };
     }
     const finishedAt = new Date();
     const combined = `${runResult.stdout}\n${runResult.stderr}`;
@@ -903,8 +949,12 @@ export async function createPlaywrightCliTool(ctx) {
         command: Type.String({
             description: `Playwright CLI command name. Allowed: ${PLAYWRIGHT_CLI_ALLOWED_COMMANDS.join(", ")}`,
         }),
-        args: Type.Optional(Type.Array(Type.String(), { description: "Positional/flag args (not a shell string)" })),
-        timeoutSeconds: Type.Optional(Type.Number({ description: "Per-command timeout seconds (default 60, max 600)" })),
+        args: Type.Optional(Type.Array(Type.String(), {
+            description: "Positional/flag args (not a shell string)",
+        })),
+        timeoutSeconds: Type.Optional(Type.Number({
+            description: "Per-command timeout seconds (default 60, max 600)",
+        })),
     }, { additionalProperties: false });
     return defineTool({
         name: "playwright_cli",

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -570,6 +570,106 @@ function canonicalizeVerificationTargetAliases(value) {
         : record.requirements;
     return { ...record, requirements };
 }
+/**
+ * Model-written evidence gaps are hypotheses, not authoritative coverage
+ * facts. If the plan contains a real verification target that explicitly
+ * names a requirement, the executor can prove that the requirement has a
+ * verification path even when the model forgot to wire the target into the
+ * requirement entry or conservatively marked its gap as blocking.
+ *
+ * Keep gaps blocking when that proof cannot be derived. This is deliberately
+ * narrow: it uses only sourceBinding requirement IDs and structurally present
+ * verification targets, and never invents a command, file, or target.
+ */
+function deriveFrontendVerificationCoverage(value, canonicalBinding) {
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    const rawTargets = Array.isArray(record.verificationTargets)
+        ? record.verificationTargets
+        : [];
+    const targetIds = new Set(rawTargets
+        .map((item) => asRecord(item))
+        .filter((item) => Boolean(item))
+        .map((item) => asString(item.id))
+        .filter(Boolean));
+    const targetIdsByRequirement = new Map();
+    for (const item of rawTargets) {
+        const target = asRecord(item);
+        if (!target)
+            continue;
+        const targetId = asString(target.id);
+        const commandLabel = asString(target.commandLabel) || asString(target.command);
+        const file = asString(target.file);
+        // A target is usable evidence only when it has an identity, command and
+        // file. The strict schema will validate the final shape afterwards.
+        if (!targetId || !commandLabel || !file)
+            continue;
+        for (const requirementId of asStringArray(target.requirementIds)) {
+            const canonicalId = canonicalizeRequirementId(requirementId);
+            if (!canonicalBinding.requirementIds.includes(canonicalId))
+                continue;
+            const ids = targetIdsByRequirement.get(canonicalId) ?? [];
+            if (!ids.includes(targetId))
+                ids.push(targetId);
+            targetIdsByRequirement.set(canonicalId, ids);
+        }
+    }
+    const provenRequirementIds = new Set(targetIdsByRequirement.keys());
+    const requirements = Array.isArray(record.requirements)
+        ? record.requirements.map((item) => {
+            const requirement = asRecord(item);
+            if (!requirement)
+                return item;
+            const requirementId = canonicalizeRequirementId(asString(requirement.id));
+            const inferredTargetIds = targetIdsByRequirement.get(requirementId) ?? [];
+            const existingTargetIds = asStringArray(requirement.verificationTargetIds)
+                .filter((id) => targetIds.has(id));
+            const verificationTargetIds = [...new Set([
+                    ...existingTargetIds,
+                    ...inferredTargetIds,
+                ])];
+            const evidenceGap = asRecord(requirement.evidenceGap);
+            const hasProof = provenRequirementIds.has(requirementId);
+            return {
+                ...requirement,
+                ...(verificationTargetIds.length > 0 ? { verificationTargetIds } : {}),
+                ...(hasProof
+                    ? (evidenceGap ? { evidenceGap: { ...evidenceGap, blocking: false } } : {})
+                    : {
+                        evidenceGap: {
+                            requirementId,
+                            description: `No executable verification target can be derived for ${requirementId}`,
+                            blocking: true,
+                        },
+                    }),
+            };
+        })
+        : record.requirements;
+    const modelEvidenceGaps = Array.isArray(record.evidenceGaps)
+        ? record.evidenceGaps.map((item) => {
+            const gap = asRecord(item);
+            if (!gap)
+                return item;
+            const requirementId = canonicalizeRequirementId(asString(gap.requirementId));
+            // Model gaps are advisory. Blocking status is reconstructed below
+            // from the source binding and executable verification targets.
+            return { ...gap, blocking: false };
+        })
+        : [];
+    const derivedBlockingGaps = canonicalBinding.requirementIds
+        .filter((requirementId) => !provenRequirementIds.has(requirementId))
+        .map((requirementId) => ({
+        requirementId,
+        description: `No executable verification target can be derived for ${requirementId}`,
+        blocking: true,
+    }));
+    return {
+        ...record,
+        requirements,
+        evidenceGaps: [...modelEvidenceGaps, ...derivedBlockingGaps],
+    };
+}
 function assertFrontendContractPathsSafe(value) {
     const record = asRecord(value);
     if (!record)
@@ -1069,10 +1169,10 @@ export async function materializeFrontendImplementationContract(input) {
     const normalizedContract = coerceFrontendImplementationContractInput(parsed, canonicalBinding);
     // There is exactly one post-security candidate. A fallback candidate would
     // allow malformed raw fields to bypass the boundary checks above.
-    const candidate = {
+    const candidate = deriveFrontendVerificationCoverage({
         ...(asRecord(normalizedContract) ?? parsed),
         sourceBinding: canonicalBinding,
-    };
+    }, canonicalBinding);
     const result = frontendImplementationContractSchema.safeParse(candidate);
     if (!result.success)
         throw new Error(`invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -1,8 +1,7 @@
 import { readFile, stat } from "node:fs/promises";
-import { createHash } from "node:crypto";
 import path from "node:path";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
-import { frontendImplementationContractSchema, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
+import { frontendImplementationContractSchema, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
 import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 async function selectNode(runDir, primary, fallbacks) {
@@ -37,7 +36,10 @@ async function readNodeText(runDir, nodeId) {
     return text;
 }
 function firstNonEmptyVerdictLine(text) {
-    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const lines = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
     const normalize = (line) => {
         const emphasized = line.match(/^(?:`{1,3}|\*{1,3})\s*(VERDICT:[^`*]+?)\s*(?:`{1,3}|\*{1,3})$/);
         return (emphasized?.[1] ?? line).trim();
@@ -134,7 +136,10 @@ export async function runFrontendPrewriteGate(input) {
         if (input.config.requireSourceFreshness) {
             if (!input.sourceBinding)
                 throw new Error("frontend prewrite gate requires sourceBinding for freshness check");
-            await assertFrontendSourceBindingFresh({ workspaceRoot, binding: input.sourceBinding });
+            await assertFrontendSourceBindingFresh({
+                workspaceRoot,
+                binding: input.sourceBinding,
+            });
         }
         let hasGitMetadata = true;
         try {
@@ -147,7 +152,10 @@ export async function runFrontendPrewriteGate(input) {
                 throw error;
         }
         if (hasGitMetadata)
-            await captureFrontendWorktreeBaseline({ runDir: input.runDir, workspaceRoot });
+            await captureFrontendWorktreeBaseline({
+                runDir: input.runDir,
+                workspaceRoot,
+            });
     }
     const planNodeId = await selectNode(input.runDir, input.config.planFromNodeId, input.config.planFallbackFromNodeIds);
     const reviewNodeId = await selectNode(input.runDir, input.config.reviewFromNodeId, input.config.reviewFallbackFromNodeIds);
@@ -161,20 +169,16 @@ export async function runFrontendPrewriteGate(input) {
     if (missingIds.length > 0) {
         throw new Error(`frontend prewrite gate missing requirement ids: ${missingIds.join(", ")}`);
     }
-    const artifactPath = path.join(input.runDir, input.config.outputDir, input.config.artifactName);
-    const artifact = await stat(artifactPath)
-        .then(async () => ({
-        path: artifactPath,
-        schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
-        sha256: createHash("sha256").update(await readFile(artifactPath)).digest("hex"),
-    }))
-        .catch(() => materializeFrontendImplementationContract({
+    // Always rematerialize from the selected plan node. Reusing a previous
+    // contracts/*.json would accept stale contracts when a higher-priority
+    // FINISHED primary is present but invalid (see composite-shell invalid-primary).
+    const artifact = await materializeFrontendImplementationContract({
         runDir: input.runDir,
         fromNodeId: planNodeId,
         artifactName: input.config.artifactName,
         outputDir: input.config.outputDir,
         sourceBinding: input.sourceBinding,
-    }));
+    });
     const raw = JSON.parse(await readFile(artifact.path, "utf8"));
     const contract = frontendImplementationContractSchema.parse(raw);
     if (!input.config.allowedMockStrategies.includes(contract.mockApi.strategy)) {

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

@@ -3588,8 +3588,14 @@ async function buildBackendTestHybridDag(sources) {
         writeSet: ["testcase/md/**"],
         allowedPaths: ["testcase/md/**"],
         forbiddenPaths: forbidden,
+        writerOutcomePolicy: {
+            type: "implementation-outcome-v1",
+            requireChangedFiles: true,
+        },
         outputContract: "Write a Chinese, human-readable testcase/md/README.md plus module Markdown case cards using BE-<MODULE>-<NNN>; keep machine IDs/literals exact and do not execute pytest or modify production code/config.",
         subtask_prompt: [
+            "This is a required file-generation node. After reading the bounded inputs, immediately use write/edit tools to create testcase/md/README.md and the module Markdown files. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists.",
+            "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the required files have been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.",
             "Read the upstream environment report. Generate a Markdown-first backend test strategy and cases under testcase/md/**.",
             "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
             "Create testcase/md/README.md as the concise 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 README.",

package/dist/workflows/dag/types.js

@@ -537,6 +537,8 @@ export const dagDecisionGateSchema = z.object({
 export const dagWriterOutcomePolicySchema = z
     .object({
     type: z.literal("implementation-outcome-v1"),
+    /** Generation writers may forbid already-satisfied/no-diff completion. */
+    requireChangedFiles: z.boolean().optional(),
 })
     .strict();
 export const dagConvergenceSpecSchema = z

package/docs/templates/agent-dag.schema.json

@@ -533,7 +533,11 @@
           "required": ["type"],
           "description": "Fail-closed outcome/diff consistency protocol for bounded Pi writers. The first non-empty assistant line must be IMPLEMENTATION_OUTCOME: changed, already-satisfied, or blocked.",
           "properties": {
-            "type": { "const": "implementation-outcome-v1" }
+            "type": { "const": "implementation-outcome-v1" },
+            "requireChangedFiles": {
+              "type": "boolean",
+              "description": "When true, already-satisfied and every empty run-attributed diff fail closed. Use for generation nodes whose output contract requires fresh files."
+            }
           }
         },
         "allowedPaths": {

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

@@ -125,7 +125,11 @@
         "artifacts/**"
       ],
       "outputContract": "Write a Chinese, human-readable testcase/md/README.md plus module Markdown case cards using BE-<MODULE>-<NNN>; keep machine IDs/literals exact and do not execute pytest or modify production code/config.",
-      "subtask_prompt": "Read the upstream environment report. Generate a Markdown-first backend test strategy and cases under testcase/md/**.\n\nWrite human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.\n\nCreate testcase/md/README.md as the concise 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 README.\n\nBefore the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in README 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`. Classify from authoritative task/reference evidence, not merely whether a route already exists. Use only these pairs: `new-operation` → `full-contract`; `contract-change` → `affected-contract-full`; `behavior-change` → `affected-behavior-full`; `bugfix` → `reproduction-plus-neighbors`; `implementation-optimization` → `change-focused-plus-regression-floor`. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.\n\nCoverage depth follows the declared change scope. For `new-operation`, fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected new operation, but do not re-test unrelated existing operations. For contract/behavior changes, fully cover the changed contract or behavior and its directly affected operations. For bugfix, cover exact reproduction, adjacent boundary/equivalence cases and a normal path. For `implementation-optimization`, cover explicit ACs, deterministic affected operations and a minimum regression floor; do not exhaustively regenerate unrelated POST/PUT/GET/DELETE rules. Every non-new classification must include `main-success-path` and `unchanged-response-shape`; contract changes also include `changed-contract-boundaries`, behavior changes `affected-state-transition`, and bugfixes `defect-reproduction` plus `adjacent-boundary`. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same changed path can affect them; unresolved impact stays visible as GAP/CONFLICT.\n\nBefore writing cases, build the mandatory machine-readable Coverage Matrix inside `testcase/md/README.md` 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\nWrite each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射`; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol.\n\nName each module file with a stable lowercase business stem such as `testcase/md/health.md` or `testcase/md/resource_notes.md`. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.\n\nEvery Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.\n\nIn every `自动化映射`, use exactly these machine-readable list labels: `脚本`, `primary symbol`, `变体测试点`, `场景断言测试点`, `横切证据测试点`. Each Test Point from `### 测试点` must appear in exactly one binding list, and every Test Point named in any binding list must also be declared in that Case's `### 测试点`; write `无` for an empty list. A variant Test Point is atomic: one exact endpoint/input/precondition/outcome row equals one exact pytest item and one exact TP ID. If a parameter table has five rows, declare five distinct variant TP IDs in Markdown; never declare one family TP and append row suffixes only in pytest. Classify as `variant` only when endpoint, request input, precondition business state, or expected outcome genuinely changes and therefore needs an independent pytest parameter item. Classify CRUD checkpoints, status/body/header/schema assertions and multiple checks over the same response/journey as `assertion`; classify shared HTTP logging/redaction/truncation evidence as `cross-cutting`. Never create a Test Point merely to parameterize a checkpoint. Every non-cross-cutting TP ID is owned by exactly one Case; when the same response/schema/error assertion is needed in different Cases, use distinct Case-specific TP IDs instead of reusing one assertion TP across Cases. Keep the script path identical to the module one-to-one path and declare exactly one primary symbol named with the canonical Case prefix, for example `BE-RN-003` → `test_BE_RN_003_<description>`; non-Case-prefixed primary symbols are forbidden because parameterized item association must remain deterministic. For redaction scenarios, list sensitive header/field key names only. Never write any header-name-and-value pair, credential placeholder, fake token, anti-example, or other secret-shaped literal in Markdown; state only that a test-only value is supplied at runtime and omitted. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Before finalizing Markdown, 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 file-generation node. After reading the bounded inputs, immediately use write/edit tools to create testcase/md/README.md and the module Markdown files. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists.\n\nThe first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the required files have been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.\n\nRead the upstream environment report. Generate a Markdown-first backend test strategy and cases under testcase/md/**.\n\nWrite human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.\n\nCreate testcase/md/README.md as the concise 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 README.\n\nBefore the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in README 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`. Classify from authoritative task/reference evidence, not merely whether a route already exists. Use only these pairs: `new-operation` → `full-contract`; `contract-change` → `affected-contract-full`; `behavior-change` → `affected-behavior-full`; `bugfix` → `reproduction-plus-neighbors`; `implementation-optimization` → `change-focused-plus-regression-floor`. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.\n\nCoverage depth follows the declared change scope. For `new-operation`, fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected new operation, but do not re-test unrelated existing operations. For contract/behavior changes, fully cover the changed contract or behavior and its directly affected operations. For bugfix, cover exact reproduction, adjacent boundary/equivalence cases and a normal path. For `implementation-optimization`, cover explicit ACs, deterministic affected operations and a minimum regression floor; do not exhaustively regenerate unrelated POST/PUT/GET/DELETE rules. Every non-new classification must include `main-success-path` and `unchanged-response-shape`; contract changes also include `changed-contract-boundaries`, behavior changes `affected-state-transition`, and bugfixes `defect-reproduction` plus `adjacent-boundary`. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same changed path can affect them; unresolved impact stays visible as GAP/CONFLICT.\n\nBefore writing cases, build the mandatory machine-readable Coverage Matrix inside `testcase/md/README.md` 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\nWrite each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射`; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol.\n\nName each module file with a stable lowercase business stem such as `testcase/md/health.md` or `testcase/md/resource_notes.md`. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.\n\nEvery Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.\n\nIn every `自动化映射`, use exactly these machine-readable list labels: `脚本`, `primary symbol`, `变体测试点`, `场景断言测试点`, `横切证据测试点`. Each Test Point from `### 测试点` must appear in exactly one binding list, and every Test Point named in any binding list must also be declared in that Case's `### 测试点`; write `无` for an empty list. A variant Test Point is atomic: one exact endpoint/input/precondition/outcome row equals one exact pytest item and one exact TP ID. If a parameter table has five rows, declare five distinct variant TP IDs in Markdown; never declare one family TP and append row suffixes only in pytest. Classify as `variant` only when endpoint, request input, precondition business state, or expected outcome genuinely changes and therefore needs an independent pytest parameter item. Classify CRUD checkpoints, status/body/header/schema assertions and multiple checks over the same response/journey as `assertion`; classify shared HTTP logging/redaction/truncation evidence as `cross-cutting`. Never create a Test Point merely to parameterize a checkpoint. Every non-cross-cutting TP ID is owned by exactly one Case; when the same response/schema/error assertion is needed in different Cases, use distinct Case-specific TP IDs instead of reusing one assertion TP across Cases. Keep the script path identical to the module one-to-one path and declare exactly one primary symbol named with the canonical Case prefix, for example `BE-RN-003` → `test_BE_RN_003_<description>`; non-Case-prefixed primary symbols are forbidden because parameterized item association must remain deterministic. For redaction scenarios, list sensitive header/field key names only. Never write any header-name-and-value pair, credential placeholder, fake token, anti-example, or other secret-shaped literal in Markdown; state only that a test-only value is supplied at runtime and omitted. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Before finalizing Markdown, 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.",
+      "writerOutcomePolicy": {
+        "type": "implementation-outcome-v1",
+        "requireChangedFiles": true
+      }
     },
     {
       "id": "review-and-revise-backend-md-cases-pi",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.28.1-beta.1",
+  "version": "0.28.2-beta.1",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",