@tea-agent/loop-agent 0.39.0-beta.11 → 0.39.0-beta.12

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.39.0-beta.11",
-  "gitSha": "5614959a483efbdc1f3a598246fee5cee57595d4",
-  "builtAt": "2026-08-28T03:23:49.173Z"
+  "version": "0.39.0-beta.12",
+  "gitSha": "f6c24c6c6eaacfcc975732dec41df6ef5027f16c",
+  "builtAt": "2026-08-28T08:40:28.786Z"
 }

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

@@ -2,6 +2,7 @@ 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 { fileURLToPath } from "node:url";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
 import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1, DAG_RUNTIME_CONTRACT_SCHEMA_VERSION, DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
@@ -2764,6 +2765,37 @@ function resolveFrontendShapeCapsuleGenerationInput(sources) {
     }
     return explicit ?? autoloaded;
 }
+/** Standard frontend DAG template (docs/templates/frontend-implementation-dag.json).
+ * It is the topology source of truth: node set, execution order, and depends_on
+ * come from the template; the runtime generator assembles each node's full
+ * configuration (budgets, retry, skeleton, skills, dynamic prompt sections).
+ * Resolution order: repoRoot copy (dev workspace) → bundled package copy. */
+export async function loadFrontendDagTemplate(repoRoot) {
+    const candidates = [];
+    if (repoRoot) {
+        candidates.push(path.join(repoRoot, "docs", "templates", "frontend-implementation-dag.json"));
+    }
+    candidates.push(fileURLToPath(new URL("../../../docs/templates/frontend-implementation-dag.json", import.meta.url)));
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(await readFile(candidate, "utf8"));
+            if (!Array.isArray(parsed.tasks))
+                continue;
+            const tasks = parsed.tasks.filter((item) => typeof item === "object" &&
+                item !== null &&
+                typeof item.id === "string" &&
+                Array.isArray(item.depends_on) &&
+                typeof item.executor === "string");
+            if (tasks.length === 0)
+                continue;
+            return { tasks };
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
 async function buildFrontendHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const mockCapability = sources.frontendMockCapability ?? {
@@ -3461,6 +3493,34 @@ async function buildFrontendHybridDagFromTask(sources) {
             },
         ],
     };
+    // The static DAG template is the topology source of truth: the generated
+    // chain must match the template's node set and order, and the template's
+    // depends_on must be a subset of the generated one (the runtime may add
+    // dependencies, e.g. Mock-required planning depending on the contract
+    // node's Mock facts). The template's own tasks carry simplified placeholder
+    // configs; the generated node definitions (budgets, retry, skeleton,
+    // skills, prompts) and any runtime-added dependencies win.
+    const frontendTemplate = await loadFrontendDagTemplate(sources.repoRoot);
+    if (frontendTemplate) {
+        const byId = new Map(spec.tasks.map((task) => [task.id, task]));
+        const templateIds = frontendTemplate.tasks.map((task) => task.id);
+        const missing = templateIds.filter((id) => !byId.has(id));
+        if (missing.length > 0) {
+            throw new Error(`frontend DAG template topology drift: generated chain is missing template node(s): ${missing.join(", ")}`);
+        }
+        for (const templateTask of frontendTemplate.tasks) {
+            const generated = byId.get(templateTask.id);
+            const generatedDeps = new Set(generated.depends_on);
+            const templateOnly = templateTask.depends_on.filter((dep) => !generatedDeps.has(dep));
+            if (templateOnly.length > 0) {
+                throw new Error(`frontend DAG template topology drift: generated node ${templateTask.id} is missing template dependency ${templateOnly.join(", ")}`);
+            }
+        }
+        const templateSet = new Set(templateIds);
+        const ordered = templateIds.map((id) => byId.get(id));
+        const extra = spec.tasks.filter((task) => !templateSet.has(task.id));
+        spec.tasks = [...ordered, ...extra];
+    }
     if (frontendTaskShape.shape === "split-required") {
         spec.tasks = pruneFrontendTasksForSplitRequired(spec.tasks);
     }

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

@@ -254,11 +254,25 @@ function planInputStrings(value) {
         ? value.filter((item) => typeof item === "string")
         : [];
 }
+/** Input bound for the planner evidence block; protects the model input budget. */
+const FRONTEND_PLAN_INPUT_MAX_CHARS = 12_000;
+const FRONTEND_PLAN_INPUT_CAP_LADDER = [
+    { text: 240, array: 40 },
+    { text: 120, array: 20 },
+    { text: 60, array: 10 },
+    { text: 24, array: 4 },
+];
 /**
  * Render the planner's complete-but-bounded evidence handoff from committed
  * typed facts. It deliberately excludes upstream response prose and artifact
  * paths: Contract and Scout have already established these facts, so Plan
  * should decide and commit rather than spend another model turn reading them.
+ *
+ * The block is always valid JSON under the char bound: field texts shrink
+ * through a cap ladder before any fact is dropped, and the last-resort
+ * fallback keeps every requirement id (with `text: "(truncated)"`) while
+ * declaring the degradation, so the planner records targeted evidence gaps
+ * instead of receiving a silently corrupted tail.
  */
 export function renderFrontendPlanInputContext(input) {
     const committedFacts = (records) => records.flatMap((record) => record.phase === "committed" && planInputRecord(record.fact)
@@ -277,45 +291,109 @@ export function renderFrontendPlanInputContext(input) {
     const targetSurface = scoutFacts
         .filter((fact) => fact.kind === "target-surface" && fact.origin === "scout")
         .map((fact) => ({
-        completeness: planInputText(fact.completeness, 32),
-        entrypoint: planInputText(fact.entrypoint, 240),
-        routeOrMount: planInputText(fact.routeOrMount, 240),
-        implementationPaths: planInputStrings(fact.implementationPaths),
-        testPaths: planInputStrings(fact.testPaths),
-        dataSource: planInputText(fact.dataSource),
-        allowedPathConflicts: planInputStrings(fact.allowedPathConflicts),
-        unresolvedPaths: planInputStrings(fact.unresolvedPaths),
+        completeness: fact.completeness,
+        entrypoint: fact.entrypoint,
+        routeOrMount: fact.routeOrMount,
+        implementationPaths: fact.implementationPaths,
+        testPaths: fact.testPaths,
+        dataSource: fact.dataSource,
+        allowedPathConflicts: fact.allowedPathConflicts,
+        unresolvedPaths: fact.unresolvedPaths,
     }));
     const designEvidence = scoutFacts
         .filter((fact) => fact.kind === "design-evidence" && fact.origin === "scout")
         .map((fact) => ({
-        source: planInputText(fact.source),
-        paths: planInputStrings(fact.paths),
-        conflicts: planInputStrings(fact.conflicts),
+        source: fact.source,
+        paths: fact.paths,
+        conflicts: fact.conflicts,
     }));
-    const serialized = JSON.stringify({ requirements, targetSurface, designEvidence });
-    const bounded = serialized.length <= 12_000
-        ? serialized
-        : `${serialized.slice(0, 11_999)}…`;
+    const serializeAtCap = (cap) => JSON.stringify({
+        requirements: requirements.map((requirement) => ({
+            id: requirement.id,
+            text: planInputText(requirement.text, cap.text),
+            sourceFragmentIds: planInputStrings(requirement.sourceFragmentIds).slice(0, cap.array),
+        })),
+        targetSurface: targetSurface.map((surface) => ({
+            completeness: planInputText(surface.completeness, 32),
+            entrypoint: planInputText(surface.entrypoint, cap.text),
+            routeOrMount: planInputText(surface.routeOrMount, cap.text),
+            implementationPaths: planInputStrings(surface.implementationPaths).slice(0, cap.array),
+            testPaths: planInputStrings(surface.testPaths).slice(0, cap.array),
+            dataSource: planInputText(surface.dataSource, cap.text),
+            allowedPathConflicts: planInputStrings(surface.allowedPathConflicts).slice(0, cap.array),
+            unresolvedPaths: planInputStrings(surface.unresolvedPaths).slice(0, cap.array),
+        })),
+        designEvidence: designEvidence.map((evidence) => ({
+            source: planInputText(evidence.source, cap.text),
+            paths: planInputStrings(evidence.paths).slice(0, cap.array),
+            conflicts: planInputStrings(evidence.conflicts).slice(0, cap.array),
+        })),
+    });
+    let serialized = serializeAtCap(FRONTEND_PLAN_INPUT_CAP_LADDER[0]);
+    for (const cap of FRONTEND_PLAN_INPUT_CAP_LADDER.slice(1)) {
+        if (serialized.length <= FRONTEND_PLAN_INPUT_MAX_CHARS)
+            break;
+        serialized = serializeAtCap(cap);
+    }
+    if (serialized.length > FRONTEND_PLAN_INPUT_MAX_CHARS) {
+        // Last resort: keep every requirement id (ids are short and the plan
+        // prompt separately lists them) but drop their texts, shrink scout facts
+        // to the minimum, and declare the degradation instead of corrupting JSON.
+        let fallback = {
+            degraded: "requirement-texts-truncated",
+            requirements: requirements.map((requirement) => ({
+                id: requirement.id,
+                text: "(truncated)",
+            })),
+            targetSurface: targetSurface.map((surface) => ({
+                completeness: planInputText(surface.completeness, 32),
+                implementationPaths: planInputStrings(surface.implementationPaths).slice(0, FRONTEND_PLAN_INPUT_CAP_LADDER[3].array),
+            })),
+            designEvidence: [],
+        };
+        let bounded = JSON.stringify(fallback);
+        let keep = fallback.requirements.length;
+        while (bounded.length > FRONTEND_PLAN_INPUT_MAX_CHARS &&
+            keep > 0) {
+            keep = Math.max(0, Math.floor(keep / 2));
+            fallback = { ...fallback, requirements: fallback.requirements.slice(0, keep) };
+            bounded = JSON.stringify({
+                ...fallback,
+                requirementIdsTruncated: keep < requirements.length,
+            });
+        }
+        serialized = bounded;
+    }
     return [
         "<frontend_plan_input>",
         "Committed Contract/Scout facts, compiled by the runner. Treat them as the complete planning evidence.",
-        bounded,
+        serialized,
         "Do not read upstream artifacts, task sources, or repository files. If this input cannot support a decision, record a genuine evidence gap.",
         "</frontend_plan_input>",
     ].join("\n");
 }
-async function buildFrontendPlanInputContext(runDir) {
+export async function buildFrontendPlanInputContext(runDir) {
+    const contractFactsPath = path.join(runDir, "frontend-contract-pi", "contract-typed-facts.jsonl");
+    const scoutFactsPath = path.join(runDir, "frontend-scout-pi", "scout-typed-facts.jsonl");
+    let contractRecords;
+    let scoutRecords;
     try {
-        const [contractRecords, scoutRecords] = await Promise.all([
-            readTypedEventStoreFromJsonl(path.join(runDir, "frontend-contract-pi", "contract-typed-facts.jsonl")),
-            readTypedEventStoreFromJsonl(path.join(runDir, "frontend-scout-pi", "scout-typed-facts.jsonl")),
+        [contractRecords, scoutRecords] = await Promise.all([
+            readTypedEventStoreFromJsonl(contractFactsPath),
+            readTypedEventStoreFromJsonl(scoutFactsPath),
         ]);
-        return renderFrontendPlanInputContext({ contractRecords, scoutRecords });
     }
-    catch {
-        return "";
+    catch (error) {
+        // A missing/unreadable upstream store is a broken pipeline, not an
+        // evidence gap; fail before spending a model turn on a prompt that
+        // forbids reading anything.
+        throw new Error(`frontend-plan-input-unavailable: cannot read committed typed facts (${error instanceof Error ? error.message : String(error)})`);
     }
+    const committedCount = [...contractRecords, ...scoutRecords].filter((record) => record.phase === "committed").length;
+    if (committedCount === 0) {
+        throw new Error(`frontend-plan-input-unavailable: no committed Contract/Scout facts in ${contractFactsPath} / ${scoutFactsPath}`);
+    }
+    return renderFrontendPlanInputContext({ contractRecords, scoutRecords });
 }
 export function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics, frontendPlanRetryStep) {
     if (attemptNumber <= 1)
@@ -1018,9 +1096,15 @@ export async function executeDagNode(input) {
         return;
     }
     if (isFrontendPlanLadderTask(task)) {
-        const planInputContext = await buildFrontendPlanInputContext(runDir);
-        if (planInputContext)
-            prompt = `${prompt}\n\n${planInputContext}`;
+        let planInputContext;
+        try {
+            planInputContext = await buildFrontendPlanInputContext(runDir);
+        }
+        catch (error) {
+            await failBeforePrompt(error, "frontend-plan-input-unavailable");
+            return;
+        }
+        prompt = `${prompt}\n\n${planInputContext}`;
     }
     node.resolvedSkills = resolvedSkills;
     await writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills);

package/docs/templates/README.md

@@ -38,6 +38,7 @@
 
 - `frontend-task-requirement.md`、`frontend-task-constraints.md`、`frontend-design-contract.md` — 前端任务输入与设计合同。
 - `frontend-implementation-contract.schema.json` — 前端实现合同 schema（sourceBinding v2 ledger 字段 all-or-none：任一出现则四项齐全，禁止 v1+optional 冒充 v2）。`requirements[].sourceRefs[].items` 使用合法 `$ref: #/$defs/path`（相对路径、无 `..` 逃逸、无反斜杠），模板 JSON 无非法键，运行时加载器可直接编译（AC-003）。
+- `frontend-implementation-dag.json` — 自包含的前端实现 DAG 模板：契约 → 侦察 → 计划 → 设计策略/评审 → writer 准入 → 有界写入 → 验证 → 真实 diff 审查 → closeout。它不依赖 runtime builder 或其他模板；执行前必须将所有 `REPLACE/WITH/...` 路径和确定性命令替换为当前项目的具体值。
 - `frontend-test-dag.json` — frontend-test DAG 模板；其 deterministic checklist 会拒绝 alternative executable instructions，仅允许 allowlisted `playwright-cli` command。Pi generator/reviser 的 runtime writeSet 仅授权下列目标项目生成路径（不是本仓库文档索引目标）：
 
   ~~~text

package/docs/templates/frontend-implementation-dag.json

@@ -0,0 +1,89 @@
+{
+  "$schema": "./agent-dag.schema.json",
+  "version": 2,
+  "title": "Frontend implementation independent DAG template",
+  "objective": "Replace with the concrete, bounded frontend implementation objective for this DAG run.",
+  "successCriteria": [
+    "The contract covers every required user-visible behavior, state, and interaction.",
+    "The implementation is admitted only after a concrete, narrow writeSet is reviewed.",
+    "Static and behavior verification are recorded before final review.",
+    "The final closeout distinguishes passed, not-run, and residual-risk evidence."
+  ],
+  "globalConstraints": [
+    "This is a self-contained static template: do not generate, import, or merge a DAG from a runtime builder before execution.",
+    "Replace every REPLACE/WITH/... placeholder with concrete repository paths or deterministic commands before execution.",
+    "Do not commit runtime traces under .harness/dag-runs/.",
+    "Every node must explicitly declare its executor; defaults.executor is schema-only and not a runtime fallback.",
+    "Only frontend-implement-pi may write project files, and only inside its concrete writeSet.",
+    "Read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.",
+    "Do not infer missing behavior, states, interactions, design decisions, or verification commands. Stop for an explicit task-contract revision instead.",
+    "Do not add dependencies unless they are already declared by the project contract."
+  ],
+  "defaults": {"executor":"pi","contextProfile":"slim","skills":["ai-engineering-context"],"writePolicy":"read-only"},
+  "skillsByRole": {
+    "planner":["loop-agent"], "scout":["ai-engineering-context"], "implementer":["verification-before-completion"], "reviewer":["requesting-code-review"], "verifier":["verification-before-completion","systematic-debugging"], "closeout":["loop-agent","verification-before-completion"]
+  },
+  "executorModels": {"pi":{"LOW":"gpt-5.3-codex-spark","MED":"gpt-5.5","HIGH":"gpt-5.5"}},
+  "tasks": [
+    {
+      "id":"frontend-contract-pi", "depends_on":[], "complexity":"MED", "executor":"pi", "role":"planner", "writePolicy":"read-only", "allowedPaths":["**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Plain Markdown frontend contract: required behavior, states, interactions, non-goals, concrete verification expectations, and unresolved gaps; no file writes.",
+      "subtask_prompt":"Read the task inputs. Produce a concise frontend contract that maps each required behavior, UI state, and interaction to observable outcomes. Identify missing or conflicting requirements as blockers; do not infer them and do not edit files."
+    },
+    {
+      "id":"frontend-scout-pi", "depends_on":["frontend-contract-pi"], "complexity":"LOW", "executor":"pi", "role":"scout", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Plain Markdown source and verification reconnaissance: relevant routes, components, styles, state patterns, focused tests, and risks; no file writes.",
+      "subtask_prompt":"Inspect only the declared frontend source and test paths. Report reusable component, styling, accessibility, state-management, and verification patterns that satisfy the contract. Do not edit files or broaden the allowed paths."
+    },
+    {
+      "id":"frontend-plan-pi", "depends_on":["frontend-scout-pi"], "complexity":"MED", "executor":"pi", "role":"planner", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Plain Markdown implementation plan: ordered changes, concrete target files, behavior/state/interaction coverage, and focused verification mapping; no file writes.",
+      "subtask_prompt":"Turn the contract and reconnaissance into a minimal implementation plan. Every target file and verification step must be concrete. Preserve existing design and accessibility conventions. If any behavior lacks a verifiable target, report it as blocked instead of guessing."
+    },
+    {
+      "id":"frontend-design-policy-shell", "depends_on":["frontend-plan-pi"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Archived deterministic design-policy result proving the plan uses declared dependencies, concrete requirements, and approved design evidence; no worktree writes.",
+      "subtask_prompt":"Run the project-specific deterministic design-policy check selected for this task. It must reject missing requirement coverage, unauthorized dependencies, and unresolved design conflicts.",
+      "shell":{"commands":["REPLACE/WITH/DESIGN-POLICY/COMMAND"],"cwd":".","timeoutMs":300000}
+    },
+    {
+      "id":"frontend-design-review-pi", "depends_on":["frontend-design-policy-shell"], "complexity":"MED", "executor":"pi", "role":"reviewer", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Plain Markdown design review: approved plan or explicit blocking findings for behavior, state, interaction, design-system, and accessibility coverage; no file writes.",
+      "subtask_prompt":"Review the approved plan against the frontend contract and design-policy result. Reject missing visible states, interaction behavior, accessibility obligations, or unsupported design claims. Do not edit files."
+    },
+    {
+      "id":"frontend-writer-admission-shell", "depends_on":["frontend-design-review-pi"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Archived deterministic writer-admission result with a concrete, narrow writeSet and pre-write baseline; no worktree writes.",
+      "subtask_prompt":"Run the project-specific writer-admission check. It must derive and record a concrete writeSet from the approved plan, reject broad paths and scope drift, and capture the pre-write baseline before authorizing the writer.",
+      "shell":{"commands":["REPLACE/WITH/WRITER-ADMISSION/COMMAND"],"cwd":".","timeoutMs":300000}
+    },
+    {
+      "id":"frontend-implement-pi", "depends_on":["frontend-writer-admission-shell"], "complexity":"HIGH", "executor":"pi", "role":"implementer", "toolProfile":"write", "writePolicy":"exclusive", "writeSet":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Implementation summary with changed files, contract coverage, focused checks run, and residual risks.",
+      "subtask_prompt":"Implement only the admitted frontend changes. Preserve established component, styling, accessibility, and state-management conventions. Cover every approved behavior, state, and interaction, then report changed files and focused verification. Do not broaden writeSet or add undeclared dependencies."
+    },
+    {
+      "id":"frontend-verify-shell", "depends_on":["frontend-implement-pi"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Archived static and behavior verification output with command exit codes; no worktree writes.",
+      "subtask_prompt":"Run the contract-selected deterministic static and behavior verification commands. Record all exit codes. A failed required command is terminal for this DAG run; do not silently substitute a different command.",
+      "shell":{"preset":"loop-agent-standard-verify","cwd":".","timeoutMs":300000}
+    },
+    {
+      "id":"frontend-review-context-shell", "depends_on":["frontend-verify-shell"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Archived deterministic final-review context: admitted writeSet, cumulative diff, and required verification evidence; no worktree writes.",
+      "subtask_prompt":"Run the project-specific review-context collector. It must bind the admitted writeSet, actual cumulative diff, and required verification results so final review cannot rely on summaries alone.",
+      "shell":{"commands":["REPLACE/WITH/REVIEW-CONTEXT/COMMAND"],"cwd":".","timeoutMs":300000}
+    },
+    {
+      "id":"frontend-review-pi", "depends_on":["frontend-review-context-shell"], "complexity":"MED", "executor":"pi", "role":"reviewer", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Plain Markdown final review: approved result or explicit findings for contract coverage, regression risk, accessibility, and verification gaps; no file writes.",
+      "subtask_prompt":"Review the actual diff and archived verification evidence against the frontend contract. Do not treat missing, weak, mock-only, or not-run evidence as passed. Report explicit residual risks; do not edit files."
+    },
+    {
+      "id":"frontend-closeout-shell", "depends_on":["frontend-review-pi"], "complexity":"LOW", "executor":"shell", "role":"closeout", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
+      "outputContract":"Archived deterministic closeout summarizing contract coverage, verification status, review findings, evidence gaps, and residual risks; no worktree writes.",
+      "subtask_prompt":"Run the project-specific deterministic closeout renderer. Preserve evidence status exactly: passed, failed, not-run, mock-backed, and baseline debt must never be promoted to a stronger result.",
+      "shell":{"commands":["REPLACE/WITH/CLOSEOUT/COMMAND"],"cwd":".","timeoutMs":300000}
+    }
+  ]
+}

package/package.json

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

package/skills/loop-agent/references/hybrid-dag.md

@@ -91,7 +91,7 @@ loop-agent dag execute --dag <temp-dir>/hybrid-dag.json --init-only --canvas-pat
 - **Source binding / recovery**：新生成 DAG 在顶层冻结 `sourceBinding`（任务源相对路径、SHA-256、显式 `REQ/BR/AC`）。前端计划在存在显式编号时经过 `frontend-requirement-coverage-shell`；修订计划为 primary，只在条件分支未产生输出时 fallback 到原计划。主来源存在但缺号时仍在 writer 前 fail closed。中断后重新生成完整 DAG，不要从二手摘要拼接 impl-only DAG；v3 孤立 exclusive writer 若无 `sourceBinding` 且没有只读 planner 上游，会被 strict governance 拒绝。
 - **勿宣称 live smoke 已通过**，除非真实 `dag execute` execution 中 Pi read-only、Pi writer、显式 Cursor 或 shell node 均按 DAG 完成。
 
-可复用 template：`docs/templates/agent-dag.base.json`（model 生成 DAG 的首选 base template）、`docs/templates/agent-dag.schema.json`（JSON Schema）、`docs/templates/agent-dag.supervised-implementation.json`（supervised implementation：writeSet audit、soft/hard verify、process supervisor、repair、review verdict gate）、`docs/templates/backend-test-dag.json`（后端测试专用模板）、`docs/templates/frontend-test-dag.json`（FE-test RAG：Markdown case manifest、串行 Playwright CLI case 子节点与逐 case 证据）、`docs/templates/agent-dag-process-supervisor.prompt.md`、`docs/templates/agent-dag-review-verdict.prompt.md`、`docs/templates/agent-dag-authority-surface-audit.prompt.md`（可选 authority surface verifier；authority signal 或显式 enablement 匹配时由 `dag init-hybrid` 插入）、`examples/hybrid-loop-agent-dag.json`、`docs/templates/hybrid-dag.json`。
+可复用 template：`docs/templates/agent-dag.base.json`（model 生成 DAG 的首选 base template）、`docs/templates/agent-dag.schema.json`（JSON Schema）、`docs/templates/agent-dag.supervised-implementation.json`（supervised implementation：writeSet audit、soft/hard verify、process supervisor、repair、review verdict gate）、`docs/templates/frontend-implementation-dag.json`（自包含的前端实现完整默认链：contract、scout、plan、design policy/review、writer admission、implement、verify、review context/review、closeout；不依赖 runtime builder 或其他模板，执行前替换全部 `REPLACE/WITH/...` 值）、`docs/templates/backend-test-dag.json`（后端测试专用模板）、`docs/templates/frontend-test-dag.json`（FE-test RAG：Markdown case manifest、串行 Playwright CLI case 子节点与逐 case 证据）、`docs/templates/agent-dag-process-supervisor.prompt.md`、`docs/templates/agent-dag-review-verdict.prompt.md`、`docs/templates/agent-dag-authority-surface-audit.prompt.md`（可选 authority surface verifier；authority signal 或显式 enablement 匹配时由 `dag init-hybrid` 插入）、`examples/hybrid-loop-agent-dag.json`、`docs/templates/hybrid-dag.json`。
 
 ### Supervised implementation flow（减少 operator 中途介入）