@tea-agent/loop-agent 0.25.6 → 0.26.1

package/AGENTS.md

@@ -25,6 +25,7 @@
 - 用 loop-agent 迭代本仓库时，控制器必须来自已发布 npm 包（记录实际版本）；启动后不要中途升级；不要用工作区 `npm link` / `npm run dev` 控制可能改 CLI/runtime/package 的任务。
 - 反复出现的约束固化为文档、脚本、检查、测试或模板；禁止占位实现（除非 contract 标明脚手架）。
 - 非微小实现：`exec-plan` 不能替代 Agent DAG；除非用户要求 one-shot 或计划记录 escape hatch，否则改实现前完成 `new-task`、结构化路径、`dag run-task`、`dag validate` 与 writeSet 审查。
+- **实现默认 DAG，主会话不直接改代码**：只要是实现/修复/行为或展示语义变更（含 observe 文案映射、runtime status、schema、executor、CLI 等），主会话只做 Orient / 建 task / dry-run / validate / writeSet 审查 / 执行与监视 DAG，**不得**自己改 `src/**`、`test/**` 等交付面。仅当用户**明确授权**主会话直接处理（例如「直接改」「主会话改」「one-shot」「不用 DAG」）时，才允许主会话写入；授权后仍须记录边界、allowedPaths 与验证证据。纯答疑、读代码、查状态、提交/推送已有 diff、或用户点名的文档微调（如本文件规则）不在此限。
 - 不要自行引入外部 SDD/spec-first 等强制平行治理树；以本文件与 `docs/` 为准（ADR 0006）。
 
 ## 开始顺序
@@ -44,7 +45,7 @@
 
 1. Orient → 2. Select（一块）→ 3. Contract → 4. Implement → 5. Verify → 6. Converge Docs → 7. Handoff。
 
-这不是 DAG 节点序列。复杂实现默认 Agent DAG；主 agent 拆任务、写 contract、结构化路径、审查 DAG/writeSet/profile/shell verification。微小任务可用 one-shot escape hatch 并记录边界与验证证据。
+这不是 DAG 节点序列。实现默认 Agent DAG；主 agent 拆任务、写 contract、结构化路径、审查 DAG/writeSet/profile/shell verification，**不自行 implement**。主会话 one-shot 仅在用户明确授权时可用，并记录边界与验证证据；「看起来很小」或「只是展示文案」不构成授权——若改动触及 runtime/status/映射语义，仍走 DAG。
 
 启动 loop-agent DAG 流程后，主 agent 应自主推进到整个流程结束，不要中途请求无谓的人工确认（如“要我现在执行 DAG 吗？”）。只要 dry-run / validate / writeSet 审查通过就应直接执行并跑完全部 ranks；遇到真问题（契约不一致、writeSet 越界、verify 失败且超出 maxFixLoops、用户明显未授权的高风险动作）才停。即便 profile 是 supervised/reviewed，也不默认在 review-gate 主动停下等人——控制器会在需要人工 approve 时自行提示，主 agent 的职责是推动流程跑完。
 

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [0.26.1] - 2026-08-02
+
+### 新增
+
+- 新增 `task source prepare`：PRD-first 确定性派生薄执行契约（`source/需求.md` / `执行约束.md` + managed paths），默认 dry-run，`--apply` 仅经 Task Contract 投影落盘；默认无 LLM 写 source，工程字段不从 PRD 自动提取
+
+### 修复
+
+- Nightly 发布恢复探测会对 annotated tag 做 peel：远程 `ls-remote` 优先取 `refs/tags/<tag>^{}` 的 commit SHA，而不再把 tag object SHA 与 `git rev-list` 的 commit 误判为 conflict，避免「tag+npm 已齐、仅缺 GitHub Release」的恢复被错误中断
+- 收紧 Windows 下 write-guard 的 `git status` 启动路径，降低启动失败与误报
+
+## [0.26.0] - 2026-08-01
+
+### 新增
+
+- Observe/看板将 DAG 机器态 `partial_failed` 展示为「部分成功」（琥珀色 badge/timeline），与红色「执行失败」区分；内部状态与 recovery 语义仍为 `partial_failed` 非成功终态
+- `harness.json` 的 `executors.pi.LOW|MED|HIGH` 支持简洁对象写法 `{ model, thinking? }`，同时完全兼容既有模型字符串；显式 `thinking` 会透传到 DAG Pi 的 `modelConfig.thinking`，省略时不强制覆盖 Pi 默认（含既有 `wizard-local/gpt-5.5 → low` 硬编码例外，且显式配置优先）
+- pre-push 新增本机 verification receipt：相同 Git tree、关键环境与默认 24 小时 TTL 命中时可复用已通过验证，并对仅 `docs/reports/**/*.md` 的确定性变更使用 `check-repo` + `docs:build` 轻量门禁；新分支、多 ref、dirty/HEAD 漂移等不确定场景保持 fail-closed。
+- DAG Pi 模型矩阵支持 `provider/model` 限定引用，可让 LOW/MED/HIGH 通过不同 Pi provider 调用模型；裸模型名继续兼容原有映射与默认 provider，非法空组件在模型调用前安全拒绝
+
+### 修复
+
+- 收紧 `frontend-project-default-implementation`：强前端项目证据（React/Vue/Next）须与具体前端 allowedPath 证据（如 `.tsx`、`src/components/**`、`apps/web/src/**`）共同出现，才作为默认前端实现依据。核心 runtime 路径（如 `src/workflows/dag/**`、`src/server/**`）与宽泛 `src/**` 不再被仓库级前端证据单独劫持到 `frontend-implementation`，模糊任务安全回退 `standard-dag`/`supervised-implementation`。`Task Type: backend-feature` 不再因项目默认前端证据被误判为 mixed，分类保持 backend、模板保持非前端。不新增模型仲裁或路由 DAG 节点，也不向通用 backend 目录列表硬编码 loop-agent 私有目录，修复跨仓库通用。
+
 ## [0.25.6] - 2026-08-01
 
 ### 重点更新
@@ -16,8 +40,9 @@
 
 ### 改进
 
+- Observe/看板将 DAG 机器态 `partial_failed` 展示为「部分成功」（琥珀色 badge/timeline），与红色「执行失败」区分；内部状态与 recovery 语义仍为 `partial_failed` 非成功终态
 - 纯优化类变更现聚焦于需求、确定性影响面与最小回归集，避免无关接口全量用例膨胀
-- 该初始化模板仅随 npm 包发布，不投影到目标项目治理目录，同时同步了多项推荐路径与精确命令
+- 目标项目 `AGENTS.md` 的 `LOOP_AGENT_INIT` managed block 改为从 `docs/templates/init-managed-agents.md` 渲染，便于直接编辑维护；该模板仅随 npm 包发布，不投影到目标项目治理目录；同时同步 `import-prd`/exec-plan 推荐路径、init reconcile 零写入条件、DAG liveness/recovery 精确命令及 Official Console 裸入口
 
 ## [0.25.5] - 2026-07-31
 
@@ -45,6 +70,7 @@
 
 ### 修复
 
+- 修复 Windows 上 Pi writer 已完成写入后，write guard 启动 `git status` 偶发 `0xC0000142 / STATUS_DLL_INIT_FAILED` 而快速失败的问题：对该精确状态启用更长的有界指数退避和同一 Git for Windows 安装内的 executable fallback，持久化 writer 前置 baseline 与逐次结构化诊断；所有尝试耗尽后仍保持 fail-closed
 - 修复后端测试节点 4/6 的确定性覆盖与对应分析在自身崩溃时被静默吞掉的问题，现会写入诊断信息并按基础设施故障安全停止
 - 修复后端测试节点 4、6、7 在缺失 spec.sourceBinding 时未统一停止的问题，避免上游回退导致下游 manifest 突发报错
 - 修复成功执行路径下 HTTP 请求/响应日志解析不规范的问题，现统一规范化大小写不敏感的日志前缀并完整解析 JSON，恢复报告中的请求参数与大响应正文

package/README.md

@@ -56,11 +56,16 @@ loop-agent init reconcile --repo-root .
 
 ```bash
 loop-agent new-task example-task "实现一个有明确验收标准的小功能"
-```
 
-完善 `.harness/tasks/example-task/source/需求.md` 和 `task.json` 中的结构化写入边界，然后执行：
+# 推荐：先有详细 PRD，再归档并确定性派生执行契约（无需手写两个 source 文件）
+# loop-agent import-prd example-task --file path/to/prd.md --json
+loop-agent task source prepare example-task \
+  --use-imported-prd \
+  --allowed-path "src/**" \
+  --forbidden-path ".harness/**" \
+  --verify "typecheck:npm run typecheck" \
+  --apply --json
 
-```bash
 loop-agent dag run-task example-task \
   --profile auto \
   --strict-models \

package/dist/cli/command-definitions.js

@@ -12,6 +12,7 @@ import { runInstructions } from "../commands/instructions.js";
 import { runNewTask } from "../commands/new-task.js";
 import { runImportPrd } from "../commands/import-prd.js";
 import { runTaskContract } from "../commands/task-contract.js";
+import { runTaskSourcePrepare } from "../commands/task-source-prepare.js";
 import { runOperator } from "../commands/operator.js";
 import { runPlanList } from "../commands/plan-list.js";
 import { runPlanCheck, runPlanComplete, runPlanCreate, } from "../commands/plan.js";
@@ -139,7 +140,7 @@ const DAG_SUBCOMMANDS = [
     "final-verification",
     "decision",
 ];
-const TASK_SUBCOMMANDS = ["contract"];
+const TASK_SUBCOMMANDS = ["contract", "source"];
 const TASK_CONTRACT_SUBCOMMANDS = [
     "show",
     "validate",
@@ -149,6 +150,7 @@ const TASK_CONTRACT_SUBCOMMANDS = [
     "doctor",
     "recover",
 ];
+const TASK_SOURCE_SUBCOMMANDS = ["prepare"];
 const OPERATOR_SUBCOMMANDS = ["capabilities"];
 const WORKFLOW_SUBCOMMANDS = [
     "list",
@@ -271,19 +273,32 @@ export const COMMAND_DEFINITIONS = [
         name: "task",
         adapter: "required",
         tier: "primary",
-        intent: "Task Contract application boundary: show/validate/diff/apply/adopt/doctor/recover managed contract facts.",
-        usage: "task contract <show|validate|diff|apply|adopt|doctor|recover> ...",
+        intent: "Task Contract and source intake: contract show/validate/diff/apply/adopt/doctor/recover; source prepare (PRD-first Draft projection).",
+        usage: "task <contract|source> ...  (contract <show|validate|diff|apply|adopt|doctor|recover>; source prepare ...)",
         subcommands: [...TASK_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
-            if (subcommand !== "contract") {
-                throw new Error(formatSubcommandUsageError("task", TASK_SUBCOMMANDS));
+            if (subcommand === "contract") {
+                const [contractSub, ...contractRest] = rest;
+                if (!contractSub ||
+                    !TASK_CONTRACT_SUBCOMMANDS.includes(contractSub)) {
+                    throw new Error(`usage: task contract <${TASK_CONTRACT_SUBCOMMANDS.join("|")}> ...`);
+                }
+                await runTaskContract(repoRoot, [contractSub, ...contractRest]);
+                return;
             }
-            const [contractSub, ...contractRest] = rest;
-            if (!contractSub ||
-                !TASK_CONTRACT_SUBCOMMANDS.includes(contractSub)) {
-                throw new Error(`usage: task contract <${TASK_CONTRACT_SUBCOMMANDS.join("|")}> ...`);
+            if (subcommand === "source") {
+                const [sourceSub, ...sourceRest] = rest;
+                if (!sourceSub ||
+                    !TASK_SOURCE_SUBCOMMANDS.includes(sourceSub)) {
+                    throw new Error(`usage: task source <${TASK_SOURCE_SUBCOMMANDS.join("|")}> ...`);
+                }
+                if (sourceSub === "prepare") {
+                    await runTaskSourcePrepare(repoRoot, sourceRest);
+                    return;
+                }
+                throw new Error(`usage: task source <${TASK_SOURCE_SUBCOMMANDS.join("|")}> ...`);
             }
-            await runTaskContract(repoRoot, [contractSub, ...contractRest]);
+            throw new Error(formatSubcommandUsageError("task", TASK_SUBCOMMANDS));
         },
     },
     {

package/dist/cli/help.js

@@ -24,9 +24,10 @@ export function formatCommandTierSummary(manifest = CODE_AGENT_COMMAND_MANIFEST)
     return [
         "Recommended DAG path:",
         "  1. new-task <task-id> [title]",
-        "  2. import-prd <task-id> --file <original-prd>   # optional but recommended",
-        "  3. dag run-task <task-id> --profile auto --strict-models",
-        "  4. run-dag --dag <path> --cwd <repo-root>",
+        "  2. import-prd <task-id> --file <detailed-prd>   # PRD-first recommended",
+        "  3. task source prepare <task-id> --use-imported-prd --allowed-path <glob> --apply",
+        "  4. dag run-task <task-id> --profile auto --strict-models",
+        "  5. run-dag --dag <path> --cwd <repo-root>",
         "Operator recovery/closeout: dag status/report/doctor/closeout-draft",
         `Primary commands: ${primary}`,
         `Operator commands: ${operator}`,

package/dist/cli/program.js

@@ -41,6 +41,7 @@ import { runLoopBenchmark } from "../commands/loop-benchmark.js";
 import { runNewTask } from "../commands/new-task.js";
 import { runImportPrd } from "../commands/import-prd.js";
 import { runTaskContract } from "../commands/task-contract.js";
+import { runTaskSourcePrepare } from "../commands/task-source-prepare.js";
 import { runOperator } from "../commands/operator.js";
 import { runPiReuseBenchmark } from "../commands/pi-reuse-benchmark.js";
 import { parsePiPromptArgs, printPiPromptUsage, runPiPrompt, } from "../commands/pi-prompt.js";
@@ -137,25 +138,33 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
             await runImportPrd(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
         case "task": {
-            if (subcommand !== "contract") {
-                throw new Error("usage: task <contract> ...");
+            if (subcommand === "contract") {
+                const [contractSub, ...contractRest] = rest;
+                const allowed = [
+                    "show",
+                    "validate",
+                    "diff",
+                    "apply",
+                    "adopt",
+                    "doctor",
+                    "recover",
+                ];
+                if (!contractSub ||
+                    !allowed.includes(contractSub)) {
+                    throw new Error(`usage: task contract <${allowed.join("|")}> ...`);
+                }
+                await runTaskContract(ctx.repoRoot, [contractSub, ...contractRest]);
+                return;
             }
-            const [contractSub, ...contractRest] = rest;
-            const allowed = [
-                "show",
-                "validate",
-                "diff",
-                "apply",
-                "adopt",
-                "doctor",
-                "recover",
-            ];
-            if (!contractSub ||
-                !allowed.includes(contractSub)) {
-                throw new Error(`usage: task contract <${allowed.join("|")}> ...`);
+            if (subcommand === "source") {
+                const [sourceSub, ...sourceRest] = rest;
+                if (sourceSub !== "prepare") {
+                    throw new Error("usage: task source <prepare> ...");
+                }
+                await runTaskSourcePrepare(ctx.repoRoot, sourceRest);
+                return;
             }
-            await runTaskContract(ctx.repoRoot, [contractSub, ...contractRest]);
-            return;
+            throw new Error("usage: task <contract|source> ...");
         }
         case "operator":
             await runOperator(ctx.repoRoot, compactArgs([subcommand, ...rest]));
@@ -437,6 +446,14 @@ function addStandaloneSubcommands(parent, subcommands, handler) {
         });
     }
 }
+function configureTaskSourcePrepare(command) {
+    command
+        .description("Prepare deterministic task source files from a PRD or draft")
+        .usage("<task-id> [options]")
+        .option("--from-draft <path>", "TaskContractDraftV1 JSON path")
+        .option("--use-imported-prd", "use the task's imported PRD reference")
+        .option("--force-overwrite-source", "replace existing managed source files");
+}
 function configureDagValidate(command) {
     command
         .description("Validate an Agent DAG spec")
@@ -662,6 +679,15 @@ export function buildLoopAgentProgram(options) {
         }
         if (entry.subcommands)
             addRawSubcommands(command, entry.subcommands, options.defaultRepoRoot);
+        if (entry.name === "task") {
+            const source = command.commands.find((child) => child.name() === "source");
+            if (source) {
+                const prepare = createRawArgsCommand("prepare", "Prepare deterministic task source files", options.defaultRepoRoot);
+                configureTaskSourcePrepare(prepare);
+                replaceActionWithOptionAwareDispatch(prepare, options.defaultRepoRoot);
+                source.addCommand(prepare);
+            }
+        }
         program.addCommand(command);
     }
     return program;

package/dist/commands/import-prd.js

@@ -61,7 +61,11 @@ export async function runImportPrd(repoRoot, args) {
                 .split(path.sep)
                 .join("/"),
             referenceDocs: result.referenceDocs,
-            message: "Imported PRD as an immutable source reference. Derive source/需求.md from it; do not rewrite the reference copy.",
+            message: "Imported PRD as an immutable source reference. Next: task source prepare --use-imported-prd (plus engineering --allowed-path/--verify) then --apply. Do not rewrite source/references/*.",
+            next: [
+                `loop-agent task source prepare ${result.taskId} --use-imported-prd --allowed-path <glob> --verify "typecheck:npm run typecheck" --json`,
+                `loop-agent task source prepare ${result.taskId} --use-imported-prd --allowed-path <glob> --apply --json`,
+            ],
         }, null, 2));
         return;
     }
@@ -71,6 +75,7 @@ export async function runImportPrd(repoRoot, args) {
         `  materialized: ${result.materializedRelativePath}`,
         `  sha256: ${result.sha256}`,
         `  manifest: ${path.relative(repoRoot, result.manifestPath).split(path.sep).join("/")}`,
-        "Next: write source/需求.md as a derived execution contract with REQ/AC ids that map back to the original PRD. Do not edit source/references/*.",
+        "Next: loop-agent task source prepare <task-id> --use-imported-prd --allowed-path <glob> [--verify label:cmd] --apply --json",
+        "Do not hand-write source/需求.md or source/执行约束.md on the default path; do not edit source/references/*.",
     ].join("\n"));
 }

package/dist/commands/init.js

@@ -1811,14 +1811,15 @@ function buildManagedReadmeBlock(input) {
         "",
         "```bash",
         'loop-agent new-task <task-id> "任务标题"',
-        "# write .harness/tasks/<task-id>/source/需求.md",
-        "# write .harness/tasks/<task-id>/source/执行约束.md",
+        "# 推荐：详细 PRD → import-prd → task source prepare --apply（无需手写两 source）",
+        "# loop-agent import-prd <task-id> --file <prd.md>",
+        'loop-agent task source prepare <task-id> --use-imported-prd --allowed-path "<glob>" --apply --json',
         "loop-agent dag run-task <task-id> --profile auto --strict-models",
         "loop-agent dag validate --dag .harness/tasks/<task-id>/dag.json --strict-models --strict-governance",
         "loop-agent run-dag --dag .harness/tasks/<task-id>/dag.json --cwd .",
         "```",
         "",
-        `详细工作流见 \`${input.governanceRoot}/feature-workflow.md\`；验证矩阵见 \`${input.governanceRoot}/verification-matrix.md\`。任务 source 是必需项：\`source/需求.md\` 写目标、范围、非目标、验收标准和相关链接，\`source/执行约束.md\` 写允许路径、禁止路径、受保护变更、不变量、预期验证和失败条件。`,
+        `详细工作流见 \`${input.governanceRoot}/feature-workflow.md\`；验证矩阵见 \`${input.governanceRoot}/verification-matrix.md\`。任务 source 仍必需（\`source/需求.md\` / \`source/执行约束.md\`），默认由 \`task source prepare --apply\` 从详细 PRD 确定性派生，而不是主会话手写或 LLM 写 md。`,
         "",
         "执行后使用 `loop-agent dag report --run-id <run-id> --markdown` 和 `loop-agent dag doctor --run-id <run-id> --markdown` 读取事实与诊断失败。失败 run 不做成功式 closeout；使用 `loop-agent dag closeout-draft --run-id <run-id>` 生成 failure handoff。",
         "",
@@ -2043,8 +2044,9 @@ function buildTargetFeatureWorkflow(input) {
         "",
         "```bash",
         'loop-agent new-task <task-id> "Task title"',
-        "# write .harness/tasks/<task-id>/source/需求.md",
-        "# write .harness/tasks/<task-id>/source/执行约束.md",
+        "# Preferred: detailed PRD → import-prd → task source prepare --apply",
+        "# loop-agent import-prd <task-id> --file <prd.md>",
+        'loop-agent task source prepare <task-id> --use-imported-prd --allowed-path "<glob>" --apply --json',
         "loop-agent dag run-task <task-id> --profile auto --strict-models",
         "loop-agent dag validate --dag .harness/tasks/<task-id>/dag.json --strict-models --strict-governance",
         "loop-agent run-dag --dag .harness/tasks/<task-id>/dag.json --cwd .",