@tea-agent/loop-agent 0.7.3 → 0.7.5

package/CHANGELOG.md

@@ -4,6 +4,20 @@
 
 ## [Unreleased]
 
+## [0.7.5] - 2026-07-11
+
+### 新增
+
+- Observe DAG Detail 新增离线 SVG 依赖图：read-model 从 canonical `run.json` 投影稳定 edges，支持并行/汇合/失败/跳过状态、键盘节点选择、上下游高亮、滚动与重置视图，并保留节点表格和过程时间线降级路径。
+- 新增 repository-owned Worker nightly wrapper 与 GitHub Actions 手动/定时适配面：按 feature 互斥、保留超时/批次退出码，并收集 controller、morning report、Observe snapshot 等 artifacts。
+- 新增 `agent-worker task validate-feature` 和可初始化投影的语言无关产品线模板，校验 AC 唯一性、任务依赖、TaskSpec 路径/验证命令及 QA verdict → success closeout 顺序，并接入仓库治理门禁。
+
+## [0.7.4] - 2026-07-11
+
+### 修复
+
+- Worker materialize 现在把 TaskSpec 中所有 required `verify.commands` 写入 task config，并强制合并到 DAG 最终 shell verification；review 不再只能看到仓库级治理命令而缺少任务契约要求的 typecheck/focused tests。
+
 ## [0.7.3] - 2026-07-11
 
 ### 修复

package/README.md

@@ -88,6 +88,15 @@ loop-agent pi-prompt --cwd . --tools read,grep,find,ls "只读评审这个任务
 loop-agent pi-prompt --cwd . --tools read,bash,edit,write,grep,find,ls "<包含 allowedPaths 和 forbiddenPaths 的有边界任务说明>"
 ```
 
+产品线 feature packet 可用伴生 Worker CLI 做 docs CI；仓库也提供外部 CI/cron wrapper，调度仍由外部系统负责：
+
+```bash
+agent-worker task validate-feature <feature-dir>
+bash scripts/worker-nightly.sh <feature-dir> <target-repo> <batch-run-id>
+```
+
+nightly wrapper 按 feature 互斥，保留批次/超时退出码，并输出 morning report、Observe snapshot 和 controller 版本 artifacts。
+
 ## 核心概念
 
 - **Agent DAG**：把一次任务拆成 contract、scout、plan、implement、verify、closeout 等可审查节点。

package/dist/commands/init.js

@@ -418,6 +418,7 @@ checks=(
   "scripts/check-harness-runtime-clean.sh"
   "scripts/check-architecture-boundaries.sh"
   "scripts/check-skill-entry.sh"
+  "scripts/check-product-line-docs.sh"
 )
 
 for check in "\${checks[@]}"; do
@@ -428,6 +429,32 @@ done
 
 echo "仓库治理检查全部通过"
 `;
+const INIT_CHECK_PRODUCT_LINE_DOCS_SH = `#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")/.." && pwd)"
+cd "\${ROOT_DIR}"
+
+if ! command -v agent-worker >/dev/null 2>&1; then
+  echo "product-line docs check skipped: agent-worker is not installed"
+  exit 0
+fi
+
+feature_dirs=()
+for root in features product/features dogfood/features; do
+  [[ -d "\${root}" ]] || continue
+  while IFS= read -r acceptance; do
+    feature_dirs+=("$(dirname "\${acceptance}")")
+  done < <(find "\${root}" -mindepth 2 -maxdepth 2 -name acceptance.yaml -type f | sort)
+done
+
+for feature_dir in "\${feature_dirs[@]}"; do
+  echo "==> validate product-line feature: \${feature_dir}"
+  agent-worker task validate-feature "\${feature_dir}"
+done
+
+echo "product-line docs checks passed: \${#feature_dirs[@]} feature packet(s)"
+`;
 const INIT_CI_GOVERNANCE_SH = `#!/usr/bin/env bash
 set -euo pipefail
 
@@ -570,6 +597,7 @@ const INIT_SCRIPT_FILES = {
     "scripts/check-harness-runtime-clean.sh": INIT_CHECK_HARNESS_RUNTIME_CLEAN_SH,
     "scripts/check-architecture-boundaries.sh": INIT_CHECK_ARCHITECTURE_BOUNDARIES_SH,
     "scripts/check-skill-entry.sh": INIT_CHECK_SKILL_ENTRY_SH,
+    "scripts/check-product-line-docs.sh": INIT_CHECK_PRODUCT_LINE_DOCS_SH,
     "scripts/check-repo.sh": INIT_CHECK_REPO_SH,
     "scripts/ci-governance.sh": INIT_CI_GOVERNANCE_SH,
     "scripts/ci-tests.sh": INIT_CI_TESTS_SH,

package/dist/task/config-types.js

@@ -25,6 +25,11 @@ export const piSubagentModeSchema = z.enum(["off", "analyze-plan", "full"]);
 export const verifyModeSchema = z.enum(["parallel", "serial"]);
 export const verifyPresetSchema = z.enum(["auto", "quick", "standard", "full"]);
 export const verifyQuotaSchema = z.enum(["1", "3", "full"]);
+export const taskVerifyCommandSchema = z.object({
+    label: z.string().min(1),
+    command: z.string().min(1),
+    timeoutMs: z.number().int().positive().optional(),
+});
 export const dagVerifyStrategySchema = z
     .object({
     intermediateQuota: verifyQuotaSchema.optional(),
@@ -73,6 +78,8 @@ export const taskConfigSchema = z.object({
     capabilities: z.array(taskCapabilitySchema).optional(),
     verifyMode: verifyModeSchema.optional().default("parallel"),
     verifyPreset: verifyPresetSchema.optional().default("auto"),
+    /** Task-contract commands that must be included in final DAG shell verification. */
+    verifyCommands: z.array(taskVerifyCommandSchema).optional().default([]),
     /** Verification selection policy. Intermediate loops may use quota; final gates still run full required verification. */
     verifyQuota: verifyQuotaSchema.optional().default("full"),
     /** DAG supervised verify strategy. Final quota is fixed to full; intermediate quota may reduce cost. */

package/dist/task/runtime.js

@@ -104,6 +104,7 @@ export async function createTask(repoRoot, taskId, title) {
         contextProfile: 'full',
         verifyMode: 'parallel',
         verifyPreset: 'auto',
+        verifyCommands: [],
         verifyQuota: 'full',
         verifyRetryCount: 0,
         verifyFailFast: false,

package/dist/worker/cli.js

@@ -16,6 +16,7 @@ import { createObserveServer } from "./observe/server.js";
 import { prepareTaskPoolRetry } from "./pool/run-store.js";
 import { taskSpecSchema } from "./task-spec/schema.js";
 import { validateTaskSpec } from "./task-spec/validate.js";
+import { validateFeatureTaskGraph } from "./task-graph/validate.js";
 export function buildAgentWorkerProgram() {
     const program = new Command();
     program
@@ -49,6 +50,16 @@ export function buildAgentWorkerProgram() {
         const result = resolveLoopAgentProfile(parsed);
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
     });
+    task
+        .command("validate-feature")
+        .argument("<feature-dir>", "Feature directory containing acceptance.yaml and tasks/")
+        .description("Validate acceptance ids, task graph, TaskSpecs, paths, and verification commands")
+        .action(async (featureDir) => {
+        const result = await validateFeatureTaskGraph(path.resolve(featureDir));
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        if (!result.ok)
+            process.exitCode = 1;
+    });
     task
         .command("retry")
         .argument("<task-id>", "Failed Task Pool task to requeue")

package/dist/worker/materialize/harness-task-materializer.js

@@ -44,6 +44,13 @@ export async function materializeTaskSpec(options) {
         verifyMode: options.taskSpec.verify.mode,
         verifyPreset: options.taskSpec.verify.preset,
         verifyQuota: options.taskSpec.verify.quota,
+        verifyCommands: options.taskSpec.verify.commands
+            .filter((command) => command.required)
+            .map((command) => ({
+            label: command.label,
+            command: command.command,
+            timeoutMs: command.timeout_ms,
+        })),
         autoCommitAfterVerify: false,
     };
     await writeTaskConfig(options.repoRoot, harnessTaskId, taskConfig);

package/dist/worker/observability/read-model.js

@@ -645,7 +645,7 @@ async function loadDagRuns(repoRoot) {
     const byId = new Map();
     const statePaths = await findStateJsonFiles(path.join(repoRoot, ".harness", "dag-runs"));
     for (const statePath of statePaths) {
-        const summary = parseDagStateFile(statePath);
+        const summary = await parseDagStateFile(statePath);
         if (summary)
             byId.set(summary.dagRunId, mergeDagRun(byId.get(summary.dagRunId), summary));
     }
@@ -674,6 +674,7 @@ function mergeDagRun(existing, incoming) {
         ...(durationMs !== undefined ? { durationMs } : {}),
         ...(ranks && ranks.length > 0 ? { ranks } : {}),
         nodes: mergeDagNodes(existing.nodes, incoming.nodes),
+        edges: incoming.edges.length > 0 ? incoming.edges : existing.edges,
         ...(incoming.dagPath ?? existing.dagPath ? { dagPath: incoming.dagPath ?? existing.dagPath } : {}),
     };
 }
@@ -819,6 +820,7 @@ async function loadDagEventFiles(repoRoot) {
             ...(finishedAt ? { finishedAt } : {}),
             ...(durationMs !== undefined ? { durationMs } : {}),
             nodes: [...nodeMap.values()].sort((a, b) => a.nodeId.localeCompare(b.nodeId)),
+            edges: [],
         });
     }
     return result;
@@ -845,7 +847,7 @@ async function walkForStateJson(dir, results) {
         // skip
     }
 }
-function parseDagStateFile(statePath) {
+async function parseDagStateFile(statePath) {
     try {
         if (!existsSync(statePath))
             return undefined;
@@ -863,6 +865,7 @@ function parseDagStateFile(statePath) {
         const ranks = readStringMatrix(parsed, "ranks");
         const rankByNode = buildRankIndex(ranks);
         const nodes = parseDagNodes(parsed, rankByNode);
+        const edges = await parseDagEdges(path.join(runDir, "run.json"), nodes);
         return {
             dagRunId,
             status,
@@ -872,6 +875,7 @@ function parseDagStateFile(statePath) {
             ...(durationMs !== undefined ? { durationMs } : {}),
             ...(ranks.length > 0 ? { ranks } : {}),
             nodes,
+            edges,
             dagPath: runDir,
         };
     }
@@ -879,6 +883,30 @@ function parseDagStateFile(statePath) {
         return undefined;
     }
 }
+async function parseDagEdges(runPath, nodes) {
+    const parsed = await safeReadJson(runPath);
+    if (!parsed)
+        return [];
+    const tasks = readObjectArray(parsed, "tasks");
+    if (tasks.length === 0)
+        return [];
+    const knownNodeIds = new Set(nodes.map((node) => node.nodeId));
+    const edges = new Map();
+    for (const task of tasks) {
+        const taskId = readString(task, "id") ?? readString(task, "nodeId");
+        if (!taskId || !knownNodeIds.has(taskId))
+            continue;
+        const dependencies = readStringArray(task, "depends_on");
+        const compatibleDependencies = dependencies.length > 0 ? dependencies : readStringArray(task, "dependsOn");
+        for (const dependencyId of compatibleDependencies) {
+            if (dependencyId === taskId || !knownNodeIds.has(dependencyId))
+                continue;
+            const edge = { from: dependencyId, to: taskId };
+            edges.set(`${edge.from}\u0000${edge.to}`, edge);
+        }
+    }
+    return [...edges.values()].sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+}
 function buildRankIndex(ranks) {
     const index = new Map();
     for (let i = 0; i < ranks.length; i++) {
@@ -995,6 +1023,14 @@ function readString(value, key) {
     const child = value[key];
     return typeof child === "string" ? child : undefined;
 }
+function readStringArray(value, key) {
+    if (!value || typeof value !== "object")
+        return [];
+    const child = value[key];
+    if (!Array.isArray(child))
+        return [];
+    return child.filter((item) => typeof item === "string");
+}
 function readNumber(value, key) {
     if (!value || typeof value !== "object")
         return undefined;

package/dist/worker/observe/static/app.js

@@ -1,3 +1,5 @@
+import { layoutDag } from "./dag-layout.js";
+
 const POLL_MS = 2000;
 const DASHBOARD_POLL_MS = 5000;
 
@@ -194,6 +196,16 @@ function statusLabel(status) {
 	return status;
 }
 
+function statusSymbol(status) {
+	const key = (status ?? "unknown").toLowerCase();
+	if (["finished", "completed", "succeeded", "done"].includes(key)) return "✓";
+	if (["failed", "error"].includes(key)) return "✕";
+	if (key === "skipped") return "↷";
+	if (["running", "started"].includes(key)) return "●";
+	if (["pending", "queued", "blocked"].includes(key)) return "○";
+	return "◇";
+}
+
 function badgeClass(status) {
 	if (!status) return "unknown";
 	const key = status.toLowerCase().replace(/_/g, "-");
@@ -704,6 +716,55 @@ function renderRankLanes(dag) {
 	return container;
 }
 
+function svgEl(tag, attrs = {}) {
+	const node = document.createElementNS("http://www.w3.org/2000/svg", tag);
+	for (const [key, value] of Object.entries(attrs)) node.setAttribute(key, String(value));
+	return node;
+}
+
+function renderDagGraph(dag, dagRunId) {
+	const nodes = dag.nodes ?? [];
+	const edges = dag.edges ?? [];
+	const layout = layoutDag(nodes, edges, dag.ranks ?? []);
+	const wrap = el("div", "dag-graph-wrap");
+	const toolbar = el("div", "dag-graph-toolbar");
+	toolbar.appendChild(el("span", "dag-graph-summary", `${nodes.length} 节点 · ${layout.edges.length} 条依赖`));
+	const reset = el("button", "dag-graph-reset", "重置视图");
+	toolbar.appendChild(reset);
+	wrap.appendChild(toolbar);
+	if (edges.length === 0) wrap.appendChild(el("p", "dag-graph-fallback", "该运行没有可用依赖数据；图按 Rank 展示，节点表格仍保留完整数据。"));
+	const viewport = el("div", "dag-graph-viewport");
+	const svg = svgEl("svg", { class: "dag-graph", viewBox: `0 0 ${layout.width} ${layout.height}`, width: layout.width, height: layout.height, role: "img", "aria-label": `DAG 依赖图，共 ${nodes.length} 个节点` });
+	const defs = svgEl("defs");
+	const marker = svgEl("marker", { id: "dag-arrow", viewBox: "0 0 10 10", refX: 9, refY: 5, markerWidth: 7, markerHeight: 7, orient: "auto-start-reverse" });
+	marker.appendChild(svgEl("path", { d: "M 0 0 L 10 5 L 0 10 z" }));
+	defs.appendChild(marker); svg.appendChild(defs);
+	const related = new Set([selectedDagNodeId]);
+	for (const edge of layout.edges) if (edge.from === selectedDagNodeId || edge.to === selectedDagNodeId) { related.add(edge.from); related.add(edge.to); }
+	for (const edge of layout.edges) {
+		const path = svgEl("path", { d: edge.path, class: `dag-edge${selectedDagNodeId && (!related.has(edge.from) || !related.has(edge.to)) ? " dag-dimmed" : ""}`, "marker-end": "url(#dag-arrow)" });
+		path.appendChild(svgEl("title")); path.firstChild.textContent = `${edge.from} → ${edge.to}`; svg.appendChild(path);
+	}
+	const byId = Object.fromEntries(nodes.map((node) => [node.nodeId, node]));
+	for (const position of layout.nodes) {
+		const node = byId[position.nodeId] ?? { nodeId: position.nodeId };
+		const status = (node.status ?? "unknown").toLowerCase();
+		const group = svgEl("g", { transform: `translate(${position.x} ${position.y})`, class: `dag-graph-node status-${status}${node.nodeId === selectedDagNodeId ? " selected" : ""}${selectedDagNodeId && !related.has(node.nodeId) ? " dag-dimmed" : ""}`, tabindex: 0, role: "button", "aria-label": `${node.nodeId}，状态 ${status}` });
+		group.appendChild(svgEl("rect", { width: position.width, height: position.height, rx: 10 }));
+		const title = svgEl("title"); title.textContent = `${node.nodeId}\n${node.executor ?? "未知执行器"}\n${status}`; group.appendChild(title);
+		const label = svgEl("text", { x: 14, y: 26, class: "dag-node-label" }); label.textContent = truncateText(node.label ?? node.nodeId, 26); group.appendChild(label);
+		const executor = svgEl("text", { x: 14, y: 50, class: "dag-node-meta" }); executor.textContent = `◈ ${node.executor ?? "unknown"}`; group.appendChild(executor);
+		const state = svgEl("text", { x: 14, y: 74, class: "dag-node-status" }); state.textContent = `${statusSymbol(status)} ${statusLabel(node.status)} · ${formatMs(node.durationMs)}`; group.appendChild(state);
+		const activate = () => selectDagNode(dagRunId, node.nodeId);
+		group.addEventListener("click", activate);
+		group.addEventListener("keydown", (event) => { if (event.key === "Enter" || event.key === " ") { event.preventDefault(); activate(); } });
+		svg.appendChild(group);
+	}
+	viewport.appendChild(svg); wrap.appendChild(viewport);
+	reset.addEventListener("click", () => { viewport.scrollTo({ left: 0, top: 0, behavior: "smooth" }); });
+	return wrap;
+}
+
 function expandablePreview(title, content, previewClass) {
 	const wrap = el("details", previewClass ?? "output-preview");
 	const summary = el("summary", null, title);
@@ -1307,11 +1368,11 @@ async function renderDagDetail(dagRunId, initial = true) {
 	);
 
 	clearNode(ranksEl);
-	ranksEl.appendChild(el("h3", null, "Rank 泳道"));
+		ranksEl.appendChild(el("h3", null, "DAG 依赖图"));
 	if (nodes.length === 0) {
 		ranksEl.appendChild(el("p", "empty", UI_TEXT.noNodes));
 	} else {
-		ranksEl.appendChild(renderRankLanes(dag));
+			ranksEl.appendChild(renderDagGraph(dag, dagRunId));
 	}
 
 	clearNode(nodesEl);

package/dist/worker/observe/static/dag-layout.d.ts

@@ -0,0 +1,31 @@
+export type DagLayoutNodeInput = { nodeId: string };
+export type DagLayoutEdgeInput = { from: string; to: string };
+export type DagLayoutNode = {
+	nodeId: string;
+	rank: number;
+	index: number;
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+};
+export type DagLayoutEdge = DagLayoutEdgeInput & { path: string };
+export type DagLayout = {
+	width: number;
+	height: number;
+	nodes: DagLayoutNode[];
+	edges: DagLayoutEdge[];
+};
+
+export function layoutDag(
+	nodes?: DagLayoutNodeInput[],
+	edges?: DagLayoutEdgeInput[],
+	ranks?: string[][],
+	options?: Partial<{
+		nodeWidth: number;
+		nodeHeight: number;
+		rankGap: number;
+		nodeGap: number;
+		padding: number;
+	}>,
+): DagLayout;

package/dist/worker/observe/static/dag-layout.js

@@ -0,0 +1,83 @@
+const DEFAULTS = {
+	nodeWidth: 216,
+	nodeHeight: 92,
+	rankGap: 104,
+	nodeGap: 28,
+	padding: 32,
+};
+
+export function layoutDag(nodes = [], edges = [], ranks = [], options = {}) {
+	const config = { ...DEFAULTS, ...options };
+	const nodeIds = [...new Set(nodes.map((node) => node.nodeId).filter(Boolean))].sort();
+	if (nodeIds.length === 0) return { width: 320, height: 160, nodes: [], edges: [] };
+	const known = new Set(nodeIds);
+	const validEdges = edges
+		.filter((edge) => known.has(edge.from) && known.has(edge.to) && edge.from !== edge.to)
+		.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+	const layers = normalizeLayers(nodeIds, validEdges, ranks);
+	const positioned = [];
+	for (let rank = 0; rank < layers.length; rank++) {
+		const ids = layers[rank];
+		for (let index = 0; index < ids.length; index++) {
+			positioned.push({
+				nodeId: ids[index], rank, index,
+				x: config.padding + rank * (config.nodeWidth + config.rankGap),
+				y: config.padding + index * (config.nodeHeight + config.nodeGap),
+				width: config.nodeWidth, height: config.nodeHeight,
+			});
+		}
+	}
+	const byId = new Map(positioned.map((node) => [node.nodeId, node]));
+	const routed = validEdges.map((edge) => {
+		const from = byId.get(edge.from);
+		const to = byId.get(edge.to);
+		const x1 = from.x + from.width;
+		const y1 = from.y + from.height / 2;
+		const x2 = to.x;
+		const y2 = to.y + to.height / 2;
+		const bend = Math.max(36, (x2 - x1) / 2);
+		return { ...edge, path: `M ${x1} ${y1} C ${x1 + bend} ${y1}, ${x2 - bend} ${y2}, ${x2} ${y2}` };
+	});
+	const maxRows = Math.max(...layers.map((layer) => layer.length), 1);
+	return {
+		width: config.padding * 2 + layers.length * config.nodeWidth + (layers.length - 1) * config.rankGap,
+		height: config.padding * 2 + maxRows * config.nodeHeight + (maxRows - 1) * config.nodeGap,
+		nodes: positioned,
+		edges: routed,
+	};
+}
+
+function normalizeLayers(nodeIds, edges, ranks) {
+	const known = new Set(nodeIds);
+	const seen = new Set();
+	const layers = [];
+	if (Array.isArray(ranks)) {
+		for (const rank of ranks) {
+			if (!Array.isArray(rank)) continue;
+			const ids = [...new Set(rank.filter((id) => known.has(id) && !seen.has(id)))].sort();
+			ids.forEach((id) => seen.add(id));
+			if (ids.length > 0) layers.push(ids);
+		}
+	}
+	if (layers.length === 0 && edges.length > 0) {
+		const level = new Map(nodeIds.map((id) => [id, 0]));
+		for (let pass = 0; pass < nodeIds.length; pass++) {
+			let changed = false;
+			for (const edge of edges) {
+				const next = Math.min(nodeIds.length - 1, level.get(edge.from) + 1);
+				if (next > level.get(edge.to)) { level.set(edge.to, next); changed = true; }
+			}
+			if (!changed) break;
+		}
+		for (const id of nodeIds) {
+			const rank = level.get(id);
+			(layers[rank] ??= []).push(id);
+			seen.add(id);
+		}
+		for (const layer of layers) layer?.sort();
+	}
+	for (const id of nodeIds) {
+		if (!seen.has(id)) (layers[0] ??= []).push(id);
+	}
+	return layers.filter(Boolean);
+}

package/dist/worker/observe/static/styles.css

@@ -1,6 +1,7 @@
 :root {
   --bg: #0d1117;
   --surface: #161b22;
+  --surface-raised: #1c2128;
   --border: #30363d;
   --text: #c9d1d9;
   --muted: #8b949e;
@@ -10,6 +11,17 @@
   --yellow: #d29922;
   --blue: #58a6ff;
   --gray-red: #8b3a3a;
+  --space-1: 4px;
+  --space-2: 8px;
+  --space-3: 12px;
+  --space-4: 16px;
+  --space-6: 24px;
+  --space-8: 32px;
+  --radius-sm: 4px;
+  --radius-md: 8px;
+  --radius-lg: 12px;
+  --shadow-1: 0 4px 18px rgba(0, 0, 0, 0.2);
+  --transition-fast: 140ms ease;
 }
 
 * {
@@ -18,13 +30,25 @@
 
 body {
   margin: 0;
-  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+  font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
   font-size: 13px;
   line-height: 1.5;
   background: var(--bg);
   color: var(--text);
 }
 
+code,
+pre,
+.output-block,
+.rank-node-id,
+.dag-node-label,
+.dag-node-meta,
+.dag-node-status,
+td:first-child,
+.meta-item dd {
+  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace;
+}
+
 #app {
   max-width: 1200px;
   margin: 0 auto;
@@ -103,11 +127,96 @@ h3,
 .panel {
   background: var(--surface);
   border: 1px solid var(--border);
-  border-radius: 6px;
+  border-radius: var(--radius-md);
   padding: 0.75rem 1rem;
   margin-bottom: 1rem;
 }
 
+.dag-graph-wrap {
+  display: grid;
+  gap: var(--space-2);
+}
+
+.dag-graph-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--space-3);
+}
+
+.dag-graph-summary,
+.dag-graph-fallback {
+  color: var(--muted);
+  font-size: 12px;
+}
+
+.dag-graph-fallback { margin: 0; }
+
+.dag-graph-reset {
+  appearance: none;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: var(--surface-raised);
+  color: var(--text);
+  padding: 6px 10px;
+  cursor: pointer;
+}
+
+.dag-graph-reset:hover,
+.dag-graph-reset:focus-visible { border-color: var(--link); }
+
+.dag-graph-viewport {
+  min-height: 220px;
+  max-height: 620px;
+  overflow: auto;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  background: radial-gradient(circle at 1px 1px, rgba(139, 148, 158, 0.18) 1px, transparent 0) 0 0 / 20px 20px, var(--bg);
+  scroll-behavior: smooth;
+}
+
+.dag-graph { display: block; }
+.dag-edge { fill: none; stroke: var(--muted); stroke-width: 2; opacity: 0.75; transition: opacity var(--transition-fast); }
+.dag-edge + .dag-edge { stroke-width: 1.8; }
+#dag-arrow path { fill: var(--muted); }
+.dag-graph-node { cursor: pointer; transition: opacity var(--transition-fast); }
+.dag-graph-node rect { fill: var(--surface-raised); stroke: var(--border); stroke-width: 1.5; }
+.dag-graph-node:hover rect,
+.dag-graph-node:focus-visible rect { stroke: var(--link); stroke-width: 2.5; }
+.dag-graph-node:focus { outline: none; }
+.dag-graph-node.selected rect { stroke: var(--link); stroke-width: 3; filter: drop-shadow(0 0 6px rgba(88, 166, 255, 0.45)); }
+.dag-graph-node.status-running rect,
+.dag-graph-node.status-started rect { stroke: var(--yellow); }
+.dag-graph-node.status-failed rect,
+.dag-graph-node.status-error rect { stroke: var(--red); fill: rgba(248, 81, 73, 0.1); }
+.dag-graph-node.status-skipped rect { stroke-dasharray: 5 4; }
+.dag-node-label { fill: var(--text); font-size: 13px; font-weight: 700; }
+.dag-node-meta { fill: var(--muted); font-size: 11px; }
+.dag-node-status { fill: var(--text); font-size: 11px; }
+.dag-dimmed { opacity: 0.25; }
+.dag-graph-node.status-running { animation: graph-node-pulse 2s ease-in-out infinite; }
+
+@keyframes graph-node-pulse {
+  50% { filter: drop-shadow(0 0 7px rgba(210, 153, 34, 0.45)); }
+}
+
+@media (max-width: 680px) {
+  #app { padding-inline: var(--space-3); }
+  .meta-grid { grid-template-columns: 1fr; }
+  .dag-graph-viewport { max-height: 480px; }
+  table { min-width: 760px; }
+  .panel { overflow-x: auto; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    scroll-behavior: auto !important;
+    transition-duration: 0.01ms !important;
+  }
+}
+
 .kpi-grid {
   display: grid;
   grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));

package/dist/worker/task-graph/validate.js

@@ -2,6 +2,7 @@ import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
 import { taskSpecSchema } from "../task-spec/schema.js";
+import { validateTaskSpec } from "../task-spec/validate.js";
 import { acceptanceSpecSchema } from "./acceptance-schema.js";
 import { computeReadyQueue } from "./ready-queue.js";
 import { taskGraphSpecSchema } from "./task-graph-schema.js";
@@ -13,12 +14,57 @@ export async function validateFeatureTaskGraph(featureDir, options = {}) {
         return result("", acceptance, graph, errors);
     }
     checkDuplicateNodeIds(graph, errors);
+    checkDuplicateAcceptanceIds(acceptance, errors);
     checkAcceptanceTaskRefs(acceptance, graph, errors);
     checkUnknownDependencies(graph, errors);
     checkCycles(graph, errors);
-    await checkTaskFiles(featureDir, graph, errors);
+    await checkTaskFiles(featureDir, graph, acceptance, errors);
+    await checkQaCloseoutOrder(featureDir, options, errors);
     return result(graph.feature_id, acceptance, graph, errors);
 }
+async function checkQaCloseoutOrder(featureDir, options, errors) {
+    const closeoutPath = path.join(featureDir, "closeout.yaml");
+    let raw = options.closeoutOverride;
+    if (raw === undefined) {
+        if (!(await exists(closeoutPath)))
+            return;
+        raw = YAML.parse(await readFile(closeoutPath, "utf-8"));
+    }
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push({ code: "closeout-schema-invalid", message: "closeout.yaml must be an object", path: "closeout.yaml" });
+        return;
+    }
+    const record = raw;
+    if (record.status !== "success")
+        return;
+    if (record.qa_verdict !== "pass") {
+        errors.push({
+            code: "qa-verdict-required-before-closeout",
+            message: "success closeout requires qa_verdict: pass",
+            path: "closeout.yaml:qa_verdict",
+        });
+    }
+    if (!Array.isArray(record.qa_evidence) || record.qa_evidence.length === 0) {
+        errors.push({
+            code: "qa-evidence-required-before-closeout",
+            message: "success closeout requires non-empty qa_evidence",
+            path: "closeout.yaml:qa_evidence",
+        });
+    }
+}
+function checkDuplicateAcceptanceIds(acceptance, errors) {
+    const seen = new Set();
+    for (const item of acceptance.acceptance) {
+        if (seen.has(item.id)) {
+            errors.push({
+                code: "duplicate-acceptance-id",
+                message: `duplicate acceptance id: ${item.id}`,
+                path: `acceptance.${item.id}`,
+            });
+        }
+        seen.add(item.id);
+    }
+}
 async function loadAcceptanceSpec(featureDir, options, errors) {
     const raw = options.acceptanceOverride ??
         YAML.parse(await readFile(path.join(featureDir, "acceptance.yaml"), "utf-8"));
@@ -115,7 +161,8 @@ function checkCycles(graph, errors) {
     for (const node of graph.nodes)
         visit(node.id, []);
 }
-async function checkTaskFiles(featureDir, graph, errors) {
+async function checkTaskFiles(featureDir, graph, acceptance, errors) {
+    const acceptanceIds = new Set(acceptance.acceptance.map((item) => item.id));
     for (const node of graph.nodes) {
         const taskPath = path.join(featureDir, "tasks", node.task);
         if (!(await exists(taskPath))) {
@@ -126,7 +173,8 @@ async function checkTaskFiles(featureDir, graph, errors) {
             });
             continue;
         }
-        const parsedTask = taskSpecSchema.safeParse(YAML.parse(await readFile(taskPath, "utf-8")));
+        const rawTask = YAML.parse(await readFile(taskPath, "utf-8"));
+        const parsedTask = taskSpecSchema.safeParse(rawTask);
         if (!parsedTask.success) {
             errors.push({
                 code: "task-spec-schema-invalid",
@@ -136,6 +184,23 @@ async function checkTaskFiles(featureDir, graph, errors) {
             continue;
         }
         const taskSpec = parsedTask.data;
+        const detailed = await validateTaskSpec(rawTask, { taskSpecPath: taskPath });
+        for (const issue of detailed.errors) {
+            errors.push({
+                code: `task-${issue.code}`,
+                message: `${node.id}: ${issue.message}`,
+                path: `${node.task}:${issue.path ?? ""}`,
+            });
+        }
+        for (const acceptanceRef of taskSpec.acceptance_refs) {
+            if (!acceptanceIds.has(acceptanceRef)) {
+                errors.push({
+                    code: "task-acceptance-ref-missing",
+                    message: `${node.id} references missing acceptance ${acceptanceRef}`,
+                    path: `${node.task}:acceptance_refs`,
+                });
+            }
+        }
         if (taskSpec.id !== node.id) {
             errors.push({
                 code: "task-id-mismatch",

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

@@ -426,12 +426,12 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
                 phase: "intermediate",
                 taskConfig,
             }),
-            final: adapter.getVerifyCommands(repoRoot, {
+            final: mergeFinalVerifyCommands(repoRoot, taskConfig, adapter.getVerifyCommands(repoRoot, {
                 preset,
                 quota: "full",
                 phase: "final",
                 taskConfig,
-            }),
+            })),
         };
         if (verifyCommands.final.length === 0) {
             throw new Error("adapter returned no final verification commands");
@@ -455,6 +455,22 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         verifyCommands,
     };
 }
+function mergeFinalVerifyCommands(repoRoot, taskConfig, adapterCommands) {
+    const taskCommands = taskConfig.verifyCommands.map((command) => ({
+        args: ["bash", "-lc", command.command],
+        cwd: repoRoot,
+        label: command.label,
+        timeoutMs: command.timeoutMs,
+    }));
+    const seen = new Set();
+    return [...taskCommands, ...adapterCommands].filter((command) => {
+        const key = `${command.cwd}\0${command.args.join("\0")}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
 export function buildStandardHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const forbiddenPaths = mergeForbiddenPaths(taskConfig);

package/docs/README.md

@@ -34,6 +34,9 @@
 - `exec-plans/completed/README.md` — 已完成的执行计划
 - `progress/README.md` — 进度交接日志
 - `reports/README.md` — 验证与审计报告
+- `reports/2026-07-11-round3-worker-expansion.md` — Round 3 Worker 扩量、0.7.4 FE green、QA review blocker 与第二轮 owner decision
+- `reports/2026-07-11-observe-dag-visualization.md` — Observe DAG edges、SVG 图形化、交互与真实 Chrome smoke 验证证据
+- `reports/2026-07-11-0.7.5-init-evolution-review.md` — 0.7.5 package/version 变化对目标项目初始化 surface 的影响审查
 - `decisions/README.md` — 架构决策
 - `skills/README.md` — repo-local skill registry and vetting notes
 - `templates/` — 可复用的规划、报告与 DAG 模板
@@ -54,6 +57,7 @@
 - `templates/worker-dogfood-setup.md` — 发布控制器下的真实 Worker sample setup 与 retry 纪律
 - `templates/worker-dogfood-evidence.md` — BE/FE/QA sample、Observe、morning report 与 coverage evidence 模板
 - `templates/interactive-ui-round2-experiment.md` — interactive UI prompt/model A/B/C 对照实验与统一指标模板
+- `templates/product-line/` — 可投影的 Feature/Task/QA/Links 产品线包；配合 `agent-worker task validate-feature` 做 docs CI
 - `templates/production-readiness-checklist.md` — 低/中风险单仓库 DAG readiness 检查清单
 - `templates/init-evolution-review.md` — 初始化能力演化审查报告模板
 - `templates/adr.md` — 架构决策记录（ADR）

package/docs/exec-plans/active/README.md

@@ -7,6 +7,5 @@
 当前 active execution plan：
 
 - `2026-07-10-release-0.6.0-nightly-drill.md` — 技术演练已完成；等待 0.6.0 发布 owner 对 Day-1 provisional remediation 作明确 ratify / revise / reject。
-- `2026-07-11-round-2-interactive-ui-productization.md` — 补齐 Round-1 owner gate，发布 interactive-ui controller，完成 React A/B/C、Round 2/3 扩量、CI/cron 和产品线模板/docs CI。
 
-- 已归档：`../completed/2026-07-11-interactive-ui-writer-routing.md`、`../completed/2026-07-10-next-stage-worker-evidence.md` 及更早计划。
+- 已归档：`../completed/2026-07-11-observe-dag-visualization.md`、`../completed/2026-07-11-round-2-interactive-ui-productization.md`、`../completed/2026-07-11-interactive-ui-writer-routing.md`、`../completed/2026-07-10-next-stage-worker-evidence.md` 及更早计划。

package/docs/exec-plans/completed/README.md

@@ -9,6 +9,8 @@ npm 包携带本 README 作为目录契约。具体 completed plan 属于目标
 - [`2026-07-04-runtime-boundary-remediation.md`](2026-07-04-runtime-boundary-remediation.md) — 整合 CLI/skill/runtime 边界，抽出 DAG/Loop runtime seam，集中 harness store/guard 策略
 - [`2026-07-10-next-stage-worker-evidence.md`](2026-07-10-next-stage-worker-evidence.md) — Worker retry、EnvFailure、边界治理、初始化投影与真实 BE/FE/QA dogfood evidence 闭环
 - [`2026-07-11-interactive-ui-writer-routing.md`](2026-07-11-interactive-ui-writer-routing.md) — 新增 interactive-ui writer-only HIGH 路由、UI 交付契约、真实 React dogfood fixture 与 Round-2 A/B/C 实验入口
+- [`2026-07-11-round-2-interactive-ui-productization.md`](2026-07-11-round-2-interactive-ui-productization.md) — 完成 owner gate、0.7.0–0.7.4 发布、React A/B/C、20 个 Worker runs、外部 nightly、产品线模板与 docs CI
+- [`2026-07-11-observe-dag-visualization.md`](2026-07-11-observe-dag-visualization.md) — Observe 投影 canonical DAG edges，新增确定性 SVG 依赖图、节点交互、视觉 tokens、可访问性与真实 Chrome smoke
 - [`2026-07-04-dag-role-skill-alignment.md`](2026-07-04-dag-role-skill-alignment.md) — 对齐 DAG/Dynamic Workflow role 与 repo-local vetted skills，新增 strict skill audit
 - [`2026-07-06-production-readiness-hardening.md`](2026-07-06-production-readiness-hardening.md) — 冻结 Production Readiness v0.1，打磨 DAG 主路径 next steps、failure routing、doctor/report/failure handoff 与 dogfood 验证
 - [`2026-07-08-taskspec-schema-validate.md`](2026-07-08-taskspec-schema-validate.md) — 新增 TaskSpec v0.1 schema、三层校验器、risk→complexity 映射和 5 个 dogfood TaskSpec 样例

package/docs/init-surface.manifest.json

@@ -17,6 +17,17 @@
     "docs/templates/worker-dogfood-setup.md",
     "docs/templates/worker-dogfood-evidence.md",
     "docs/templates/interactive-ui-round2-experiment.md",
+    "docs/templates/product-line/README.md",
+    "docs/templates/product-line/AGENTS.md",
+    "docs/templates/product-line/requirement.md",
+    "docs/templates/product-line/acceptance.yaml",
+    "docs/templates/product-line/design.md",
+    "docs/templates/product-line/test-plan.md",
+    "docs/templates/product-line/task-graph.yaml",
+    "docs/templates/product-line/task.yaml",
+    "docs/templates/product-line/closeout.yaml",
+    "docs/templates/product-line/links.md",
+    "scripts/check-product-line-docs.sh",
     "docs/templates/agent-dag.schema.json",
     "examples/example-dag.json",
     "skills/loop-agent/SKILL.md",
@@ -46,6 +57,17 @@
     "docs/templates/worker-dogfood-setup.md",
     "docs/templates/worker-dogfood-evidence.md",
     "docs/templates/interactive-ui-round2-experiment.md",
+    "docs/templates/product-line/README.md",
+    "docs/templates/product-line/AGENTS.md",
+    "docs/templates/product-line/requirement.md",
+    "docs/templates/product-line/acceptance.yaml",
+    "docs/templates/product-line/design.md",
+    "docs/templates/product-line/test-plan.md",
+    "docs/templates/product-line/task-graph.yaml",
+    "docs/templates/product-line/task.yaml",
+    "docs/templates/product-line/closeout.yaml",
+    "docs/templates/product-line/links.md",
+    "scripts/check-product-line-docs.sh",
     "scripts/check-repo.sh",
     "scripts/ci-governance.sh",
     "scripts/ci-tests.sh",
@@ -91,6 +113,17 @@
     "docs/templates/worker-dogfood-setup.md": "copied",
     "docs/templates/worker-dogfood-evidence.md": "copied",
     "docs/templates/interactive-ui-round2-experiment.md": "copied",
+    "docs/templates/product-line/README.md": "copied",
+    "docs/templates/product-line/AGENTS.md": "copied",
+    "docs/templates/product-line/requirement.md": "copied",
+    "docs/templates/product-line/acceptance.yaml": "copied",
+    "docs/templates/product-line/design.md": "copied",
+    "docs/templates/product-line/test-plan.md": "copied",
+    "docs/templates/product-line/task-graph.yaml": "copied",
+    "docs/templates/product-line/task.yaml": "copied",
+    "docs/templates/product-line/closeout.yaml": "copied",
+    "docs/templates/product-line/links.md": "copied",
+    "scripts/check-product-line-docs.sh": "copied",
     "scripts/check-repo.sh": "generated",
     "scripts/ci-governance.sh": "generated",
     "scripts/ci-tests.sh": "generated",

package/docs/templates/product-line/AGENTS.md

@@ -0,0 +1,8 @@
+# Product-line execution rules
+
+- Read requirement, acceptance, design, test plan, task graph, and the selected TaskSpec before writing.
+- Treat `constraints.allowed_paths` and `constraints.forbidden_paths` as machine-enforced write boundaries; review DAG writer `writeSet` before execution.
+- Advance only tasks whose dependencies are complete. Preserve failed run records; retries receive new worker run IDs.
+- A Ready task must have acceptance references, non-empty allowed/forbidden paths, and deterministic verification commands.
+- QA records an independent verdict and evidence. Do not write `status: success` closeout until `qa_verdict: pass` and non-empty `qa_evidence` exist.
+- Human gates remain human decisions. Record owner, time, reason, evidence, and follow-up without rewriting failed history.

package/docs/templates/product-line/README.md

@@ -0,0 +1,9 @@
+# Product-line feature packet
+
+Copy this directory for each product feature. Replace angle-bracket placeholders, keep IDs stable, and run:
+
+```bash
+agent-worker task validate-feature <feature-dir>
+```
+
+The validator checks acceptance ID uniqueness, task references and dependencies, cycles, TaskSpec/path/verification completeness, and QA evidence before a successful closeout.

package/docs/templates/product-line/acceptance.yaml

@@ -0,0 +1,14 @@
+schema_version: 1
+feature_id: F-YYYY-NNN
+acceptance:
+  - id: AC-FEATURE-001
+    title: Observable outcome is delivered
+    priority: must
+    type: behavior
+    given: the documented precondition
+    when: the user or system performs the action
+    then: the observable result occurs
+    verification:
+      expected_task_refs:
+        - BE-001
+        - QA-001

package/docs/templates/product-line/closeout.yaml

@@ -0,0 +1,9 @@
+schema_version: 1
+feature_id: F-YYYY-NNN
+status: success
+qa_verdict: pass
+qa_evidence:
+  - <run-or-report-path>
+owner: <human owner>
+decided_at: <ISO-8601 timestamp>
+summary: <what shipped and why evidence is sufficient>

package/docs/templates/product-line/design.md

@@ -0,0 +1,13 @@
+# Design — <Feature title>
+
+## Context and boundaries
+
+Describe existing components, public contracts, trust boundaries, and protected areas.
+
+## Proposed change
+
+Describe the smallest end-to-end path and its failure behavior.
+
+## Decisions and alternatives
+
+Record material trade-offs and link ADRs where needed.

package/docs/templates/product-line/links.md

@@ -0,0 +1,10 @@
+# Traceability links
+
+| Relationship | Link or ID |
+|---|---|
+| Feature | `F-YYYY-NNN` |
+| Acceptance → tests | `AC-FEATURE-001` → `TC-001` |
+| Acceptance → tasks | `AC-FEATURE-001` → `BE-001`, `QA-001` |
+| Task → worker/DAG run | `<workerRunId>` / `<dagRunId>` |
+| Change/MR/PR | `<link>` |
+| QA evidence | `<artifact path or link>` |

package/docs/templates/product-line/requirement.md

@@ -0,0 +1,17 @@
+# <Feature title>
+
+- Feature ID: `<F-YYYY-NNN>`
+- Owner: `<human owner>`
+- Outcome: `<user or business outcome>`
+
+## In scope
+
+- `<observable capability>`
+
+## Out of scope
+
+- `<explicit non-goal>`
+
+## Constraints
+
+- `<security, compatibility, cost, or operational boundary>`

package/docs/templates/product-line/task-graph.yaml

@@ -0,0 +1,15 @@
+schema_version: 1
+feature_id: F-YYYY-NNN
+nodes:
+  - id: BE-001
+    task: BE-001.yaml
+    type: backend-feature
+    depends_on: []
+  - id: QA-001
+    task: QA-001.yaml
+    type: qa-execute
+    depends_on:
+      - BE-001
+parallel_policy:
+  max_parallel_tasks: 2
+  disallow_same_file_parallel_writes: true

package/docs/templates/product-line/task.yaml

@@ -0,0 +1,65 @@
+schema_version: 1
+id: BE-001
+feature_id: F-YYYY-NNN
+title: <Bounded tracer-bullet task>
+description: <Observable delivery>
+repo:
+  name: <repository-name>
+  path_ref: <repository-path-reference>
+  default_branch: main
+type: backend-feature
+priority: P1
+risk_level: medium
+depends_on: []
+source_docs:
+  requirement: ../requirement.md
+  acceptance: ../acceptance.yaml
+  design: ../design.md
+  test_plan: ../test-plan.md
+acceptance_refs:
+  - AC-FEATURE-001
+scope:
+  goals:
+    - <goal>
+  non_goals:
+    - <non-goal>
+constraints:
+  allowed_paths:
+    - <owned/path/**>
+  forbidden_paths:
+    - <protected/path/**>
+  hard_constraints:
+    - Do not access production secrets
+verify:
+  preset: standard
+  mode: serial
+  commands:
+    - id: focused-test
+      label: Focused deterministic verification
+      command: <project-specific verification command>
+      required: true
+      timeout_ms: 300000
+worker:
+  execution_mode: generate-validate-run
+  max_attempts: 1
+  timeout_ms: 7200000
+  require_clean_worktree: true
+  require_human_review: true
+  create_worktree: false
+loop_agent:
+  profile_policy: mapped
+  strict_models: true
+  strict_governance: true
+  no_cursor: false
+  max_concurrent: 1
+outputs:
+  required:
+    - dag_json
+    - run_record
+    - shell_verification
+    - diff_patch
+    - closeout_or_failure_handoff
+failure_policy:
+  failed_run_promote: false
+  generate_closeout_draft: true
+  create_followup_task: true

package/docs/templates/product-line/test-plan.md

@@ -0,0 +1,7 @@
+# Test plan — <Feature title>
+
+| Test ID | Acceptance | Level | Scenario | Deterministic command |
+|---|---|---|---|---|
+| TC-001 | AC-FEATURE-001 | integration | happy path and primary failure | `<project-specific command>` |
+
+Include negative cases, regression scope, environment assumptions, and evidence locations. Commands must match the target project's real toolchain.

package/docs/verification-matrix.md

@@ -26,6 +26,14 @@ npm run dev -- --help
 npm pack --dry-run
 ```
 
+产品线 Feature/Task/QA 文档或 TaskSpec 约束变更还应运行：
+
+```bash
+bash scripts/check-product-line-docs.sh
+```
+
+该检查对仓库中的 feature packet 执行 `agent-worker task validate-feature`，覆盖 AC 唯一性、依赖/环、TaskSpec 路径与验证命令、QA verdict 与 success closeout 顺序。
+
 Windows 上通过 Git Bash 或已配置的兼容 Bash 运行 `scripts/*.sh`。跨平台 CLI 代码对真实文件操作用原生路径；`/` 仅用于稳定 repo 引用、JSON/Markdown 证据引用和 glob 约定。
 
 没有相关门禁的新鲜命令输出，不得声明完成。

package/harness.json

@@ -50,6 +50,7 @@
     "checkHarnessRuntimeClean": "scripts/check-harness-runtime-clean.sh",
     "checkInitEvolutionNeeded": "scripts/check-init-evolution-needed.sh",
     "checkInitSurface": "scripts/check-init-surface.sh",
+    "checkProductLineDocs": "scripts/check-product-line-docs.sh",
     "ci": "scripts/ci.sh"
   },
   "executors": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",
@@ -25,6 +25,7 @@
     "examples/",
     "harness.json",
     "skills/",
+    "scripts/check-product-line-docs.sh",
     "README.md",
     "CHANGELOG.md"
   ],

package/scripts/check-product-line-docs.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "${ROOT_DIR}"
+
+feature_dirs=()
+while IFS= read -r acceptance; do
+  feature_dirs+=("$(dirname "$acceptance")")
+done < <(find dogfood/features -mindepth 2 -maxdepth 2 -name acceptance.yaml -type f | sort)
+
+if [[ ${#feature_dirs[@]} -eq 0 ]]; then
+  echo "product-line docs check skipped: no feature packets found"
+  exit 0
+fi
+
+for feature_dir in "${feature_dirs[@]}"; do
+  echo "==> validate product-line feature: ${feature_dir}"
+  node --import tsx/esm src/worker/cli.ts task validate-feature "${feature_dir}"
+done
+
+echo "product-line docs checks passed: ${#feature_dirs[@]} feature packet(s)"