@tea-agent/loop-agent 0.27.1-beta.2 → 0.27.1

package/CHANGELOG.md

@@ -2,9 +2,24 @@
 
 ## [Unreleased]
 
+## [0.27.1] - 2026-08-04
+
+### 重点更新
+
+- 前端测试 L-5 报告看板全新改版，与后端报告模板统一
+- 修复后端测试因 pytest 脚本漏生成而直接阻断的问题，升级为精确的缺失脚本恢复机制
+
+### 新增
+
+- 前端测试 L-5 看板新增确定性质量信号、门禁摘要、证据详情及用例执行详情展示
+
+### 改进
+
+- 前端 L-5 报告看板与后端报告模板视觉与结构对齐，提升跨端报告一致性
+
 ### 修复
 
-- 修复 backend-test collection assess 在 Markdown 已声明安全 mapped `test_*.py`、但 pytest writer 漏生成文件时直接以 `invalid-output` 阻断 repair 的问题：initial facts 升级为 `backend-test-pytest-collection-v2`，可记录 expected/existing/missing scripts、`collectionAttempted=false` 与 `missing-mapped-pytest-script`，复用既有单次 bounded repair 创建精确缺失脚本，并由 final collection、scope、安全和 hash freshness 门禁重新授权业务执行
+- 修复后端测试在 Markdown 已声明安全映射脚本、但 pytest writer 漏生成文件时直接以 invalid-output 阻断 repair 的问题：initial facts 升级为 backend-test-pytest-collection-v2，可记录 expected/existing/missing scripts、collectionAttempted=false 与 missing-mapped-pytest-script，复用既有单次有界 repair 精确创建缺失脚本，并由最终收集、scope、安全和 hash freshness 门禁重新授权业务执行
 
 ## [0.27.0] - 2026-08-03
 

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

@@ -576,19 +576,32 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
 export function validateWriterImplementationOutcome(text, changedFiles) {
     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}`,
+        };
+    }
+    return { ok: true, outcome };
 }
 function parseWriterImplementationOutcome(text) {
     const lines = text.split(/\r?\n/);
@@ -719,15 +732,6 @@ function normalizeProtocolLine(line, firstProtocolLine, nextLine) {
         const value = normalizedProtocolValue(direct[1] ?? "");
         return value ? `${firstProtocolLine} ${value}` : undefined;
     }
-    // Writers sometimes place a short delivery sentence before the protocol
-    // line. Accept the protocol token when it appears inline, while preserving
-    // the candidate value so template repetitions still fail as unknown or
-    // conflicting outcomes.
-    const inline = normalizedLine.match(new RegExp(`${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
-    if (inline) {
-        const value = normalizedProtocolValue(inline[1] ?? "");
-        return value ? `${firstProtocolLine} ${value}` : undefined;
-    }
     const splitValue = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]?\\s*$`, "i"));
     if (splitValue && nextLine !== undefined) {
         const value = normalizedProtocolValue(nextLine);

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

@@ -155,7 +155,7 @@ export const frontendImplementationContractSchema = z
             "not-needed",
         ]),
         productionDefaultOff: z.literal(true),
-        activation: z.preprocess((value) => (value === "" || value === null ? "explicit activation boundary" : value), z.string().min(1)),
+        activation: z.string().min(1),
         endpoints: z.array(z
             .object({
             method: z.enum([
@@ -168,10 +168,7 @@ export const frontendImplementationContractSchema = z
                 "OPTIONS",
             ]),
             path: z.string().startsWith("/"),
-            // Models occasionally emit an empty fixture when Mock is
-            // intentionally not needed. Treat it like an omitted optional
-            // field; active Mock strategies still fail the refinement below.
-            fixture: z.preprocess((value) => (value === "" || value === null ? undefined : value), safePath.optional()),
+            fixture: safePath.optional(),
             consumer: safePath.optional(),
         })
             .strict()),
@@ -190,7 +187,7 @@ export const frontendImplementationContractSchema = z
         type: z.enum(["static", "unit", "component", "integration", "mock"]),
         commandLabel: z.string().min(1),
         file: safePath,
-        symbol: z.preprocess((value) => (value === "" || value === null ? undefined : value), z.string().min(1).optional()),
+        symbol: z.string().min(1).optional(),
         requirementIds: z.array(id),
         uiStates: z.array(z.string().min(1)),
     })
@@ -346,127 +343,12 @@ function secretIssues(value, at = "$", issues = []) {
 }
 export function extractFrontendImplementationJson(text) {
     const trimmed = text.trim();
-    const parse = (source) => {
-        try {
-            return JSON.parse(source);
-        }
-        catch (error) {
-            // Models sometimes put ordinary ASCII quotes inside a JSON string
-            // (for example: `reason: "支持..."`). Repair only quotes that are
-            // clearly not structural: a closing quote is followed by JSON
-            // punctuation, while an embedded quote is followed by content.
-            let repaired = "";
-            let inString = false;
-            let escaped = false;
-            for (let index = 0; index < source.length; index += 1) {
-                const character = source[index];
-                if (character !== '"') {
-                    repaired += character;
-                    if (inString && character === "\\" && !escaped)
-                        escaped = true;
-                    else
-                        escaped = false;
-                    continue;
-                }
-                if (escaped) {
-                    repaired += character;
-                    escaped = false;
-                    continue;
-                }
-                if (!inString) {
-                    inString = true;
-                    repaired += character;
-                    continue;
-                }
-                const next = source.slice(index + 1).trimStart()[0];
-                if ([",", "}", "]", ":"].includes(next ?? "") || source.slice(index + 1).trim() === "") {
-                    inString = false;
-                    repaired += character;
-                }
-                else {
-                    repaired += "\\\"";
-                }
-            }
-            try {
-                return JSON.parse(repaired);
-            }
-            catch {
-                throw error;
-            }
-        }
-    };
-    const isContract = (candidate) => {
-        const record = asRecord(candidate);
-        return (record?.schemaVersion === 1 &&
-            asRecord(record.targets) !== null &&
-            Array.isArray(record.requirements) &&
-            Array.isArray(record.verificationTargets));
-    };
     if (trimmed.startsWith("{") && trimmed.endsWith("}"))
-        return parse(trimmed);
-    const balancedObjects = [];
-    for (let start = 0; start < trimmed.length; start += 1) {
-        if (trimmed[start] !== "{")
-            continue;
-        let depth = 0;
-        let inString = false;
-        let escaped = false;
-        for (let index = start; index < trimmed.length; index += 1) {
-            const character = trimmed[index];
-            if (inString) {
-                if (escaped)
-                    escaped = false;
-                else if (character === "\\")
-                    escaped = true;
-                else if (character === '"')
-                    inString = false;
-                continue;
-            }
-            if (character === '"')
-                inString = true;
-            else if (character === "{")
-                depth += 1;
-            else if (character === "}" && --depth === 0) {
-                try {
-                    const candidate = parse(trimmed.slice(start, index + 1));
-                    if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
-                        balancedObjects.push(candidate);
-                }
-                catch {
-                    // Continue scanning for a later complete JSON object.
-                }
-                break;
-            }
-        }
-    }
-    const balancedContracts = balancedObjects.filter(isContract);
-    if (balancedContracts.length === 1)
-        return balancedContracts[0];
-    if (balancedObjects.length === 1)
-        return balancedObjects[0];
+        return JSON.parse(trimmed);
     const blocks = [...trimmed.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)];
-    if (blocks.length === 0)
+    if (blocks.length !== 1)
         throw new Error("output must contain exactly one fenced json object");
-    const candidates = [];
-    for (const block of blocks) {
-        try {
-            const candidate = parse(block[1]);
-            if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
-                candidates.push(candidate);
-        }
-        catch {
-            // Ignore incomplete model scratch blocks. A later complete contract
-            // block may still be deterministically recoverable.
-        }
-    }
-    const contractCandidates = candidates.filter(isContract);
-    if (contractCandidates.length === 1)
-        return contractCandidates[0];
-    if (candidates.length === 1)
-        return candidates[0];
-    if (candidates.length === 0)
-        throw new Error("output must contain exactly one valid fenced json object (found 0)");
-    throw new Error(`output must contain exactly one valid frontend contract json object (found ${contractCandidates.length || candidates.length})`);
+    return JSON.parse(blocks[0][1]);
 }
 /**
  * Build the authoritative frontend-implementation-contract sourceBinding from

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) {
@@ -47,12 +46,7 @@ function firstNonEmptyVerdictLine(text) {
     // The prompt requires VERDICT to be the first non-empty line, but model
     // output can still prepend a summary. Keep the protocol strict in the
     // prompt while making the deterministic gate resilient to that drift.
-    const verdictLine = normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
-    if (/^VERDICT:\s*pass(?:\s*[.!?。！？]|\s+|$)/i.test(verdictLine))
-        return "VERDICT: pass";
-    if (/^VERDICT:\s*request-revision(?:\s*[.!?。！？]|\s+|$)/i.test(verdictLine))
-        return "VERDICT: request-revision";
-    return verdictLine;
+    return normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
 }
 function eventArgs(event) {
     return event.args ?? event.toolInput ?? event.input ?? {};
@@ -128,23 +122,6 @@ async function checkOpenspecReadEvidence(input) {
     }
     return [...matched];
 }
-async function existingOpenspecCandidates(candidates, repoRoot) {
-    const existing = [];
-    for (const candidate of candidates) {
-        if (!isOpenspecSpecFilePath(candidate))
-            continue;
-        try {
-            const info = await stat(path.resolve(repoRoot, candidate));
-            if (info.isFile())
-                existing.push(candidate);
-        }
-        catch {
-            // Model-generated typos and stale capability paths are not readable
-            // evidence candidates and must not create a false prewrite block.
-        }
-    }
-    return existing;
-}
 export async function runFrontendPrewriteGate(input) {
     const workspaceRoot = input.workspaceRoot ?? input.repoRoot;
     if (workspaceRoot) {
@@ -178,20 +155,13 @@ 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({
+    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)) {
@@ -205,7 +175,7 @@ export async function runFrontendPrewriteGate(input) {
             throw new Error(`frontend prewrite gate contract target is outside implementation writeSet: ${uncoveredTargets.join(", ")}`);
         }
     }
-    const candidatePaths = await existingOpenspecCandidates(input.config.openspecCandidatePaths ?? [], workspaceRoot ?? process.cwd());
+    const candidatePaths = input.config.openspecCandidatePaths ?? [];
     const openspecReadPaths = await checkOpenspecReadEvidence({
         runDir: input.runDir,
         candidatePaths,

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

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { access, readdir, readFile, realpath } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
@@ -1078,14 +1079,40 @@ function isFrontendLintVerifyCommand(command) {
     const text = `${command.label}\n${command.args.join(" ")}`;
     return /\b(?:lint|eslint)\b/i.test(text);
 }
+function isManagedCiWrapperVerifyCommand(command) {
+    const text = `${command.label}\n${command.args.join(" ")}`.replaceAll("\\", "/");
+    return /\bscripts\/ci(?:-tests)?\.sh\b/.test(text);
+}
+function repoHasNpmScript(repoRoot, scriptName) {
+    if (!repoRoot)
+        return false;
+    const packagePath = path.join(repoRoot, "package.json");
+    if (!existsSync(packagePath))
+        return false;
+    try {
+        const decoded = JSON.parse(readFileSync(packagePath, "utf8"));
+        return typeof decoded.scripts?.[scriptName] === "string";
+    }
+    catch {
+        return false;
+    }
+}
 function partitionFrontendStaticVerifyCommands(input) {
     const commands = input.commands ?? [];
-    // Frontend DAGs deliberately never generate lint verification. Existing
-    // project lint debt is allowed to remain outside this workflow, and an
-    // explicitly mentioned lint command must not reintroduce the lint gate.
+    const lintCommands = commands.filter(isFrontendLintVerifyCommand);
     const staticCommands = commands.filter((command) => !isFrontendLintVerifyCommand(command));
+    if (lintCommands.length === 0 &&
+        commands.some(isManagedCiWrapperVerifyCommand) &&
+        repoHasNpmScript(input.repoRoot, "lint")) {
+        lintCommands.push({
+            args: ["npm", "run", "lint"],
+            cwd: input.repoRoot,
+            label: "npm run lint",
+        });
+    }
     return {
         lint: {
+            ...(lintCommands.length > 0 ? { commands: lintCommands } : {}),
             commandSource: input.commandSource,
         },
         static: {
@@ -1184,6 +1211,7 @@ async function discoverFrontendFallbackVerifyCommands(repoRoot) {
     const staticCommands = firstExisting([
         "typecheck",
         "check-types",
+        "lint",
         "check",
         "build",
     ]);
@@ -2427,62 +2455,9 @@ async function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                 ].join("\n\n"),
             },
-            {
-                id: "frontend-contract-json-pi",
-                depends_on: [
-                    "frontend-plan-revision-pi",
-                    "frontend-plan-pi",
-                    "frontend-final-design-review-pi",
-                    "frontend-design-review-pi",
-                ],
-                dependsPolicy: "all-or-condition-skip",
-                role: "planner",
-                executor: "pi",
-                complexity: "MED",
-                writePolicy: "read-only",
-                outputMode: "structured-required",
-                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Return exactly one JSON object conforming to frontend-implementation-contract-v1. No Markdown, prose, comments, or code fences.",
-                subtask_prompt: [
-                    "Convert the effective reviewed frontend plan into the canonical frontend-implementation-contract-v1 JSON.",
-                    "Use frontend-plan-revision-pi when it is FINISHED; otherwise use frontend-plan-pi. Confirm the effective design review passed before producing the contract.",
-                    "Return only the JSON object. Do not wrap it in Markdown or a code fence. Do not add explanatory text.",
-                    "Preserve all requirement expectedOutcome, interaction trigger/expectedBehavior, target files, verification targets, Mock/API decisions, and Real Integration Gap from the effective plan.",
-                    frontendContractSchemaBlock,
-                    sourceContext,
-                ].join("\n\n"),
-            },
-            {
-                id: "frontend-contract-json-validate-shell",
-                depends_on: ["frontend-contract-json-pi"],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Validated frontend implementation contract artifact with schema ID and SHA-256.",
-                subtask_prompt: "Materialize and validate the structured frontend contract before prewrite authorization.",
-                shell: {
-                    commands: [],
-                    jsonArtifactGate: {
-                        fromNodeId: "frontend-contract-json-pi",
-                        schemaId: "frontend-implementation-contract-v1",
-                        artifactName: "frontend-implementation-contract.json",
-                        outputDir: "contracts",
-                    },
-                    cwd: ".",
-                    timeoutMs: 60000,
-                },
-            },
             {
                 id: "frontend-prewrite-gate-shell",
                 depends_on: [
-                    "frontend-contract-json-pi",
-                    "frontend-contract-json-validate-shell",
                     "frontend-final-design-review-pi",
                     "frontend-design-review-pi",
                     "frontend-plan-revision-pi",
@@ -2501,8 +2476,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     commands: [],
                     frontendPrewriteGate: {
                         schemaVersion: 1,
-                        planFromNodeId: "frontend-contract-json-pi",
-                        planFallbackFromNodeIds: ["frontend-plan-revision-pi", "frontend-plan-pi"],
+                        planFromNodeId: "frontend-plan-revision-pi",
+                        planFallbackFromNodeIds: ["frontend-plan-pi"],
                         reviewFromNodeId: "frontend-final-design-review-pi",
                         reviewFallbackFromNodeIds: ["frontend-design-review-pi"],
                         requiredRequirementIds: requirementIds,
@@ -5312,7 +5287,7 @@ async function buildHybridDagForTemplate(sources, template) {
         else if (template === "review-gated-dag")
             spec = buildReviewGatedHybridDag(standard, sources);
         else
-            spec = await buildSupervisedHybridDag(standard, sources);
+            spec = buildSupervisedHybridDag(standard, sources);
     }
     applyProjectGovernanceReview(spec, template, sources);
     // New generate path always emits DagSpec v4 + bindings.
@@ -5746,12 +5721,10 @@ function buildWriteSetGateNode(sources) {
         },
     };
 }
-async function buildSoftVerifyNode(sources) {
+function buildSoftVerifyNode(sources) {
     const implementId = implementationNodeId();
     const strategy = resolveDagVerifyStrategy(sources.taskConfig, "1");
-    const fallbackCommands = sources.repoRoot
-        ? (await discoverFrontendFallbackVerifyCommands(sources.repoRoot)).staticCommands
-        : ["npm run typecheck"];
+    const fallbackCommands = ["npm run typecheck"];
     const focusedIntermediate = sources.verifyCommands?.intermediate.filter((command) => !isFullSuiteVerifyCommand(command));
     const plannedIntermediate = applyMavenVerificationPlanning({
         repoRoot: sources.repoRoot,
@@ -5993,7 +5966,7 @@ function resolveSupervisedConvergence(taskConfig) {
         chainNodeIds: [...SUPERVISED_CONVERGENCE_CHAIN_NODE_IDS],
     };
 }
-async function buildSupervisedHybridDag(standard, sources) {
+function buildSupervisedHybridDag(standard, sources) {
     const contract = getTaskOrThrow(standard, "contract-pi");
     const scoutSrc = getTaskOrThrow(standard, "scout-src");
     const scoutTests = getTaskOrThrow(standard, "scout-tests");
@@ -6045,7 +6018,7 @@ async function buildSupervisedHybridDag(standard, sources) {
                     "final-write-set-audit-format-repair-pi",
                 ],
             }),
-            await buildSoftVerifyNode(sources),
+            buildSoftVerifyNode(sources),
             buildProcessSupervisorNode(sources),
             buildProcessGateNode(sources),
             buildRepairNode(sources),

package/dist/workflows/dag/output-protocol.js

@@ -206,29 +206,6 @@ export function validateOutputProtocol(protocol, text) {
             reason: `missing first non-empty line; expected one of: ${protocol.validLines.map((l) => JSON.stringify(l)).join(" or ")}`,
         };
     }
-    const isReviewVerdict = protocol.validLines.length === 2 && protocol.validLines.includes("VERDICT: pass") && protocol.validLines.includes("VERDICT: request-revision");
-    // Models frequently prepend a short explanation despite the protocol
-    // instruction. Recover only when there is exactly one unambiguous protocol
-    // line; conflicting or repeated verdicts remain fail-closed.
-    const candidates = isReviewVerdict ? text
-        .split("\n")
-        .map((line) => normalizeVerdictCandidateLine(line.trim()))
-        .filter((line) => protocol.validLines.includes(line)) : [];
-    const uniqueCandidates = [...new Set(candidates)];
-    if (uniqueCandidates.length > 1) {
-        return {
-            ok: false,
-            failureCategory: "protocol-invalid",
-            reason: `conflicting protocol lines found: ${uniqueCandidates.map((line) => JSON.stringify(line)).join(" and ")}`,
-            firstNonEmptyLine: first,
-        };
-    }
-    if (protocol.validLines.includes(first)) {
-        return { ok: true, matchedLine: first };
-    }
-    if (uniqueCandidates.length === 1) {
-        return { ok: true, matchedLine: uniqueCandidates[0] };
-    }
     if (!protocol.validLines.includes(first)) {
         return {
             ok: false,

package/docs/templates/frontend-implementation-contract.schema.json

@@ -13,9 +13,9 @@
     "requirements": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "expectedOutcome", "implementationTargets", "verificationTargetIds"], "properties": { "id": { "$ref": "#/$defs/requirementId" }, "expectedOutcome": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "evidenceGap": { "$ref": "#/$defs/gap" } } } },
     "uiStates": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "applicable"], "properties": { "name": { "type": "string", "minLength": 1 }, "applicable": { "type": "boolean" }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "notApplicableReason": { "type": "string", "minLength": 1 } }, "allOf": [{ "if": { "properties": { "applicable": { "const": true } }, "required": ["applicable"] }, "then": { "required": ["expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "implementationTargets": { "minItems": 1 }, "verificationTargetIds": { "minItems": 1 } } } }, { "if": { "properties": { "applicable": { "const": false } }, "required": ["applicable"] }, "then": { "required": ["notApplicableReason"] } }] } },
     "interactions": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "trigger", "expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "name": { "type": "string", "minLength": 1 }, "trigger": { "type": "string", "minLength": 1 }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string" } } } } },
-    "mockApi": { "type": "object", "additionalProperties": false, "required": ["strategy", "productionDefaultOff", "activation", "endpoints"], "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter", "not-needed"] }, "productionDefaultOff": { "const": true }, "activation": { "type": ["string", "null"], "minLength": 1 }, "endpoints": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["method", "path"], "properties": { "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "fixture": { "anyOf": [{ "$ref": "#/$defs/path" }, { "type": "null" }] }, "consumer": { "anyOf": [{ "$ref": "#/$defs/path" }, { "type": "null" }] } } } } } },
+    "mockApi": { "type": "object", "additionalProperties": false, "required": ["strategy", "productionDefaultOff", "activation", "endpoints"], "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter", "not-needed"] }, "productionDefaultOff": { "const": true }, "activation": { "type": "string", "minLength": 1 }, "endpoints": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["method", "path"], "properties": { "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "fixture": { "$ref": "#/$defs/path" }, "consumer": { "$ref": "#/$defs/path" } } } } } },
     "designEvidence": { "type": "object", "additionalProperties": false, "required": ["source", "paths", "conflicts"], "properties": { "source": { "type": "string", "minLength": 1 }, "paths": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "conflicts": { "type": "array", "items": { "type": "string", "minLength": 1 } } } },
-    "verificationTargets": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "type", "commandLabel", "file", "requirementIds", "uiStates"], "properties": { "id": { "type": "string", "minLength": 1 }, "type": { "enum": ["static", "unit", "component", "integration", "mock"] }, "commandLabel": { "type": "string", "minLength": 1 }, "file": { "$ref": "#/$defs/path" }, "symbol": { "anyOf": [{ "type": "string", "minLength": 1 }, { "type": "null" }] }, "requirementIds": { "type": "array", "items": { "$ref": "#/$defs/requirementId" } }, "uiStates": { "type": "array", "items": { "type": "string", "minLength": 1 } } } } },
+    "verificationTargets": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "type", "commandLabel", "file", "requirementIds", "uiStates"], "properties": { "id": { "type": "string", "minLength": 1 }, "type": { "enum": ["static", "unit", "component", "integration", "mock"] }, "commandLabel": { "type": "string", "minLength": 1 }, "file": { "$ref": "#/$defs/path" }, "symbol": { "type": "string", "minLength": 1 }, "requirementIds": { "type": "array", "items": { "$ref": "#/$defs/requirementId" } }, "uiStates": { "type": "array", "items": { "type": "string", "minLength": 1 } } } } },
     "evidenceGaps": { "type": "array", "items": { "$ref": "#/$defs/gap" } }
   },
   "allOf": [{ "if": { "properties": { "mockApi": { "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter"] } } } } }, "then": { "properties": { "mockApi": { "properties": { "endpoints": { "minItems": 1, "items": { "required": ["method", "path", "fixture", "consumer"] } } } } } } }],

package/harness.json

@@ -6,7 +6,7 @@
   "workflowPolicy": {
     "defaultImplementationWorkflow": "agent-dag",
     "dag": {
-     "defaultEntry": "task advance",
+      "defaultEntry": "task advance",
       "outputLanguage": "zh-CN",
       "profileRouting": {
         "minimal": "standard-dag",
@@ -58,9 +58,9 @@
   "executors": {
     "pi": {
       "description": "Pi planning, review, diagnosis, and bounded writing when DAG toolProfile=write",
-      "LOW": {"model": "deepseek/deepseek-v4-flash", "thinking": "high"},
-      "MED": {"model": "deepseek/deepseek-v4-flash", "thinking": "max"},
-      "HIGH": {"model": "deepseek/deepseek-v4-flash", "thinking": "max"}
+      "LOW": "minimax-m3",
+      "MED": "grok-4.5",
+      "HIGH": "gpt-5.6-sol"
     }
   }
 }

package/package.json

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