@tea-agent/loop-agent 0.3.0 → 0.5.0

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

@@ -0,0 +1,352 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import YAML from "yaml";
+import { resolveLoopAgentProfile } from "../profile-mapping.js";
+import { mapRiskLevelToComplexity } from "./complexity-mapping.js";
+import { taskSpecSchema } from "./schema.js";
+const CODE_WRITING_TYPES = new Set([
+    "backend-feature",
+    "frontend-feature",
+    "bugfix",
+    "qa-testcode",
+]);
+const VERIFY_OPTIONAL_TYPES = new Set(["qa-analysis", "reviewer-gate"]);
+const QA_TYPES = new Set([
+    "qa-analysis",
+    "qa-casegen",
+    "qa-testcode",
+    "qa-execute",
+    "qa-failure-analysis",
+]);
+export async function validateTaskSpec(input, options = {}) {
+    const schemaResult = taskSpecSchema.safeParse(input);
+    const fallback = fallbackIdentity(input);
+    if (!schemaResult.success) {
+        const errors = schemaResult.error.issues.map((issue) => ({
+            layer: "schema",
+            code: "schema-invalid",
+            message: issue.message,
+            path: issue.path.join("."),
+        }));
+        const failure = firstFailure(errors, "schema-invalid", "TaskSpec schema validation failed");
+        return buildResult({
+            taskId: fallback.taskId,
+            featureId: fallback.featureId,
+            businessProfile: fallback.businessProfile,
+            riskLevel: fallback.riskLevel,
+            checks: {
+                schema: failure,
+                sourceDocs: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                acceptanceRefs: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                dependsOn: "skipped",
+                pathBoundary: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                verifyCommands: failureFor("schema-invalid", "Skipped because schema validation failed"),
+                profileMapping: failureFor("schema-invalid", "Skipped because schema validation failed"),
+            },
+            errors,
+            warnings: [],
+        });
+    }
+    const taskSpec = schemaResult.data;
+    const errors = [];
+    const warnings = [];
+    const sourceDocsCheck = await checkSourceDocs(taskSpec, options, errors);
+    const acceptanceRefsCheck = await checkAcceptanceRefs(taskSpec, options, errors);
+    const dependsOnCheck = await checkDependsOn(taskSpec, options, errors);
+    const pathBoundaryCheck = checkPathBoundaries(taskSpec, errors, warnings);
+    const verifyCommandsCheck = checkVerifyCommands(taskSpec, errors);
+    const profileMapping = resolveLoopAgentProfile(taskSpec);
+    return buildResult({
+        taskId: taskSpec.id,
+        featureId: taskSpec.feature_id,
+        businessProfile: taskSpec.type,
+        riskLevel: taskSpec.risk_level,
+        loopAgentProfilePreview: profileMapping.loopAgentProfile,
+        checks: {
+            schema: "ok",
+            sourceDocs: sourceDocsCheck,
+            acceptanceRefs: acceptanceRefsCheck,
+            dependsOn: dependsOnCheck,
+            pathBoundary: pathBoundaryCheck,
+            verifyCommands: verifyCommandsCheck,
+            profileMapping: "ok",
+        },
+        errors,
+        warnings,
+    });
+}
+function buildResult(input) {
+    const riskLevel = input.riskLevel === "low" ||
+        input.riskLevel === "medium" ||
+        input.riskLevel === "high"
+        ? input.riskLevel
+        : "medium";
+    return {
+        schemaVersion: 1,
+        ok: input.errors.length === 0 && checksAreOk(input.checks),
+        taskId: input.taskId,
+        featureId: input.featureId,
+        businessProfile: input.businessProfile,
+        riskLevel: input.riskLevel,
+        complexityPreview: mapRiskLevelToComplexity(riskLevel),
+        loopAgentProfilePreview: input.loopAgentProfilePreview,
+        checks: input.checks,
+        errors: input.errors,
+        warnings: input.warnings,
+    };
+}
+function checksAreOk(checks) {
+    return Object.values(checks).every((check) => check === "ok" || check === "skipped");
+}
+async function checkSourceDocs(taskSpec, options, errors) {
+    const baseDir = getTaskSpecDir(options);
+    if (!baseDir)
+        return "ok";
+    for (const [key, relativePath] of Object.entries(taskSpec.source_docs)) {
+        if (!relativePath)
+            continue;
+        if (!(await exists(path.resolve(baseDir, relativePath)))) {
+            const error = {
+                layer: "file-existence",
+                code: "source-doc-missing",
+                message: `source_docs.${key} does not exist: ${relativePath}`,
+                path: `source_docs.${key}`,
+            };
+            errors.push(error);
+            return toFailure(error);
+        }
+    }
+    return "ok";
+}
+async function checkAcceptanceRefs(taskSpec, options, errors) {
+    const baseDir = getTaskSpecDir(options);
+    if (!baseDir)
+        return "ok";
+    const acceptancePath = path.resolve(baseDir, taskSpec.source_docs.acceptance);
+    if (!(await exists(acceptancePath))) {
+        const error = {
+            layer: "file-existence",
+            code: "acceptance-source-missing",
+            message: `acceptance source does not exist: ${taskSpec.source_docs.acceptance}`,
+            path: "source_docs.acceptance",
+        };
+        errors.push(error);
+        return toFailure(error);
+    }
+    const parsed = YAML.parse(await readFile(acceptancePath, "utf-8"));
+    const ids = collectStringIds(parsed);
+    for (const acceptanceRef of taskSpec.acceptance_refs) {
+        if (!ids.has(acceptanceRef)) {
+            const error = {
+                layer: "file-existence",
+                code: "acceptance-ref-missing",
+                message: `acceptance ref not found in acceptance source: ${acceptanceRef}`,
+                path: "acceptance_refs",
+            };
+            errors.push(error);
+            return toFailure(error);
+        }
+    }
+    return "ok";
+}
+async function checkDependsOn(taskSpec, options, errors) {
+    if (taskSpec.depends_on.length === 0)
+        return "skipped";
+    const baseDir = getTaskSpecDir(options);
+    if (!baseDir)
+        return "ok";
+    for (const dependency of taskSpec.depends_on) {
+        const dependencyPath = path.resolve(baseDir, `${dependency}.yaml`);
+        if (!(await exists(dependencyPath))) {
+            const error = {
+                layer: "file-existence",
+                code: "depends-on-missing",
+                message: `depends_on task file does not exist: ${dependency}.yaml`,
+                path: "depends_on",
+            };
+            errors.push(error);
+            return toFailure(error);
+        }
+    }
+    return "ok";
+}
+function checkPathBoundaries(taskSpec, errors, warnings) {
+    const start = errors.length;
+    for (const [index, allowedPath] of taskSpec.constraints.allowed_paths.entries()) {
+        if (isBroadAllowedPath(allowedPath)) {
+            errors.push({
+                layer: "path-boundary",
+                code: "broad-allowed-paths",
+                message: `allowed_paths entry is too broad: ${allowedPath}`,
+                path: `constraints.allowed_paths[${index}]`,
+            });
+        }
+        for (const [forbiddenIndex, forbiddenPath] of taskSpec.constraints.forbidden_paths.entries()) {
+            if (patternsOverlap(allowedPath, forbiddenPath)) {
+                errors.push({
+                    layer: "path-boundary",
+                    code: "allowed-forbidden-overlap",
+                    message: `allowed path overlaps forbidden path: ${allowedPath} / ${forbiddenPath}`,
+                    path: `constraints.forbidden_paths[${forbiddenIndex}]`,
+                });
+            }
+        }
+    }
+    if (CODE_WRITING_TYPES.has(taskSpec.type) &&
+        taskSpec.constraints.allowed_paths.length === 0) {
+        errors.push({
+            layer: "path-boundary",
+            code: "code-task-empty-allowed-paths",
+            message: `${taskSpec.type} requires non-empty allowed_paths`,
+            path: "constraints.allowed_paths",
+        });
+    }
+    if (taskSpec.constraints.forbidden_paths.length === 0) {
+        errors.push({
+            layer: "path-boundary",
+            code: "forbidden-paths-empty",
+            message: "TaskSpec requires non-empty forbidden_paths",
+            path: "constraints.forbidden_paths",
+        });
+    }
+    if (QA_TYPES.has(taskSpec.type) && !hasQaBusinessCodeForbiddenPath(taskSpec)) {
+        errors.push({
+            layer: "path-boundary",
+            code: "qa-business-code-not-forbidden",
+            message: "QA tasks must forbid common business code directories",
+            path: "constraints.forbidden_paths",
+        });
+    }
+    const complexity = mapRiskLevelToComplexity(taskSpec.risk_level);
+    if ((complexity === "medium" || complexity === "large") &&
+        taskSpec.constraints.allowed_paths.length === 0) {
+        errors.push({
+            layer: "path-boundary",
+            code: "empty-allowed-paths-for-complexity",
+            message: `${complexity} tasks require non-empty allowed_paths before materialize`,
+            path: "constraints.allowed_paths",
+        });
+    }
+    if (complexity === "small" && taskSpec.constraints.allowed_paths.length === 0) {
+        warnings.push({
+            code: "empty-allowed-paths-path-guard-risk",
+            message: "empty allowed_paths will make non-harness writes fail path guard",
+            path: "constraints.allowed_paths",
+        });
+    }
+    const pathErrors = errors.slice(start).filter((error) => error.layer === "path-boundary");
+    if (pathErrors.length === 0)
+        return "ok";
+    return toFailure(pathErrors[0]);
+}
+function checkVerifyCommands(taskSpec, errors) {
+    if (!VERIFY_OPTIONAL_TYPES.has(taskSpec.type) &&
+        taskSpec.verify.commands.length === 0) {
+        const error = {
+            layer: "file-existence",
+            code: "verify-commands-empty",
+            message: `${taskSpec.type} requires verify.commands`,
+            path: "verify.commands",
+        };
+        errors.push(error);
+        return toFailure(error);
+    }
+    return "ok";
+}
+function getTaskSpecDir(options) {
+    return options.taskSpecPath ? path.dirname(options.taskSpecPath) : undefined;
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function collectStringIds(value, ids = new Set()) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectStringIds(item, ids);
+        return ids;
+    }
+    if (value && typeof value === "object") {
+        for (const [key, child] of Object.entries(value)) {
+            if (key === "id" && typeof child === "string")
+                ids.add(child);
+            collectStringIds(child, ids);
+        }
+    }
+    return ids;
+}
+function isBroadAllowedPath(pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    return normalized === "**" || normalized === "./**" || normalized === ".";
+}
+function probeForPattern(pattern) {
+    return pattern
+        .replace(/\\/g, "/")
+        .replace(/\/\*\*$/, "/_probe_")
+        .replace(/\*\*$/, "_probe_")
+        .replace(/\*/g, "_")
+        .replace(/^\.\//, "");
+}
+function patternsOverlap(left, right) {
+    const leftProbe = probeForPattern(left);
+    const rightProbe = probeForPattern(right);
+    return (pathMatchesPattern(leftProbe, right) ||
+        pathMatchesPattern(rightProbe, left) ||
+        leftProbe === rightProbe);
+}
+function pathMatchesPattern(filePath, pattern) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalizedPattern.endsWith("/**")) {
+        const prefix = normalizedPattern.slice(0, -3);
+        return normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`);
+    }
+    if (normalizedPattern.includes("*")) {
+        const escaped = normalizedPattern
+            .split("*")
+            .map((part) => part.replace(/[|\\{}()[\]^$+?.]/g, "\\$&"))
+            .join(".*");
+        return new RegExp(`^${escaped}$`).test(normalizedPath);
+    }
+    return normalizedPath === normalizedPattern;
+}
+function hasQaBusinessCodeForbiddenPath(taskSpec) {
+    return taskSpec.constraints.forbidden_paths.some((forbiddenPath) => {
+        const normalized = forbiddenPath.replace(/\\/g, "/");
+        return (normalized.includes("/src/") ||
+            normalized.includes("src/**") ||
+            normalized.includes("/services/") ||
+            normalized.includes("services/**") ||
+            normalized.includes("/app/") ||
+            normalized.includes("app/**") ||
+            normalized.includes("/apps/"));
+    });
+}
+function fallbackIdentity(input) {
+    const record = input && typeof input === "object" ? input : {};
+    return {
+        taskId: typeof record.id === "string" ? record.id : "",
+        featureId: typeof record.feature_id === "string" ? record.feature_id : "",
+        businessProfile: typeof record.type === "string" ? record.type : "",
+        riskLevel: typeof record.risk_level === "string" ? record.risk_level : "medium",
+    };
+}
+function failureFor(code, message, pathValue) {
+    return { status: "failed", code, message, path: pathValue };
+}
+function firstFailure(errors, code, message) {
+    return errors[0] ? toFailure(errors[0]) : failureFor(code, message);
+}
+function toFailure(error) {
+    return {
+        status: "failed",
+        code: error.code,
+        message: error.message,
+        path: error.path,
+    };
+}

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

@@ -2,7 +2,7 @@ import { access, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { assertValidDagSpec } from "./validate.js";
-import { parseDagSpec, } from "./types.js";
+import { DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { resolveAdapter } from "../../adapters/index.js";
@@ -10,6 +10,7 @@ import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
+import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const MAX_SOURCE_EXCERPT_CHARS = 2000;
@@ -301,6 +302,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         constraintMarkdown,
         taskConfig,
         enabledExecutors: resolveEnabledExecutors(manifest.executors),
+        executorModelMatrix: resolveExecutorModelMatrices(manifest),
         verifyCommands,
     };
 }
@@ -336,18 +338,7 @@ export function buildStandardHybridDagFromTask(sources) {
             contextProfile: taskConfig.contextProfile,
         },
         skillsByRole: HYBRID_SKILLS_BY_ROLE,
-        executorModels: {
-            cursor: {
-                LOW: "composer-2.5",
-                MED: "composer-2.5",
-                HIGH: "composer-2.5",
-            },
-            pi: {
-                LOW: "gpt-5.3-codex-spark",
-                MED: "glm-5.2",
-                HIGH: "gpt-5.5",
-            },
-        },
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
         tasks: [
             {
                 id: "contract-pi",

package/dist/workflows/dag/skill-instructions.js

@@ -42,6 +42,10 @@ function buildSkillCandidatePaths(input) {
     const piSkillsDir = path.join(input.homeDir, ".pi", "agent", "skills");
     candidates.push(normalizeCandidate(path.join(piSkillsDir, input.name, "SKILL.md")), normalizeCandidate(path.join(piSkillsDir, `${input.name}.md`)));
     candidates.push(normalizeCandidate(path.join(input.cwd, "skills", input.name, "SKILL.md")));
+    // Agent-compatible project path (e.g. OpenCode). `skills/` stays the primary
+    // loop-agent repo-local path; `.agents/skills` is searched after it and before
+    // bundled skills so a project with only the mirror can still resolve.
+    candidates.push(normalizeCandidate(path.join(input.cwd, ".agents", "skills", input.name, "SKILL.md")));
     if (input.name === "loop-agent") {
         candidates.push(normalizeCandidate(path.join(input.cwd, "skill", "SKILL.md")));
     }

package/dist/workflows/dag/types.js

@@ -251,7 +251,7 @@ export const DEFAULT_DAG_EXECUTOR_MODELS = {
     cursor: {
         LOW: "composer-2.5",
         MED: "composer-2.5",
-        HIGH: "composer-2.5",
+        HIGH: "gpt-5.5",
     },
     pi: {
         LOW: "gpt-5.3-codex-spark",

package/dist/workflows/dag/validate.js

@@ -428,7 +428,7 @@ function validateDecisionGateTaskConfig(task, issues) {
         });
     }
 }
-export function collectExecutorModelWarnings(spec) {
+export function collectExecutorModelWarnings(spec, expectedMatrices = DEFAULT_DAG_EXECUTOR_MODELS) {
     const warnings = [];
     const executors = Object.keys(DEFAULT_DAG_EXECUTOR_MODELS);
     for (const executor of executors) {
@@ -436,11 +436,12 @@ export function collectExecutorModelWarnings(spec) {
         if (!actualByComplexity) {
             continue;
         }
+        const expectedByComplexity = expectedMatrices[executor] ?? DEFAULT_DAG_EXECUTOR_MODELS[executor];
         for (const [complexityKey, actual] of Object.entries(actualByComplexity)) {
             if (actual === undefined) {
                 continue;
             }
-            const expected = DEFAULT_DAG_EXECUTOR_MODELS[executor][complexityKey];
+            const expected = expectedByComplexity[complexityKey];
             if (actual !== expected) {
                 warnings.push({
                     executor,

package/docs/README.md

@@ -14,8 +14,12 @@
 - `loop-agent-harness.md` — runtime 与 command surface 概览
 - `agent-dag-runner.md` — Agent DAG runner 指南
 - `cursor-executor-usage.md` — Cursor executor 用法
-- `dynamic-workflow-dag-engine-roadmap.md` — Dynamic Workflow DAG Engine 路线图与适配分析
-- `init-surface.manifest.json` — npm 包范围、目标项目初始化投影与 `init check-update` surface 分类的机器校验契约
+- `dynamic-workflow-dag-engine-roadmap.md` — Dynamic Workflow DAG Engine 路线图与适配分析
+- `init-surface.manifest.json` — npm 包范围、目标项目初始化投影与 `init check-update` surface 分类的机器校验契约
+
+## 设计思想来源
+
+- `../website/docs/practices/` — Anthropic 长时运行 agent harness、OpenAI Codex harness engineering、腾讯端到端 Harness Engineering 与社区 agent harness 实践资料。当前仓库的“人类掌舵、智能体执行”、仓库即记录系统、小步增量、结构化 handoff 和 shell verification 纪律均受这些实践启发；权威执行规则仍以本目录治理文档、根目录 AGENTS.md、harness.json、skills 目录和脚本检查为准。
 
 ## 方法论
 
@@ -31,7 +35,7 @@
 - `progress/README.md` — 进度交接日志
 - `reports/README.md` — 验证与审计报告
 - `decisions/README.md` — 架构决策
-- `skills/README.md` — repo-local skill registry and vetting notes
+- `skills/README.md` — repo-local skill registry and vetting notes
 - `templates/` — 可复用的规划、报告与 DAG 模板
 
 ## 仓库 Skills
@@ -46,10 +50,10 @@
 - `templates/sprint-contract.md` — 实现契约与验收标准
 - `templates/exec-plan.md` — 非平凡工作的执行计划
 - `templates/progress-log.md` — 进度与交接日志
-- `templates/qa-report.md` — 验证与 QA 证据
-- `templates/production-readiness-checklist.md` — 低/中风险单仓库 DAG readiness 检查清单
-- `templates/init-evolution-review.md` — 初始化能力演化审查报告模板
-- `templates/adr.md` — 架构决策记录（ADR）
+- `templates/qa-report.md` — 验证与 QA 证据
+- `templates/production-readiness-checklist.md` — 低/中风险单仓库 DAG readiness 检查清单
+- `templates/init-evolution-review.md` — 初始化能力演化审查报告模板
+- `templates/adr.md` — 架构决策记录（ADR）
 
 ## 维护
 

package/docs/development-principles.md

@@ -6,6 +6,8 @@ loop-agent 是面向 agentic coding 的工作流 runtime。仓库应保持小而
 
 项目采用「人类掌舵、智能体执行」的工程模型。Agent 可实现、验证与总结，但持久意图与完成证据必须落在仓库中。
 
+这个模型吸收了 Anthropic 长时运行 agent harness、OpenAI Codex harness engineering、腾讯端到端 Harness Engineering 和社区 agent harness 实践中的共同经验：用短入口文档导航长期知识，用结构化任务状态和 handoff artifact 跨 session 传递事实，用独立验证和评审回路约束 agent 输出，并把人类注意力集中在意图、边界、架构和反馈系统上。面向使用者的背景资料收录在 `website/docs/practices/`。
+
 - 仓库是记录系统。决策、契约、计划、测试、报告与交接属于 tracked files。
 - `AGENTS.md` 是操作地图，不是知识 dump。长期方法论与决策属于 `docs/`。
 - 工作以小步、可逆、可验证的增量推进。

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

@@ -4,4 +4,4 @@
 
 源码仓库可在本 README 旁保留具体 active plan 文件。npm 包只携带本 README 作为目录契约，不复制 loop-agent 源码历史的 active plan；目标仓库自行生成 active plan。
 
-当前 active plan：无。
+当前没有 active plan。`2026-07-08-taskspec-worker-master.md` 的 7 个 step 已全部完成并归档到 `../completed/`。

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

@@ -9,3 +9,11 @@ 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-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 样例
+- [`2026-07-08-acceptance-taskgraph-ready.md`](2026-07-08-acceptance-taskgraph-ready.md) — 新增 AcceptanceSpec / TaskGraphSpec schema、Feature graph 校验、环检测和 Ready 队列计算
+- [`2026-07-08-profile-mapping-agent-worker-cli.md`](2026-07-08-profile-mapping-agent-worker-cli.md) — 新增 business profile 到 loop-agent profile 映射、独立 `agent-worker` CLI 和 package bin surface
+- [`2026-07-08-loop-agent-client-contract-smoke.md`](2026-07-08-loop-agent-client-contract-smoke.md) — 新增 LoopAgentClient、command artifact、JSON parse failure、repo resolver/preflight 与 Ring 0 CLI contract smoke
+- [`2026-07-08-materializer-ring1-dag.md`](2026-07-08-materializer-ring1-dag.md) — 新增 TaskSpec materializer、materialize manifest、coverage-safe source 输出与 Ring 1 DAG generate/validate/dry-run smoke
+- [`2026-07-08-run-task-pipeline-ring2.md`](2026-07-08-run-task-pipeline-ring2.md) — 新增 Worker run-task pipeline、task-local run record、成功/失败分流与 Ring 2 shell-only DAG success/failure smoke
+- [`2026-07-08-task-pool-morning-report.md`](2026-07-08-task-pool-morning-report.md) — 新增 Worker Task Pool JSONL/state store、failure routing、串行 batch run-ready 和 morning report
+- [`2026-07-08-taskspec-worker-master.md`](2026-07-08-taskspec-worker-master.md) — 完成 TaskSpec + Worker 7 步 master 编排，覆盖 schema、graph、profile、client、materialize、run-task、Task Pool 和 morning report