@tea-agent/loop-agent 0.25.2 → 0.25.4

package/AGENTS.md

@@ -60,6 +60,7 @@
 - 长期决策写入 `docs/`；面向用户变更更新 `CHANGELOG.md`（结果导向中文）。
 - init/投影变更必须同步目标项目生成物与 package assets；init evolution 按 `docs/init-surface.manifest.json` 分级。
 - CLI/skill entry/runtime boundary/发布包变更同步 catalog、脚本与测试。
+- 明确的前端页面/UI/组件/交互实现需求必须设置 `taskKind: "frontend-implementation"`（不是 `--profile`），不得保留默认 `standard`；浏览器/UI 自动化测试继续使用 `taskKind: "frontend-test"`。
 - 没有新鲜验证证据时不声明完成；新债写入 plan/progress/report。
 
 ## 验证

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## [Unreleased]
 
+## [0.25.4] - 2026-07-31
+
+### 新增
+
+- stream run progress heartbeats
+- improve HTML failure triage
+- add native checklist and HTML report gates
+
+### 修复
+
+- tighten production URL detection
+- preserve supported Pi default model
+- sync packaged prompt contract
+- normalize drifted case ids and decode nested HTML entities
+
+## [0.25.3] - 2026-07-30
+
+### 重点更新
+
+- 新增 OpenCode 客户端瞬态会话恢复机制，在内置重试遗漏时自动补偿 UnknownError
+- 优化前端实现需求路由，将前端开发与测试任务准确分发至对应 DAG 流程
+
+### 新增
+
+- loop-agent init 支持 --client-recovery 参数，可在目标项目生成 OpenCode 插件以补偿瞬态 UnknownError
+- 支持在用户级别原子写入 Pi retry 推荐配置，并严格遵守插件 ownership 不覆盖用户改动
+
+### 改进
+
+- 初始化或刷新 AGENTS.md 时，要求将明确的前端实现需求路由至 frontend-implementation，与浏览器和 UI 自动化测试区分开
+
+### 修复
+
+- 修复生成的 OpenCode 恢复插件无法按真实 API 工作的问题，现直接返回 Hooks.event 并按事件正确分发与续接
+- 修复 Type validation failed 等真实错误被业务校验规则误杀的问题
+- 修复 Pi retry 配置读取将权限或 I/O 错误误判为缺文件的问题，现仅 ENOENT 视为缺文件
+
 ## [0.25.2] - 2026-07-30
 
 ### 重点更新

package/dist/application/dag/args.js

@@ -247,12 +247,14 @@ export function parseDagValidateArgs(args) {
 }
 export function parseRunDagArgs(args, defaultCwd) {
     if (args.length === 0) {
-        throw new Error("usage: run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--json]");
+        throw new Error("usage: run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--quiet] [--progress-interval-ms N] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--json]");
     }
     let dagPath;
     let cwd;
     let initOnly = false;
     let dryRun = false;
+    let quiet = false;
+    let progressIntervalMs = 30_000;
     let maxConcurrent;
     let runId;
     let canvasPath;
@@ -280,6 +282,15 @@ export function parseRunDagArgs(args, defaultCwd) {
         else if (arg === "--dry-run") {
             dryRun = true;
         }
+        else if (arg === "--quiet") {
+            quiet = true;
+        }
+        else if (arg === "--progress-interval-ms") {
+            progressIntervalMs = parseProgressIntervalMs(args[++i]);
+        }
+        else if (arg.startsWith("--progress-interval-ms=")) {
+            progressIntervalMs = parseProgressIntervalMs(arg.slice("--progress-interval-ms=".length));
+        }
         else if (arg === "--max-concurrent") {
             maxConcurrent = parseMaxConcurrent(args[++i]);
         }
@@ -337,6 +348,8 @@ export function parseRunDagArgs(args, defaultCwd) {
         cwd: path.resolve(cwd ?? defaultCwd ?? process.cwd()),
         initOnly,
         dryRun,
+        quiet,
+        progressIntervalMs,
         maxConcurrent,
         runId,
         canvasPath,
@@ -346,6 +359,13 @@ export function parseRunDagArgs(args, defaultCwd) {
         ...(workerAssociation ? { workerAssociation } : {}),
     };
 }
+function parseProgressIntervalMs(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1_000) {
+        throw new Error("progress-interval-ms must be an integer >= 1000");
+    }
+    return parsed;
+}
 function parseWorkerAssociation(raw) {
     if (!raw?.trim()) {
         throw new Error("run-dag --worker-association requires JSON");

package/dist/application/dag/run-dag.js

@@ -55,6 +55,7 @@ export async function runDagUseCase(input) {
         })
         : undefined;
     const observer = composeDagRunObservers([
+        input.observer,
         canvas?.observer,
         eventObserver?.observer,
     ]);

package/dist/cli/command-definitions.js

@@ -216,7 +216,7 @@ export const COMMAND_DEFINITIONS = [
         adapter: "none",
         tier: "primary",
         intent: "Initialize a target repository with loop-agent harness capabilities.",
-        usage: "init [instructions|doctor|check-update|update|reconcile] [--profile full|minimal] [--merge] [--json|--markdown] [--bootstrap-surface|--apply-safe]",
+        usage: "init [instructions|doctor|check-update|update|reconcile] [--profile full|minimal] [--merge] [--json|--markdown] [--bootstrap-surface|--apply-safe] [--client-recovery=auto|project|user|off]",
         subcommands: [...INIT_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runInit(repoRoot, [subcommand, ...rest].filter(Boolean), { readRuntimeActivity: readInitRuntimeActivity });
@@ -662,7 +662,7 @@ export const COMMAND_DEFINITIONS = [
         adapter: "required",
         tier: "primary",
         intent: "Execute a reviewed Agent DAG spec.",
-        usage: "run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--worker-association <json>]",
+        usage: "run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--quiet] [--progress-interval-ms N] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--worker-association <json>]",
         handler: async ({ repoRoot, subcommand, rest }) => {
             const runDagArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
             await runRunDag(repoRoot, runDagArgs);

package/dist/cli/program.js

@@ -124,18 +124,8 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
             await runDoctor(ctx.adapter, ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
         case "docs":
-            if (subcommand === "audit") {
-                await runDocsAudit(ctx.repoRoot);
-                return;
-            }
-            if (subcommand === "archive") {
-                const [planPath] = rest;
-                if (!planPath)
-                    throw new Error("usage: docs archive <active-plan-path>");
-                await runDocsArchive(ctx.repoRoot, planPath);
-                return;
-            }
-            throw new Error("usage: docs <audit|archive> ...");
+            await runDocsCommand(ctx.repoRoot, subcommand, rest);
+            return;
         case "new-task": {
             const [taskId, ...titleParts] = [subcommand, ...rest];
             if (!taskId)
@@ -189,53 +179,14 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
             await runStats(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
         case "plan":
-            if (subcommand === "list" || subcommand === undefined) {
-                await runPlanList(ctx.repoRoot);
-                return;
-            }
-            if (subcommand === "create") {
-                const [planId, ...titleParts] = rest;
-                if (!planId)
-                    throw new Error('usage: plan create <plan-id> "<title>"');
-                await runPlanCreate(ctx.repoRoot, planId, titleParts.join(" "));
-                return;
-            }
-            if (subcommand === "complete") {
-                const [planId, ...summaryParts] = rest;
-                if (!planId)
-                    throw new Error('usage: plan complete <plan-id> --summary "<summary>"');
-                const summary = parsePlanSummaryFlag(summaryParts);
-                if (!summary)
-                    throw new Error('usage: plan complete <plan-id> --summary "<summary>"');
-                await runPlanComplete(ctx.repoRoot, planId, { summary });
-                return;
-            }
-            if (subcommand === "check") {
-                await runPlanCheck(ctx.repoRoot);
-                return;
-            }
-            throw new Error("usage: plan <list|create|complete|check> ...");
+            await runPlanCommand(ctx.repoRoot, subcommand, rest);
+            return;
         case "spine":
             await runSpine(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
         case "handoff":
-            if (subcommand === "check") {
-                await runHandoffCheck(ctx.repoRoot, rest[0]);
-                return;
-            }
-            if (subcommand === "coverage") {
-                const [taskId, ...flags] = rest;
-                if (!taskId) {
-                    throw new Error("usage: handoff coverage <taskId> [--json|--markdown]");
-                }
-                const exitCode = await runCoverageAudit(ctx.repoRoot, taskId, {
-                    json: flags.includes("--json"),
-                    markdown: flags.includes("--markdown"),
-                });
-                process.exitCode = exitCode;
-                return;
-            }
-            throw new Error("usage: handoff <check|coverage> [taskId]");
+            await runHandoffCommand(ctx.repoRoot, subcommand, rest);
+            return;
         case "coverage":
             await runCoverageReport(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
@@ -243,14 +194,8 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
             await runGoal(ctx.repoRoot, subcommand, rest);
             return;
         case "reference":
-            if (subcommand === "index") {
-                const [taskId] = rest;
-                if (!taskId)
-                    throw new Error("usage: reference index <task-id>");
-                await runReferenceIndex(ctx.repoRoot, taskId);
-                return;
-            }
-            throw new Error("usage: reference <index> <task-id>");
+            await runReferenceCommand(ctx.repoRoot, subcommand, rest);
+            return;
         case "study":
             if (subcommand === "init") {
                 await runStudyInit(ctx.repoRoot, rest);
@@ -305,6 +250,78 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
             throw new Error(`commander command is not wired to an action: ${command}`);
     }
 }
+async function runDocsCommand(repoRoot, subcommand, rest) {
+    if (subcommand === "audit") {
+        await runDocsAudit(repoRoot);
+        return;
+    }
+    if (subcommand === "archive") {
+        const [planPath] = rest;
+        if (!planPath)
+            throw new Error("usage: docs archive <active-plan-path>");
+        await runDocsArchive(repoRoot, planPath);
+        return;
+    }
+    throw new Error("usage: docs <audit|archive> ...");
+}
+async function runPlanCommand(repoRoot, subcommand, rest) {
+    if (subcommand === "list" || subcommand === undefined) {
+        await runPlanList(repoRoot);
+        return;
+    }
+    if (subcommand === "create") {
+        const [planId, ...titleParts] = rest;
+        if (!planId)
+            throw new Error('usage: plan create <plan-id> "<title>"');
+        await runPlanCreate(repoRoot, planId, titleParts.join(" "));
+        return;
+    }
+    if (subcommand === "complete") {
+        const [planId, ...summaryParts] = rest;
+        if (!planId) {
+            throw new Error('usage: plan complete <plan-id> --summary "<summary>"');
+        }
+        const summary = parsePlanSummaryFlag(summaryParts);
+        if (!summary) {
+            throw new Error('usage: plan complete <plan-id> --summary "<summary>"');
+        }
+        await runPlanComplete(repoRoot, planId, { summary });
+        return;
+    }
+    if (subcommand === "check") {
+        await runPlanCheck(repoRoot);
+        return;
+    }
+    throw new Error("usage: plan <list|create|complete|check> ...");
+}
+async function runHandoffCommand(repoRoot, subcommand, rest) {
+    if (subcommand === "check") {
+        await runHandoffCheck(repoRoot, rest[0]);
+        return;
+    }
+    if (subcommand === "coverage") {
+        const [taskId, ...flags] = rest;
+        if (!taskId) {
+            throw new Error("usage: handoff coverage <taskId> [--json|--markdown]");
+        }
+        process.exitCode = await runCoverageAudit(repoRoot, taskId, {
+            json: flags.includes("--json"),
+            markdown: flags.includes("--markdown"),
+        });
+        return;
+    }
+    throw new Error("usage: handoff <check|coverage> [taskId]");
+}
+async function runReferenceCommand(repoRoot, subcommand, rest) {
+    if (subcommand === "index") {
+        const [taskId] = rest;
+        if (!taskId)
+            throw new Error("usage: reference index <task-id>");
+        await runReferenceIndex(repoRoot, taskId);
+        return;
+    }
+    throw new Error("usage: reference <index> <task-id>");
+}
 async function runDagAction(repoRoot, subcommand, rest) {
     const args = compactArgs(rest);
     switch (subcommand) {
@@ -439,6 +456,8 @@ function configureRunDag(command) {
         .option("--dry-run", "validate and plan without executing")
         .option("--max-concurrent <n>", "maximum concurrent nodes")
         .option("--run-id <id>", "run id")
+        .option("--quiet", "disable run/node progress on stderr")
+        .option("--progress-interval-ms <n>", "stderr heartbeat interval in milliseconds (minimum 1000)")
         .option("--canvas-path <path>", "absolute canvas output path")
         .option("--canvas <name>", "canvas name")
         .option("--canvases-dir <dir>", "canvas output directory")
@@ -617,7 +636,8 @@ export function buildLoopAgentProgram(options) {
                 .option("--json", "print JSON")
                 .option("--markdown", "print Markdown")
                 .option("--bootstrap-surface", "write an inferred .harness/init-surface.json baseline")
-                .option("--apply-safe", "apply deterministic safe init updates");
+                .option("--apply-safe", "apply deterministic safe init updates")
+                .option("--client-recovery <mode>", "auto|project|user|off — OpenCode project plugin and optional Pi user retry config", "auto");
             command.action(async (args, _options, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
             addStandaloneSubcommands(command, entry.subcommands ?? [], (args, actionCommand) => runInitCommand(args, actionCommand, options.defaultRepoRoot));
             program.addCommand(command);