@tea-agent/loop-agent 0.39.0-beta.0 → 0.39.0-beta.10

package/README.md

@@ -47,12 +47,14 @@ npm install -g @tea-agent/loop-agent@0.37.5          # 精确、可复现
 
 ```bash
 loop-agent init instructions --repo-root .
-loop-agent init --repo-root . --profile full --merge
+loop-agent init model-catalog --repo-root . --json
+loop-agent init --repo-root . --profile full --merge \
+  --low-model <provider/model> --med-model <provider/model> --high-model <provider/model>
 loop-agent init doctor --repo-root .
 loop-agent inspect --repo-root .
 ```
 
-初始化会保留已有用户内容，并补充 `AGENTS.md`、`harness.json`、`ai_workspace/loop-agent/`、`.agents/skills/`、`.harness/` 和验证脚本等治理入口。
+`init model-catalog` 会通过 Pi runtime 与 OpenCode 的非 verbose 列表发现本机可用模型，只输出白名单模型元数据、Pi setup 状态和 provider 凭据就绪状态，不输出原始配置或凭据。已有 LOW/MED/HIGH 只要仍存在于 Pi 就保持不变；只有已移除或缺失的档位才由模型结合项目、能力、成本和上下文窗口重选。如果 Pi 没有模型定义，初始化模型会先向用户补齐 provider/model、API/base URL、上下文窗口、最大输出等无法推断的信息并协助配置；如果只是凭据缺失，则保留 harness 选择并修复认证。初始化会保留已有用户内容，并补充 `AGENTS.md`、`harness.json`、`ai_workspace/loop-agent/`、`.agents/skills/`、`.harness/` 和验证脚本等治理入口。
 
 控制器升级后，旧项目可能仍使用过期的 repo-local skills、模板、managed blocks 和治理说明。普通安全仓库命令结束时会自动检测目标项目是否需要对齐：非 TTY 只向 stderr 输出提示且不写入目标；TTY 且无 human decisions、无活跃 DAG/Worker 时，可经明确 `y/yes` 同意后应用 deterministic safe actions；也可手动运行统一入口：
 
@@ -66,11 +68,11 @@ loop-agent init reconcile --repo-root .
 
 ```bash
 loop-agent init upgrade --repo-root . --json
-# controller 返回单文件 merge task 后：
+# controller 返回当前单文件 merge task 后（其余任务已在同一次计划中排队）：
 loop-agent init upgrade --repo-root . --run-id <run-id> --continue --json
 ```
 
-它在 `.harness/init-upgrades/<run-id>/` 保存身份、扫描、动作收据、合并任务、验证与报告；`--status` / `--report` 只读。默认管理项目 `.opencode/plugins/`、`.pi/extensions/` 和 `.pi/settings.json`，不会默认写 `~/.pi/agent/settings.json`。旧项目首次执行后需 reload 宿主会话，以加载更新后的 AGENTS、skills 与 recovery 产物。明确「检查初始化更新」「只检查，不要修改」仍只运行 `init check-update`。
+它在 `.harness/init-upgrades/<run-id>/` 保存身份、一次性模型目录与 surface 计划、动作收据、合并队列、验证与报告。固定投影文件按 recorded ownership 确定性新增、更新或安全删除；用户改过的文件和项目自适应内容才进入模型合并。多个合并仍逐文件限制 `allowedPaths`，但接受后直接激活下一项，不重复版本发现和全量规划；全部处理完只执行一次最终验证。`harness.json` 按属性结构新增/删除字段并保留项目值，同时同步 schema。已完成的 `--status` / `--report` 只读取控制器哈希锚定的证据，不重新执行项目脚本。默认管理项目 `.opencode/plugins/`、`.pi/extensions/` 和 `.pi/settings.json`，不会默认写 `~/.pi/agent/settings.json`。旧项目首次执行后需 reload 宿主会话。明确「检查初始化更新」「只检查，不要修改」仍只运行 `init check-update`。
 
 完整说明见[初始化目标项目](website/docs/quick-start/init-target-project.md)。
 
@@ -114,7 +116,7 @@ loop-agent dag report --run-id <run-id>
 | --- | --- | --- |
 | 受治理 CLI | `loop-agent …` / `agent-worker …` | 权威写入与诊断 |
 | Loop Operator Console | `agent-worker console` | Official 本地控制面（默认 repo=当前目录、`127.0.0.1:8790`，含 Operate 与 Inspect） |
-| Inspect（只读） | `agent-worker console` → `/inspect/`；`observe snapshot` | 统一 Console 内只读检视；`observe serve` 已下线（REMOVED / exit 2） |
+| Inspect（只读） | `agent-worker console` → `/inspect/`；`observe snapshot` | 统一 Console 内只读检视；`observe serve` 已下线（REMOVED / exit 2）。实验例外：节点 inspector 默认显示失败节点「提示词重启」tab；紧急回退可设置 `HARNESS_DAG_RERUN_PROMPT_OVERRIDE=0`（也接受 `false` / `off`），关闭后不注入任何 mutation token |
 
 ```bash
 # 终端 A：Console（任务/运行操作面；canonical mutation 只经 sibling loop-agent）
@@ -124,6 +126,8 @@ agent-worker console doctor --repo .
 
 ```
 
+裸 `agent-worker console` 不在终端询问升级。Operate 右上角提供非阻塞的更新入口，默认选择 npm `latest` 稳定版，也可由操作者显式选择 `next` 预发布版；更新前会先检查活跃运行和全局安装来源。`console doctor`、帮助和版本命令均不触发更新检查。
+
 访问 Console <http://127.0.0.1:8790/>；**Operator Chat Official** 是 Console 内的主引导交互，默认打开「对话」工作区。构建时设置 `VITE_OPERATOR_CHAT_DEFAULT_LANDING=tasks` 可改回 Tasks；URL hash（`#/tasks`）与 localStorage 仍优先于默认值。顶部「检视」以及 `/inspect/` 提供只读 Dashboard、DAG、时间线与 artifacts；`loop-agent …` / `agent-worker …` CLI direct path 仍是受治理 fallback。当前状态为 **code ready, dogfood pending/unmet**，不宣称已替代 openCode 或其他外部主会话。
 
 ## 核心边界

package/bin/loop-agent.js

@@ -18,11 +18,15 @@ if (!existsSync(cliEntry)) {
  * to silently execute a dist/ that predates the latest source edit. The
  * classic failure mode is editing src/** and running the bin without
  * `npm run build`, which executes the previous build. Suppress with
- * --ignore-stale-dist when intentionally running a stale build.
+ * --ignore-stale-dist (or LOOP_AGENT_IGNORE_STALE_DIST=1, which sibling
+ * processes such as a Console-spawned CLI inherit automatically) when
+ * intentionally running a stale build.
  */
 const srcDir = join(packageRoot, "src");
-const ignoreStale = process.argv.includes("--ignore-stale-dist");
-if (ignoreStale) {
+const ignoreStale =
+  process.argv.includes("--ignore-stale-dist") ||
+  process.env.LOOP_AGENT_IGNORE_STALE_DIST === "1";
+if (process.argv.includes("--ignore-stale-dist")) {
   process.argv = process.argv.filter((arg) => arg !== "--ignore-stale-dist");
 }
 if (!ignoreStale && existsSync(srcDir)) {

package/dist/application/task-lifecycle/advance.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { createTask, getTaskPaths, loadTaskConfig, } from "../../task/runtime.js";
 import { importPrdDocument } from "../../task/source-references.js";
 import { prepareTaskSource } from "../../task/source-prepare/index.js";
+import { resolveProductionSourceFidelityPi } from "../../task/source-prepare/source-fidelity-pi.js";
 import { isIntakeSoftGapCode, resolvePrdImportRole, } from "../../task/source-prepare/artifact-meta.js";
 import { sanitizeDraftPlaceholders } from "../../task/source-prepare/placeholder-paths.js";
 import { evaluateSemanticIntakeEligibility, isSemanticIntakeDisabled, readSemanticIntakeAttempted, runSemanticIntake, } from "../../task/source-prepare/semantic-intake.js";
@@ -585,6 +586,15 @@ export async function advanceTaskLifecycle(input) {
             continue;
         }
         if (action.type === "prepare-contract") {
+            // 生产 source fidelity Pi 接线（AC-PROD-001/005）：仅 frontend-implementation
+            // 任务注入 reconcile executor + 独立 reviewer；ineligible 返回 undefined 不接线。
+            // 主路径与 semantic-intake retry 路径共用同一接线，保证任意一条生产路径都实际
+            // 触发 reconciliation executor（修复前两处均缺省导致生产路径从不调用 Pi）。
+            const sourceFidelity = await resolveProductionSourceFidelityPi({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                taskKind: input.taskKind,
+            });
             let draftIntent = null;
             if (input.fromDraftPath) {
                 try {
@@ -635,6 +645,7 @@ export async function advanceTaskLifecycle(input) {
                     verifyCommands: effectiveInput.verifyCommands,
                     backendTest: input.backendTest,
                 },
+                ...(sourceFidelity ? { sourceFidelity } : {}),
             });
             if (!prepareResult.ok) {
                 const gapCodes = (prepareResult.gaps ?? [])
@@ -712,6 +723,7 @@ export async function advanceTaskLifecycle(input) {
                                     verifyCommands: effectiveInput.verifyCommands,
                                     backendTest: input.backendTest,
                                 },
+                                ...(sourceFidelity ? { sourceFidelity } : {}),
                             });
                             if (retry.ok) {
                                 warnings.push({

package/dist/application/task-lifecycle/recommendations.js

@@ -42,6 +42,7 @@ export async function buildTaskLifecycleRecommendations(input) {
     const allowedPaths = [];
     const verifyCommands = [];
     // 1) managed task config
+    let hasDeclaredManagedVerify = false;
     try {
         const config = await loadTaskConfig(input.repoRoot, input.taskId);
         for (const glob of config.allowedPaths ?? []) {
@@ -53,7 +54,9 @@ export async function buildTaskLifecycleRecommendations(input) {
                 source: "managed-task-config",
             });
         }
-        for (const cmd of config.verifyCommands ?? []) {
+        const managedVerify = (config.verifyCommands ?? []).filter((cmd) => Boolean(cmd.command?.trim()));
+        hasDeclaredManagedVerify = managedVerify.length > 0;
+        for (const cmd of managedVerify) {
             const label = cmd.label?.trim() || "verify";
             const command = cmd.command?.trim();
             if (!command)
@@ -70,14 +73,22 @@ export async function buildTaskLifecycleRecommendations(input) {
         // task may not exist yet
     }
     // 2) package.json scripts (only if not already covered by managed config)
+    // The full-suite `test` script is recommended only when the task declares
+    // NO managed verifyCommands at all. Once a task configures a targeted
+    // verify set (e.g. per-change typecheck + a scoped vitest run), the full
+    // `npm run test` must never be auto-added: it validates the whole repo,
+    // costs far more than the change under review, and can fail on unrelated
+    // pre-existing breakage, turning a targeted verify green into a hard fail.
     const scripts = await readPackageScripts(input.repoRoot);
     const hasVerifyLabel = (label) => verifyCommands.some((entry) => entry.label === label);
     const scriptCandidates = [
         { label: "typecheck", script: "typecheck" },
-        { label: "test", script: "test" },
         { label: "check-repo", script: "check:repo" },
         { label: "check-repo", script: "check-repo" },
     ];
+    if (!hasDeclaredManagedVerify) {
+        scriptCandidates.push({ label: "test", script: "test" });
+    }
     for (const candidate of scriptCandidates) {
         const scriptBody = scripts[candidate.script];
         if (!scriptBody)

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.39.0-beta.0",
-  "gitSha": "cf0cf7e8e996da8d1c727ccc7cb8f4c52f8d5319",
-  "builtAt": "2026-08-21T03:47:18.913Z"
+  "version": "0.39.0-beta.10",
+  "gitSha": "f6ea22730a28e6556983394e41560c0d8d18a852",
+  "builtAt": "2026-08-27T07:03:53.753Z"
 }

package/dist/cli/command-definitions.js

@@ -7,6 +7,7 @@ import { runCoverageReport } from "../commands/coverage-report.js";
 import { runExamples } from "../commands/examples.js";
 import { runHandoffCheck } from "../commands/handoff-check.js";
 import { runInspect } from "../commands/inspect.js";
+import { runInspectNext } from "../commands/inspect-next.js";
 import { runInstructions } from "../commands/instructions.js";
 import { runTaskAdvance } from "../commands/task-advance.js";
 import { runTaskStatus } from "../commands/task-status.js";
@@ -34,6 +35,7 @@ import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
+import { runDagFollowUp } from "../commands/dag-follow-up.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagResume } from "../commands/dag-resume.js";
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
@@ -74,6 +76,7 @@ export function parseSummaryFlag(tokens) {
 const DOCS_SUBCOMMANDS = ["audit", "archive"];
 const INIT_SUBCOMMANDS = [
     "instructions",
+    "model-catalog",
     "doctor",
     "check-update",
     "update",
@@ -133,6 +136,7 @@ const DAG_SUBCOMMANDS = [
     "request-interrupt",
     "rerun",
     "rerun-task",
+    "follow-up",
     "reconcile-tasks",
     "final-verification",
     "decision",
@@ -162,10 +166,19 @@ export const COMMAND_DEFINITIONS = [
         name: "inspect",
         adapter: "required",
         tier: "operator",
-        intent: "Inspect the target repo harness manifest.",
-        usage: "inspect",
-        handler: async ({ adapter, repoRoot }) => {
-            await runInspect(adapter, repoRoot);
+        intent: "Inspect the target repo harness manifest, or report the current npm next binding.",
+        usage: "inspect | inspect next [--json]",
+        subcommands: ["next"],
+        handler: async ({ adapter, repoRoot, subcommand, rest }) => {
+            if (subcommand === "next") {
+                await runInspectNext(repoRoot, rest.filter((arg) => Boolean(arg)));
+                return;
+            }
+            if (subcommand === undefined || subcommand.startsWith("-")) {
+                await runInspect(adapter, repoRoot);
+                return;
+            }
+            throw new Error("usage: inspect | inspect next [--json]");
         },
     },
     {
@@ -205,7 +218,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|upgrade] [--profile full|minimal] [--merge] [--json|--markdown] [--bootstrap-surface|--apply-safe] [--client-recovery=auto|project|user|off] [--run-id <id> --status|--continue|--report]",
+        usage: "init [instructions|model-catalog|doctor|check-update|update|reconcile|upgrade] [--profile full|minimal] [--merge] [--model provider/model | --low-model provider/model --med-model provider/model --high-model provider/model] [--json|--markdown] [--bootstrap-surface|--apply-safe] [--client-recovery=auto|project|user|off] [--run-id <id> --status|--continue|--report]",
         subcommands: [...INIT_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runInit(repoRoot, [subcommand, ...rest].filter(Boolean), { readRuntimeActivity: readInitRuntimeActivity });
@@ -566,6 +579,11 @@ export const COMMAND_DEFINITIONS = [
                 await runDagRerunTask(repoRoot, rerunTaskArgs);
                 return;
             }
+            if (subcommand === "follow-up") {
+                const followUpArgs = rest.filter((arg) => Boolean(arg));
+                await runDagFollowUp(repoRoot, followUpArgs);
+                return;
+            }
             if (subcommand === "reconcile-tasks") {
                 const reconcileArgs = rest.filter((arg) => Boolean(arg));
                 await runDagReconcileTasks(repoRoot, reconcileArgs);

package/dist/cli/program.js

@@ -13,6 +13,7 @@ import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagRequestInterrupt } from "../commands/dag-request-interrupt.js";
 import { runDagRerunTask } from "../commands/dag-rerun-task.js";
+import { runDagFollowUp } from "../commands/dag-follow-up.js";
 import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
@@ -33,6 +34,7 @@ import { runHarvest } from "../commands/harvest.js";
 import { runInit } from "../commands/init.js";
 import { readInitRuntimeActivity } from "./update/runtime-activity.js";
 import { runInspect } from "../commands/inspect.js";
+import { runInspectNext } from "../commands/inspect-next.js";
 import { runInstructions } from "../commands/instructions.js";
 import { runKnowledge } from "../commands/knowledge.js";
 import { runLoop } from "../commands/loop.js";
@@ -97,6 +99,9 @@ async function dispatchRegisteredCommand(commandObject, defaultRepoRoot, rawArgs
         [...rest, ...rawArgs].some((token) => token === "--json")) ||
         (command === "stats" &&
             subcommand === "context" &&
+            [...rest, ...rawArgs].some((token) => token === "--json")) ||
+        (command === "inspect" &&
+            subcommand === "next" &&
             [...rest, ...rawArgs].some((token) => token === "--json"));
     const repoRoot = resolveRepoRootOnly(commandObject, defaultRepoRoot, {
         quiet,
@@ -125,8 +130,15 @@ async function runTaskCommand(repoRoot, subcommand, rest) {
 async function runCommanderAction(ctx, command, subcommand, rest) {
     switch (command) {
         case "inspect":
-            await runInspect(ctx.adapter, ctx.repoRoot);
-            return;
+            if (subcommand === "next") {
+                await runInspectNext(ctx.repoRoot, rest);
+                return;
+            }
+            if (subcommand === undefined || subcommand.startsWith("-")) {
+                await runInspect(ctx.adapter, ctx.repoRoot);
+                return;
+            }
+            throw new Error("usage: inspect | inspect next [--json]");
         case "doctor":
             await runDoctor(ctx.adapter, ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
@@ -341,6 +353,9 @@ async function runDagAction(repoRoot, subcommand, rest) {
         case "rerun-task":
             await runDagRerunTask(repoRoot, args);
             return;
+        case "follow-up":
+            await runDagFollowUp(repoRoot, args);
+            return;
         case "reconcile-tasks":
             await runDagReconcileTasks(repoRoot, args);
             return;
@@ -500,6 +515,7 @@ function addDagCommand(program, defaultRepoRoot) {
         "request-interrupt",
         "rerun",
         "rerun-task",
+        "follow-up",
         "reconcile-tasks",
         "final-verification",
     ], defaultRepoRoot);
@@ -595,6 +611,9 @@ export function buildLoopAgentProgram(options) {
                 .option("--no-merge", "skip existing files")
                 .option("--provider <provider>", "provider paired with a bare --model (otherwise use provider/model)")
                 .option("--model <model>", "qualified provider/model, or a bare model paired with --provider")
+                .option("--low-model <provider/model>", "credential-ready Pi model for LOW")
+                .option("--med-model <provider/model>", "credential-ready Pi model for MED")
+                .option("--high-model <provider/model>", "credential-ready Pi model for HIGH")
                 .option("--json", "print JSON")
                 .option("--markdown", "print Markdown")
                 .option("--bootstrap-surface", "write an inferred .harness/init-surface.json baseline")

package/dist/cli/update/notifier.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { evaluateLatestVersion, shouldCheckForUpdates } from "./policy.js";
-import { acquireUpdateLock, readUpdateState, updateLockPath, updateStatePath, writeUpdateState, } from "./state.js";
+import { acquireUpdateLock, readUpdateState, updateLockPath, updateStatePath, writeUpdateState, } from "../../shared/update/state.js";
 const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const FAILURE_COOLDOWN_MS = 10 * 60 * 1000;
 export async function runSelfUpdateNotifier(options) {
@@ -69,7 +69,7 @@ export async function runSelfUpdateNotifier(options) {
             }
             writeStderr(`loop-agent 已更新到 ${decision.targetVersion}；新版本将在下一次调用时生效。\n`);
             await safeWriteState(statePath, {
-                schemaVersion: 1,
+                ...state,
                 lastCheckedAt: now().toISOString(),
                 latestVersion: decision.targetVersion,
             });

package/dist/cli/update/runtime-activity.js

@@ -1,29 +1 @@
-import { readdir } from "node:fs/promises";
-import path from "node:path";
-import { buildGlobalSnapshot } from "../../worker/observability/read-model.js";
-/**
- * Read-only runtime guard for init-surface writes.
- *
- * DAG activeness is anchored to real directories in the canonical active
- * lifecycle root. Worker activeness reuses the Observe read model so Task Pool
- * status precedence and composite identity stay owned by the Worker adapter.
- * Projection failures block writes because liveness cannot be proven safely.
- */
-export async function readInitRuntimeActivity(repoRoot) {
-    const resolvedRoot = path.resolve(repoRoot);
-    const activeDagRoot = path.join(resolvedRoot, ".harness", "dag-runs", "active");
-    const entries = await readdir(activeDagRoot, { withFileTypes: true }).catch(() => []);
-    const activeDagRunIds = entries
-        .filter((entry) => entry.isDirectory() && entry.name !== ".gitkeep")
-        .map((entry) => entry.name)
-        .sort();
-    const snapshot = await buildGlobalSnapshot({ repoRoot: resolvedRoot });
-    return {
-        activeDagRunIds,
-        activeWorkerBatches: snapshot.health.worker.activeBatches,
-        activeWorkerTasks: snapshot.health.worker.activeTasks,
-        ...(snapshot.projectionError
-            ? { workerProjectionError: snapshot.projectionError.message }
-            : {}),
-    };
-}
+export { readInitRuntimeActivity } from "../../worker/observability/init-runtime-activity.js";

package/dist/cli.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildLoopAgentProgram } from "./cli/program.js";
-import { createNpmUpdateClient } from "./cli/update/npm-client.js";
+import { createNpmUpdateClient } from "./shared/update/npm-client.js";
 import { runSelfUpdateNotifier } from "./cli/update/notifier.js";
 import { resolveInitSurfaceRepoRoot, runInitSurfaceNotifier, } from "./cli/update/init-surface-notifier.js";
 async function main() {
@@ -29,6 +29,7 @@ async function main() {
         client: createNpmUpdateClient({
             currentVersion,
             packageRoot,
+            cwd: defaultRepoRoot,
             env: process.env,
         }),
     });

package/dist/commands/client-recovery.js

@@ -1356,12 +1356,15 @@ export async function runClientRecovery(input) {
     }
     const plugin = await installProjectOpenCodePlugin({
         repoRoot: input.repoRoot,
+        onlyIfMissing: true,
     });
     const overflowPlugin = await installProjectOpenCodeOverflowCompactPlugin({
         repoRoot: input.repoRoot,
+        onlyIfMissing: true,
     });
     const piExtension = await installProjectPiContextOverflowExtension({
         repoRoot: input.repoRoot,
+        onlyIfMissing: true,
     });
     const pi = await applyProjectPiSettingsMerge({ repoRoot: input.repoRoot });
     if (mode !== "user") {

package/dist/commands/dag-follow-up.js

@@ -0,0 +1,138 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { FRONTEND_REVIEW_FINDINGS_PRD_REL, readFrontendReviewFindingsPrd, } from "../workflows/dag/frontend-review-findings.js";
+import { locateDagRun } from "../workflows/dag/lifecycle.js";
+import { createTask, getTaskPaths } from "../task/runtime.js";
+import { importPrdDocument } from "../task/source-references.js";
+function parseFlagValue(rawArgs, flag) {
+    const index = rawArgs.indexOf(flag);
+    if (index < 0 || index + 1 >= rawArgs.length)
+        return undefined;
+    return rawArgs[index + 1];
+}
+export function parseDagFollowUpArgs(rawArgs) {
+    const positional = rawArgs.filter((arg) => !arg.startsWith("-"));
+    const parentRunId = positional[0];
+    if (!parentRunId) {
+        throw new Error("usage: dag follow-up <parent-run-id> [--task-id <id>] [--execute] [--profile <profile>]");
+    }
+    return {
+        parentRunId,
+        taskId: parseFlagValue(rawArgs, "--task-id"),
+        execute: rawArgs.includes("--execute"),
+        profile: parseFlagValue(rawArgs, "--profile"),
+    };
+}
+export function deriveFollowUpTaskId(parentRunId) {
+    // Deterministic, valid task id derived from the parent run id.
+    return `${parentRunId}-followup`;
+}
+/** CLI entry: parse raw args and run the follow-up flow. */
+export async function runDagFollowUp(repoRoot, rawArgs) {
+    const parsed = parseDagFollowUpArgs(rawArgs);
+    const result = await runDagFollowUpInternal(repoRoot, parsed.parentRunId, {
+        taskId: parsed.taskId,
+        execute: parsed.execute,
+        profile: parsed.profile,
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+        process.exitCode = result.mode === "blocked" ? 2 : 1;
+    }
+}
+export async function runDagFollowUpInternal(repoRoot, parentRunId, options = {}) {
+    const located = await locateDagRun(repoRoot, parentRunId);
+    if (!located) {
+        return {
+            ok: false,
+            mode: "invalid",
+            reason: `dag run not found: ${parentRunId}`,
+        };
+    }
+    const prd = await readFrontendReviewFindingsPrd(located.runDir);
+    if (!prd) {
+        return {
+            ok: false,
+            mode: "invalid",
+            reason: `no frontend review findings PRD found in run ${parentRunId} (${FRONTEND_REVIEW_FINDINGS_PRD_REL}); the review must have committed request_review_changes`,
+        };
+    }
+    const taskId = options.taskId ?? deriveFollowUpTaskId(parentRunId);
+    try {
+        await createTask(repoRoot, taskId, `修复 review 发现（parent ${parentRunId}）`);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            mode: "blocked",
+            reason: `failed to create task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    // Materialize the PRD draft into the task's source directory so the task
+    // lifecycle can import it as its requirement.
+    const prdMaterialized = path.join(getTaskPaths(repoRoot, taskId).sourceDir, "review-findings-prd.md");
+    try {
+        await mkdir(path.dirname(prdMaterialized), { recursive: true });
+        await importPrdDocument({
+            repoRoot,
+            taskId,
+            filePath: path.join(located.runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL),
+            name: "review-findings-prd",
+        });
+    }
+    catch (error) {
+        return {
+            ok: false,
+            mode: "blocked",
+            reason: `failed to import PRD into task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (!options.execute) {
+        return {
+            ok: true,
+            mode: "created",
+            taskId,
+            prdPath: prdMaterialized,
+            next: {
+                kind: "advance",
+                command: `loop-agent task advance ${taskId} --task-kind frontend-implementation --json`,
+            },
+        };
+    }
+    // Execute: advance through the frontend DAG.
+    const { advanceTaskLifecycle } = await import("../application/task-lifecycle/advance.js");
+    const profile = options.profile === "auto" ||
+        options.profile === "minimal" ||
+        options.profile === "standard" ||
+        options.profile === "reviewed" ||
+        options.profile === "supervised"
+        ? options.profile
+        : undefined;
+    const result = await advanceTaskLifecycle({
+        repoRoot,
+        taskId,
+        taskKind: "frontend-implementation",
+        taskKindExplicit: true,
+        ...(profile ? { profile, profileExplicit: true } : {}),
+        observer: undefined,
+    });
+    const ok = result.lifecycleState === "run-succeeded" ||
+        result.lifecycleState === "awaiting-write-set-approval";
+    return {
+        ok,
+        mode: ok ? "created" : "blocked",
+        taskId,
+        prdPath: prdMaterialized,
+        reason: ok
+            ? undefined
+            : `advance lifecycleState: ${result.lifecycleState}${result.blockers.length > 0
+                ? `; blockers: ${result.blockers.map((b) => b.code).join(", ")}`
+                : ""}`,
+        next: ok
+            ? undefined
+            : {
+                kind: "advance",
+                command: `loop-agent task advance ${taskId} --task-kind frontend-implementation --json`,
+            },
+    };
+}

package/dist/commands/dag-rerun.js

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import { isDagRerunPromptOverrideEnabled } from "../shared/dag-prompt-override.js";
 import { executeDagRerun, planDagRerun, } from "../workflows/dag/rerun-run.js";
 export function parseDagRerunArgs(args) {
     if (args.length === 0) {
@@ -9,6 +11,8 @@ export function parseDagRerunArgs(args) {
     let planHash;
     let requestId;
     let reason;
+    const promptOverrideSpecs = [];
+    const promptOverrideAppendSpecs = [];
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--run-id")
@@ -33,6 +37,14 @@ export function parseDagRerunArgs(args) {
             reason = args[++index];
         else if (arg.startsWith("--reason="))
             reason = arg.slice("--reason=".length);
+        else if (arg === "--prompt-override")
+            promptOverrideSpecs.push(args[++index] ?? "");
+        else if (arg.startsWith("--prompt-override="))
+            promptOverrideSpecs.push(arg.slice("--prompt-override=".length));
+        else if (arg === "--prompt-override-append")
+            promptOverrideAppendSpecs.push(args[++index] ?? "");
+        else if (arg.startsWith("--prompt-override-append="))
+            promptOverrideAppendSpecs.push(arg.slice("--prompt-override-append=".length));
         else if (arg === "--json")
             continue;
         else if (arg.startsWith("-"))
@@ -50,7 +62,13 @@ export function parseDagRerunArgs(args) {
         if (planHash || requestId || reason) {
             throw new Error("dag rerun --plan cannot be combined with execute flags");
         }
-        return { parentRunId, selectedNodeId, planOnly: true };
+        return {
+            parentRunId,
+            selectedNodeId,
+            planOnly: true,
+            promptOverrideSpecs,
+            promptOverrideAppendSpecs,
+        };
     }
     if (!planHash?.trim()) {
         throw new Error("dag rerun execute requires --plan-hash <hash>");
@@ -68,15 +86,50 @@ export function parseDagRerunArgs(args) {
         planHash: planHash.trim(),
         requestId: requestId.trim(),
         reason: reason.trim(),
+        promptOverrideSpecs,
+        promptOverrideAppendSpecs,
     };
 }
+async function loadPromptOverrides(specs, mode) {
+    const overrides = [];
+    for (const spec of specs) {
+        const separator = spec.indexOf("@");
+        if (separator <= 0 || separator >= spec.length - 1) {
+            throw new Error(`dag rerun --prompt-override${mode === "append" ? "-append" : ""} expects <nodeId>@<filePath>, got: ${spec}`);
+        }
+        const nodeId = spec.slice(0, separator);
+        const filePath = spec.slice(separator + 1);
+        let prompt;
+        try {
+            prompt = await readFile(filePath, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`cannot read prompt override file for node ${nodeId} (${filePath}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+        overrides.push(mode === "append" ? { nodeId, prompt, mode } : { nodeId, prompt });
+    }
+    return overrides;
+}
 export async function runDagRerun(repoRoot, rawArgs) {
     const parsed = parseDagRerunArgs(rawArgs);
+    let promptOverrides;
+    const hasOverrides = parsed.promptOverrideSpecs.length > 0 ||
+        parsed.promptOverrideAppendSpecs.length > 0;
+    if (hasOverrides) {
+        if (!isDagRerunPromptOverrideEnabled()) {
+            throw new Error("prompt override rerun is disabled by HARNESS_DAG_RERUN_PROMPT_OVERRIDE; unset it or use a value other than 0, false, or off to enable this experimental capability");
+        }
+        promptOverrides = [
+            ...(await loadPromptOverrides(parsed.promptOverrideSpecs, "replace")),
+            ...(await loadPromptOverrides(parsed.promptOverrideAppendSpecs, "append")),
+        ];
+    }
     if (parsed.planOnly) {
         const plan = await planDagRerun({
             cwd: repoRoot,
             parentRunId: parsed.parentRunId,
             selectedNodeId: parsed.selectedNodeId,
+            promptOverrides,
         });
         const result = {
             ok: plan.eligible,
@@ -95,6 +148,7 @@ export async function runDagRerun(repoRoot, rawArgs) {
         planHash: parsed.planHash,
         requestId: parsed.requestId,
         reason: parsed.reason,
+        promptOverrides,
     });
     console.log(JSON.stringify(result, null, 2));
     if (!result.ok) {