@tea-agent/loop-agent 0.25.3 → 0.25.4

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [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
 
 ### 重点更新

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

@@ -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")