@tea-agent/loop-agent 0.40.0-next.12 → 0.40.0-next.14

package/CHANGELOG.md

@@ -2,14 +2,21 @@
 
 ## [Unreleased]
 
+- Operator Chat 输入框下方的「调用记录」入口现在会常驻显示；没有记录时显示为 0，发送消息或刷新运行状态时不再突然消失。
+- 初始化选择模型时现在能识别公司内部 `wizard-local` 的 AICoder 型号梯度：`aicoder-default`、`aicoder-plus`、`aicoder-pro`、`aicoder-max` 从左到右能力逐级增强；它会作为选择 LOW/MED/HIGH 的参考，但不会忽略成本和项目需求机械分档。
+- 修复 Operator Chat 左侧栏工作区名称过长时遮挡悬浮「更多」「新建对话」按钮的问题：工作区行改为 flex 行布局，名称过长时单行省略，操作按钮改为行尾占位显示，悬浮背景整行连续无断层。
 - 修复 Console 轨迹视图引用未声明 CSS 自定义属性导致仓库发布门禁失败的问题，补齐品牌色、警告色与字体别名并保持现有视觉回退值。
 
 ### 重点更新
 
+- Console 设置页新增「Pi 插件」区块：内置一份经 npm 校验的插件目录（6303 个，仅展示 5562 个可安装、含中文说明），支持搜索、每页条数（10/20/50/100）、分页、一键安装/卸载（调用 `pi install/remove`，全局 `~/.pi/agent`），安装/卸载带进度过渡与结果提示。
+- CLI 命令 `--help` 现在直接显示真实 usage（此前 raw-args 命令只在解析出错时才抛 usage）：`task advance` / `task status` / `task source prepare` 与 `dag resume|doctor|report|reconcile-run|rerun|rerun-task|reject|approve|status` 的 `--help` 顶部即列出完整参数契约，`task advance` 并附 `--verify "label:command"` 示例；`init` 提示补全局 `--repo-root <path>`（置于子命令前）约定。
+- `task source prepare`（确定性任务源投影，managed 需求.md/执行约束.md）从死代码转正：此前 `TASK_SUBCOMMANDS` 缺少 `source` 导致命令不可达，现 `task source prepare <task-id> --from-text/--from-file/--from-stdin/--from-draft --dry-run|--apply` 可直接调用。
 - Console 对话页「轨迹」视图响应式优化：轨迹列宽跟随面板实际宽度收缩（`.oc-trajectory` 加 `width:100%`、`.oc-trajectory-turn/.step` 加 `min-width:0` 修 flex 收缩链），窄窗口（≤720px）自动隐藏耗时列，避免工具行被固定项挤爆。
 - Console 对话页新增「轨迹」视图（详情侧栏 tab）：仿 DSH ui-trajectory，用本仓库 turnGroups 数据把对话按「用户 → 过程 → AI 回复」渲染成统一单元格列表，每行带 kind 标签 + 图标（用户/ AI / 思考 / 工具 / 活动 / 错误 / 压缩）；用户与 AI 用标签颜色 + 图标区分，AI 中间文本也标注；思考、工具、以及超长用户/AI 消息默认单行截断、可展开/收起看全文（含工具参数与结果、状态与耗时）。支持一键「导出 HTML」自包含文件（长内容用 `<details>` 折叠，短内容内联）。主会话思考块标签由英文 Think 改为「思考」。
 - DAG 检查器节点「执行过程」的「导出 HTML」改为复用页面真实渲染与样式，导出的独立 HTML 排版与页面一致；Pi 会话节点导出会带上原始协议事件，左上角提供「展开/隐藏原始协议事件」按钮（默认隐藏，每项仍可单独展开），shell/静态节点导出同样与页面一致。
 - backend-test 的 pytest repair 现在继续使用 run-owned plan，不再搜索测试目录 README；correspondence finding 会直接指向 docstring、参数 ID、符号、脚本或 payload 的修复位置，collection/scenario repair 与 generated-local Python 写边界保持一致，并在单次 Pi 会话达到 24 轮或 80K 最大 usage snapshot 前受控返回 partial failure。
+- Operator Chat 新增持续目标模式：可以用 `/goal` 或输入框上方的目标条创建跨多个回合推进的目标，并随时暂停、继续、编辑或清除；刷新后仍能看到目标，但重启 Console 后不会未经确认自行续跑。
 - Operator Chat 现在可以在同一个页面管理多个工作区；每个会话始终使用创建它的工作区，切换对话时地址栏保持简洁稳定。
 - 对话消息流整体调整为更紧凑、清晰的布局，思考过程、工具执行、阶段性结果和最终回答会按真实发生顺序展示。
 - 上下文过大时会自动压缩并继续原请求，消息流会依次展示触发原因、压缩进度和压缩结果；手动压缩也使用同一套展示方式。
@@ -18,6 +25,7 @@
 
 ### 新增
 
+- 模型可以读取、创建和更新当前会话的持续目标；长任务会在安全轮数内自动续行，优先处理用户排队消息，并在 DAG 或其他运行结束后再继续。上下文压缩后，当前目标也会自动回到模型上下文中。
 - 右侧辅助栏统一承载文件、上下文、调用记录、运行活动和当前 DAG；点击消息流中的运行状态即可在同一侧栏查看运行、门禁与产物，并可自由调整侧栏宽度。
 - 新增任务清单与结构化提问卡片，让长任务的进度和需要用户选择的内容更容易理解。
 - 「对话 / 操作 / 观测」使用统一导航；操作和观测页面可以切换工作区查看对应数据。
@@ -29,14 +37,23 @@
 - `@agent-context/sift@0.0.1-alpha.6` 作为可选依赖接入 Console 与 DAG：默认开启，`HARNESS_CONSOLE_SIFT` / `HARNESS_DAG_SIFT` 设为 `0`、`false` 或 `off` 即可关闭。Anthropic 缺省 prompt cache 形态保持 no-op，避免破坏缓存。
 - 后端测试的计划与生成阶段只读取任务明确绑定的需求、环境报告和本轮产物，减少无关仓库内容干扰结果，并让后续步骤继续使用同一份已确认计划。
 - Operator Chat 的任务清单工具描述补齐多步骤与 DAG 使用纪律：开始前按具体步骤规划、保持进行中约束、完成后立即更新完整列表，并用面向用户的阶段呈现 DAG 进度，简单任务自动跳过。
+- 右侧文件工作台打开 `.html` 或 `.htm` 文件时默认直接预览：沙箱会完整加载页面及同项目的相对样式、图片和字体，同时阻止脚本及外部网络访问；大体积源码不再直接报错，而是展示前 512 KiB 并清晰提示内容已截断。
+- 排队消息改为由输入框上方的队列面板统一展示；正常排队、撤回和删除不再反复弹出提示，当前会话也不再显示重复的“待发送”，其他会话只保留低调的排队数量。
 - 正式发布会自动同步更新版本日志和文档站摘要；发布说明优先生成简洁自然的中文，生成服务不可用时也能安全完成发布。
 - 输入框整合模型与推理等级选择，并只展示有真实数据的轮次、耗时、速度和缓存统计。
 - 工作区、会话列表、文件标签和侧栏交互更加紧凑自然，折叠、切换和页面过渡更加流畅。
+- 左侧多个工作区可以独立展开；展开工作区不再切换当前作用域，跨工作区打开会话时也不会闪出错误的空列表。
+- 多个 Console 同时运行时会安全合并工作区增删，并把变更实时同步到已打开的页面，避免旧缓存覆盖新工作区。
 - 设置页改用自然中文展示当前工作区的模型状态，减少内部状态和重复信息。
 - DAG 检查器简化节点说明、执行记录和提示词重启面板，长内容更容易阅读和定位。
 
 ### 修复
 
+- 修复 Console「更新并初始化」被观测顶栏挡住、看起来像从 DAG 详情消失的问题：入口改到操作 → 设置，观测与对话页不再挂全局悬浮按钮。
+- 修复从恢复打开全屏观测时，长 DAG run id 把「返回 恢复」顶进居中模式开关底下、按钮显示不全的问题；上下文 chip 改到顶栏下方独立一行，过长 id 省略、按钮不收缩。
+- 修复 Console 内嵌观测后样式泄漏到对话/操作、观测顶栏丢失新鲜度与 Pi 状态、从恢复打开观测看不到「返回 恢复」、以及检查器盖住一级导航的问题；对话里的观测链接改为壳内地址。
+- 修复 Console 内嵌观测丢失「提示词重启」入口、Remixicon 图标和产品深链的问题：托管观测从 `/inspect/` 响应解析 scoped token，不把该凭据写入 Console HTML。
+- 修复 backend-test 的 Scenario Partition 虽声明 Domain/slot kinds、却未把展开后的精确 `TP-SP-*` 清单交给 Markdown writer，导致 Case 只生成普通别名 TP 并被 N6 全量判缺的问题；Plan 现在把每个 exact slot 逐字写入绑定 Coverage Matrix Rule，Markdown生成与同步节点返回前执行 exact-set 审计，普通别名和 `SINGLE`/`MULTIPLE` 不再替代 partition slots。
 - 修复 backend-test 的 Scenario Partition 计划表只提示 `each-value`/`omitted`、却由下游确定性门禁强制要求 `not-in-set` 的合同漂移；计划、Markdown Case 与 pytest 现在统一明确唯一补集槽位，避免 PI 因表格指令遗漏 `TP-<Partition ID>-NOT-IN-SET` 后触发 `MISSING_COMPLEMENT_SLOT`。
 - 修复文档审计扫描本地 `.scratch/` 临时证据与打包目录、导致仓库 preflight 和发布前验证被非治理文件阻断的问题。
 - 修复 backend-test 把 Markdown 明确声明的 enum-invalid、wrong-type、null、empty 和精确非法 custom literal 当作 payload enum 契约漂移、错误消耗唯一一次 pytest repair 的问题；豁免现在按 pytest parameter ID、目标字段和值逐 TP 绑定，positive/nominal drift 与 path 缺陷仍严格阻断。
@@ -47,10 +64,31 @@
 - 修复 backend-test 对 `resource_client.call(..., payload=...)` 一类本地 transport 的 payload AST 假阴性；readiness 新增固定分类/Case 排除汇总和 pytest 启动事实，payload repair finding 同时携带 expected/observed/missing path 清单。
 - 修复后端测试在 payload、fixture 与 Markdown→pytest 对应关系同时异常时只修复其中一类问题的问题；pytest 侧缺陷现在通过结构化 `repairFindings` 合并进入唯一一次有界 repair，Markdown Test Point 未分类或重复分类则在生成阶段定向重试并禁止下游猜修。
 - 修复重命名会话时输入框没有回显当前标题的问题。
+- 修复自动压缩提示长期停在输入框上方、恢复输出跑到压缩前面，以及回复文字在工具出现时突然跳位的问题；消息流会按顺序保留模型提供商的原始错误、压缩过程和恢复结果，刷新后也保持一致。
+- 工作区列表支持像 DSH Web 一样上下拖动调整顺序；新的顺序会自动保存，刷新页面或重新启动看板后仍然保持。
+- 修复多工作区下已有会话只显示在对话正文、却没有出现在左侧列表的问题；会话会稳定归属到创建它的工作区，旧会话也会自动恢复到列表中。
+- 会话列表改为独立的全局目录：启动时一次恢复历史归属，之后随会话变化实时更新；移除工作区不会删除或隐藏其中的会话，它们会保留在“未归类”中并可继续打开。
 - 修复停止回复后输入区恢复迟缓、排队消息偶发丢失，以及切换会话后旧状态残留的问题。
 - 修复宽表格、文件预览、滚动条和窄屏布局中的多处显示异常。
 - 修复部分 Windows 环境读取运行状态时的偶发失败，并提高前后端任务验证的可靠性。
 
+## [0.39.3] - 2026-08-28
+
+### 新增
+
+- 前端实现支持来源归属运行时注入，使用宽松校验，不符合格式也不会阻断现有流程，方便后续接入完整的来源追溯。
+
+## [0.39.2] - 2026-08-28
+
+### 重点更新
+
+- DAG 检查器与提示词重启面板重做：节点备注列改为节点用途简介不再复读节点 ID，默认隐藏协议事件、需要时可一键展开；提示词重启只读面板撑满剩余高度，内容在卡片内滚动，避免长提示词被压缩或被全局滚动条逼出视区。
+
+### 修复
+
+- 为 `views/dag.js` 补充缺失类型声明，修复 next 发布通道的 typecheck 阻断。
+- 记录 release/0.39 上 observe 面板改动的回移植入 0.39.2，方便追溯修复来源。
+
 ## [0.39.1] - 2026-08-25
 
 ### 重点更新

package/README.md

@@ -54,7 +54,7 @@ loop-agent init doctor --repo-root .
 loop-agent inspect --repo-root .
 ```
 
-`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/` 和验证脚本等治理入口。
+`init model-catalog` 会通过 Pi runtime 与 OpenCode 的非 verbose 列表发现本机可用模型，只输出白名单模型元数据、Pi setup 状态和 provider 凭据就绪状态，不输出原始配置或凭据。已有 LOW/MED/HIGH 只要仍存在于 Pi 就保持不变；只有已移除或缺失的档位才由模型结合项目、能力、成本和上下文窗口重选。对于 `wizard-local` provider，目录会识别 `aicoder-default < aicoder-plus < aicoder-pro < aicoder-max` 的家族内相对能力顺序，但不会把它机械绑定为固定三档。如果 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；也可手动运行统一入口：
 
@@ -126,7 +126,7 @@ agent-worker console doctor --repo .
 
 ```
 
-裸 `agent-worker console` 不在终端询问升级。Operate 右上角提供非阻塞的更新入口，默认选择 npm `latest` 稳定版，也可由操作者显式选择 `next` 预发布版；更新前会先检查活跃运行和全局安装来源。`console doctor`、帮助和版本命令均不触发更新检查。
+裸 `agent-worker console` 不在终端询问升级。操作 → 设置提供非阻塞的「更新并初始化」入口，默认选择 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/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.40.0-next.12",
-  "gitSha": "41c2688fb25e22404d7dd6f9a7c884a2e638d500",
-  "builtAt": "2026-08-29T08:53:25.216Z"
+  "version": "0.40.0-next.14",
+  "gitSha": "4a8185d1e0c0203f2d68c11f5c779b8130145252",
+  "builtAt": "2026-08-30T06:48:39.207Z"
 }

package/dist/cli/command-definitions.js

@@ -11,6 +11,7 @@ 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";
+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";
@@ -100,7 +101,6 @@ const EVAL_SUBCOMMANDS = [
     "outer-loop",
     "ignition",
 ];
-const CLOSEOUT_SUBCOMMANDS = ["task"];
 const PLAN_SUBCOMMANDS = ["list", "create", "complete", "check"];
 const SPINE_SUBCOMMANDS = ["audit"];
 const HANDOFF_SUBCOMMANDS = ["check", "coverage"];
@@ -139,7 +139,7 @@ const DAG_SUBCOMMANDS = [
     "final-verification",
     "decision",
 ];
-const TASK_SUBCOMMANDS = ["advance", "status"];
+const TASK_SUBCOMMANDS = ["advance", "status", "source"];
 const OPERATOR_SUBCOMMANDS = ["capabilities"];
 const WORKFLOW_SUBCOMMANDS = [
     "list",
@@ -215,7 +215,7 @@ export const COMMAND_DEFINITIONS = [
         name: "init",
         adapter: "none",
         tier: "primary",
-        intent: "Initialize a target repository with loop-agent harness capabilities.",
+        intent: "Initialize a target repository with loop-agent harness capabilities. Run INSIDE the target repo, or pass the global --repo-root <path> BEFORE this subcommand (e.g. `loop-agent --repo-root . init --profile full --merge`).",
         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 }) => {
@@ -248,8 +248,8 @@ export const COMMAND_DEFINITIONS = [
         name: "task",
         adapter: "required",
         tier: "primary",
-        intent: "Task lifecycle: advance (mutation) and status (read).",
-        usage: "task <advance|status> ...",
+        intent: "Task lifecycle: advance (mutation), status (read), source prepare (deterministic source files).",
+        usage: "task <advance|status|source> ...",
         subcommands: [...TASK_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             if (subcommand === "advance") {
@@ -260,6 +260,10 @@ export const COMMAND_DEFINITIONS = [
                 await runTaskStatus(repoRoot, rest);
                 return;
             }
+            if (subcommand === "source") {
+                await runTaskSourcePrepare(repoRoot, rest);
+                return;
+            }
             throw new Error(formatSubcommandUsageError("task", TASK_SUBCOMMANDS));
         },
     },

package/dist/cli/program.js

@@ -38,8 +38,9 @@ import { runInstructions } from "../commands/instructions.js";
 import { runKnowledge } from "../commands/knowledge.js";
 import { runLoop } from "../commands/loop.js";
 import { runLoopBenchmark } from "../commands/loop-benchmark.js";
-import { runTaskAdvance } from "../commands/task-advance.js";
-import { runTaskStatus } from "../commands/task-status.js";
+import { runTaskAdvance, TASK_ADVANCE_USAGE } from "../commands/task-advance.js";
+import { runTaskStatus, TASK_STATUS_USAGE } from "../commands/task-status.js";
+import { runTaskSourcePrepare, TASK_SOURCE_PREPARE_USAGE, } 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";
@@ -124,7 +125,11 @@ async function runTaskCommand(repoRoot, subcommand, rest) {
         await runTaskStatus(repoRoot, rest);
         return;
     }
-    throw new Error("usage: task <advance|status> ...");
+    if (subcommand === "source") {
+        await runTaskSourcePrepare(repoRoot, rest);
+        return;
+    }
+    throw new Error("usage: task <advance|status|source> ...");
 }
 async function runCommanderAction(ctx, command, subcommand, rest) {
     switch (command) {
@@ -402,9 +407,38 @@ function createRawArgsCommand(name, description, defaultRepoRoot) {
 function addRawSubcommands(parent, subcommands, defaultRepoRoot) {
     for (const subcommand of subcommands) {
         const command = createRawArgsCommand(subcommand, `${parent.name()} ${subcommand}`, defaultRepoRoot);
+        applyRawSubcommandUsage(command, `${parent.name()} ${subcommand}`);
         parent.addCommand(command);
     }
 }
+/**
+ * Well-known raw-args subcommands whose real USAGE would otherwise only appear
+ * after a parse error. `--help` shows this text at the top (beforeAll help text)
+ * so one-shot callers (Humans, Pi, Chat) can read the real contract up front.
+ * Keys are the full chain (`<parent> <subcommand>`); values must mirror the
+ * command module's own usage strings verbatim where one exists.
+ */
+const RAW_SUBCOMMAND_USAGE = {
+    "task advance": TASK_ADVANCE_USAGE,
+    "task status": TASK_STATUS_USAGE,
+    "task source prepare": TASK_SOURCE_PREPARE_USAGE,
+    "task source": "usage: task source prepare <task-id> [--from-text|--from-file|--from-stdin|--from-draft] [--dry-run|--apply]\nDeterministic task source projection (managed 需求.md / 执行约束.md). See `task source prepare --help` for the full flag surface.",
+    "dag resume": "usage: dag resume --run-id <id>",
+    "dag status": "usage: dag status --run-id <id>",
+    "dag approve": 'usage: dag approve --run-id <id> --option <A|B|...> [--notes "..."]',
+    "dag reject": 'usage: dag reject --run-id <id> --reason "..."',
+    "dag rerun": "usage: dag rerun --run-id <id> --from-node <node-id> --plan [--json] | dag rerun --run-id <id> --from-node <node-id> --plan-hash <hash> --request-id <key> --reason <text> [--json]",
+    "dag rerun-task": "usage: dag rerun-task --run-id <id> --reason <text> --request-id <key> [--profile auto|minimal|standard|reviewed|supervised] [--task-id <id>] [--json]",
+    "dag reconcile-run": "usage: dag reconcile-run --run-id <id> [--action supersede|abandon] [--reason <text>]",
+    "dag doctor": "usage: dag doctor [--run-id <id>]\nInspect health issues before approve/reject/resume; no --json (output is already structured JSON).",
+    "dag report": "usage: dag report [--run-id <id>] [--lifecycle active|paused|completed|all] [--json|--markdown] [--failed-only] [--latest] [--paused-latest]\nRead-only run report; --json gives structured facts (canonical: `dag report --run-id <id> --lifecycle completed --json`).",
+};
+function applyRawSubcommandUsage(command, chainKey) {
+    const usage = RAW_SUBCOMMAND_USAGE[chainKey];
+    if (!usage)
+        return;
+    command.addHelpText("beforeAll", usage);
+}
 function addStandaloneSubcommands(parent, subcommands, handler) {
     for (const subcommand of subcommands) {
         parent
@@ -640,6 +674,7 @@ export function buildLoopAgentProgram(options) {
                 const prepare = createRawArgsCommand("prepare", "Prepare deterministic task source files", options.defaultRepoRoot);
                 configureTaskSourcePrepare(prepare);
                 replaceActionWithOptionAwareDispatch(prepare, options.defaultRepoRoot);
+                applyRawSubcommandUsage(prepare, "task source prepare");
                 source.addCommand(prepare);
             }
         }

package/dist/commands/init-model-catalog.js

@@ -31,8 +31,28 @@ function sanitizeInputKinds(value) {
         .sort();
     return entries.length > 0 ? entries : undefined;
 }
+const AICODER_CAPABILITY_RANK = {
+    "aicoder-default": 1,
+    "aicoder-plus": 2,
+    "aicoder-pro": 3,
+    "aicoder-max": 4,
+};
+function relativeCapabilityForModelId(provider, modelId) {
+    if (provider !== "wizard-local")
+        return undefined;
+    const rank = AICODER_CAPABILITY_RANK[modelId];
+    if (!rank)
+        return undefined;
+    return {
+        family: "aicoder",
+        rank,
+        scale: 4,
+        order: "weakest-to-strongest",
+    };
+}
 function createCatalogEntry(input) {
     const piCompatible = input.source === "pi";
+    const relativeCapability = relativeCapabilityForModelId(input.provider, input.modelId);
     return {
         reference: `${input.provider}/${input.modelId}`,
         provider: input.provider,
@@ -42,6 +62,7 @@ function createCatalogEntry(input) {
         credentialReady: input.credentialReady,
         piCompatible,
         eligibleForHarness: piCompatible && input.credentialReady === true && input.tools !== false,
+        ...(relativeCapability ? { relativeCapability } : {}),
         ...(compactRecord({
             reasoning: input.reasoning,
             tools: input.tools,
@@ -448,6 +469,7 @@ export async function discoverInitModelCatalog(options) {
             rules: [
                 "Choose only models with eligibleForHarness=true; OpenCode-only entries are context, not proof of Pi executor compatibility.",
                 "Use target-project evidence plus model capabilities, cost, context window, and credential readiness; tiers may intentionally share a model.",
+                "When relativeCapability is present, compare only entries from the same family and treat larger rank values as stronger; it is a relative capability hint, not a mandatory LOW/MED/HIGH assignment.",
                 "Preserve an existing complete usable matrix unless it is unavailable or the user asked to reselect it.",
                 "Ask the user only for a material unresolved credential, cost, compliance, or availability decision.",
             ],

package/dist/commands/task-advance.js

@@ -13,7 +13,7 @@ const USAGE = `usage:
     [--feature-id <id>]
     [--allowed-path <glob>]...
     [--forbidden-path <glob>]...
-    [--verify <label:command>]...
+    [--verify <label:command>]...   # e.g. --verify "typecheck:npx tsc --noEmit" (label BEFORE the colon)
     [--verify-timeout <label:timeoutMs>]...
     [--backend-test <json>]
     [--accept-recommendations <digest>]
@@ -31,6 +31,7 @@ const USAGE = `usage:
     [--progress-interval-ms <ms>]
     [--dry-run]
     [--json]`;
+export { USAGE as TASK_ADVANCE_USAGE };
 function pushList(target, value) {
     const list = target ?? [];
     list.push(value);
@@ -232,6 +233,26 @@ export function parseTaskAdvanceArgs(args) {
     }
     return { taskId, options };
 }
+const FOREGROUND_DAG_WARNING = [
+    "[task advance] --approve-gate will execute the whole DAG in the FOREGROUND:",
+    "  this terminal must stay open until every node finishes (writer nodes can run 10-60+ min).",
+    "  Killing it mid-run (timeout / Ctrl-C / closed terminal) leaves an orphaned run that",
+    "  only `dag reconcile-run --action supersede|abandon` can close.",
+    "  Prefer background holders instead:",
+    "    - Console: prepareDagExecution -> runDag (operation-held)",
+    "    - CLI:     nohup loop-agent task advance <task-id> --approve-gate <token> ... &",
+].join("\n");
+/**
+ * Operator guardrail (dogfood 2026-08-29): warn a human sitting on a TTY that
+ * `--approve-gate` runs the full DAG in the foreground before the process
+ * parks on node execution. Piped/non-TTY invocations (Console operations,
+ * scripts, --json pipelines) stay silent so machine paths are unaffected.
+ */
+export function warnForegroundDagExecution(options, stream = process.stderr) {
+    if (options.quiet || stream.isTTY !== true)
+        return;
+    stream.write(`${FOREGROUND_DAG_WARNING}\n`);
+}
 function mapOutcome(result) {
     if (result.blockers.length > 0) {
         const code = result.blockers[0]?.code ?? "";
@@ -351,6 +372,7 @@ export async function runTaskAdvance(repoRoot, args) {
         // ONLY for the approve-gate execution path and disposed on every exit;
         // its timer starts only after onRunStart (double guard, no stray timer).
         if (options.approveGate && !options.dryRun && !options.quiet) {
+            warnForegroundDagExecution(options);
             progress = createRunDagProgressObserver({
                 intervalMs: options.progressIntervalMs,
             });

package/dist/commands/task-source-prepare.js

@@ -32,6 +32,7 @@ const USAGE = `usage:
     [--dry-run | --apply]
     [--force-overwrite-source]
     [--json]`;
+export { USAGE as TASK_SOURCE_PREPARE_USAGE };
 function pushList(target, value) {
     const list = target ?? [];
     list.push(value);
@@ -386,6 +387,10 @@ function printHuman(result) {
     console.log(lines.join("\n"));
 }
 export async function runTaskSourcePrepare(repoRoot, args) {
+    // CLI chain routing (task -> source -> prepare) folds the leaf name into
+    // rest[0]; strip it so `loop-agent task source prepare <id> ...` works.
+    if (args[0] === "prepare")
+        args = args.slice(1);
     if (args.includes("--help") || args.includes("-h")) {
         console.log(USAGE);
         process.exitCode = 0;

package/dist/commands/task-status.js

@@ -3,6 +3,7 @@ import { buildOperatorResult, operatorFailed, processExitCodeForOutcome, writeOp
 const COMMAND = "task status";
 const USAGE = `usage:
   task status <task-id> [--json|--markdown] [--details]`;
+export { USAGE as TASK_STATUS_USAGE };
 export function parseTaskStatusArgs(args) {
     const options = {};
     const positional = [];

package/dist/shared/operator/capabilities.js

@@ -51,6 +51,8 @@ const OFFICIAL_ACTION_DESCRIPTIONS = {
     workerSchedulerStatus: "Night-scheduler status overview (agent-worker). Use to check whether overnight jobs are healthy.",
     workerSchedulerLedger: "Night-scheduler harvest ledger (agent-worker). Use to audit what overnight runs produced.",
     workerSchedulerDoctor: "Diagnose night-scheduler health (agent-worker). Use when overnight jobs fail to fire or harvest.",
+    dagResume: "Unpause a run paused at a human decision checkpoint. Orphaned runs (dead runner, liveness=orphaned) are NOT continuable — do not resume them: use dagReconcileRun --action supersede to archive and then advance/rerun the task fresh.",
+    dagReconcileRun: "Reconcile an orphaned run (dead runner, liveness=orphaned). These are NOT continuable: supersede archives the run for a fresh same-task advance/rerun; abandon discards it. resume only unpauses human-decision checkpoints — never for orphaned runs.",
 };
 const officialAction = (action, cli, kind, coverage) => ({
     action,
@@ -817,7 +819,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "BINDING_DRIFT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Issue a session-bound single-use execution receipt after server-side G2 assessment (bounded writeSet ⊆ allowedPaths, no forbidden overlap, no broad/destructive risk, structured verification). The model never passes a raw DAG path.",
+            description: "Returns SYNCHRONOUSLY (not an operation): it immediately yields a session-bound single-use executionId + receipt, which you then pass to runDag to actually execute. It is a server-side G2 assessment (bounded writeSet ⊆ allowedPaths, no forbidden overlap, no broad/destructive risk, structured verification). The model never passes a raw DAG path.",
             inputParams: [
                 {
                     name: "taskId",
@@ -1067,6 +1069,12 @@ export function buildOperatorCapabilitiesDocument() {
                     required: false,
                     description: "verification entries as label:command strings",
                 },
+                {
+                    name: "approveGate",
+                    type: "string",
+                    required: false,
+                    description: "optional write-set gate approval token `<gate-id>:sha256:<64-hex>` exactly as reported by task status gate.approveCommand; forwards as --approve-gate and executes the approved DAG as this background operation (preferred over a foreground terminal)",
+                },
             ],
             modelCallable: "always",
             humanConfirmation: "none",

package/dist/worker/console/chat/assistant-content.js

@@ -98,6 +98,13 @@ function isFinalAnswerBlock(block) {
 }
 export function splitFinalAssistantBlocks(blocks, options = {}) {
     const displayable = getDisplayableAssistantBlocks(blocks, options);
+    // A streaming Pi message is cumulative: a later update may append a toolCall
+    // after text that is already visible. Keep the whole live message in the
+    // chronological process subtree so that update appends the tool in place
+    // instead of reparenting the earlier text from answer -> process.
+    if (options.isStreaming) {
+        return { answerBlocks: [], processBlocks: displayable };
+    }
     let lastProcessIndex = -1;
     for (let i = displayable.length - 1; i >= 0; i--) {
         if (!isFinalAnswerBlock(displayable[i])) {

package/dist/worker/console/chat/chat-event-store.js

@@ -136,7 +136,7 @@ export function projectOperationForChat(operation) {
         state: operation.state,
         createdAt: operation.createdAt,
         updatedAt: operation.finishedAt ?? operation.startedAt ?? operation.createdAt,
-        inspectHref: `/inspect/?operationId=${encodeURIComponent(operation.operationId)}#/`,
+        inspectHref: `/#/inspect?operationId=${encodeURIComponent(operation.operationId)}`,
         ...(taskId ? { taskId } : {}),
         ...(dagRunId ? { dagRunId } : {}),
         ...(featureId ? { featureId } : {}),
@@ -381,12 +381,26 @@ function dropOneByPriority(ring) {
     const events = ring.events;
     if (events.length === 0)
         return undefined;
-    const textIndex = events.findIndex((event) => event.kind === "message_update");
+    // Keep the newest Goal snapshot/tombstone as the session's durable Goal
+    // source of truth. Otherwise a long thread could forget an active Goal or
+    // resurrect a cleared one after ring eviction.
+    let protectedGoalIndex = -1;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        if (events[index].kind === "goal_changed" ||
+            events[index].kind === "goal_cleared") {
+            protectedGoalIndex = index;
+            break;
+        }
+    }
+    const textIndex = events.findIndex((event, index) => index !== protectedGoalIndex && event.kind === "message_update");
     if (textIndex !== -1)
         return events.splice(textIndex, 1)[0];
-    const structuralIndex = events.findIndex((event) => event.kind !== "message_end");
+    const structuralIndex = events.findIndex((event, index) => index !== protectedGoalIndex && event.kind !== "message_end");
     if (structuralIndex !== -1)
         return events.splice(structuralIndex, 1)[0];
+    const anyUnprotected = events.findIndex((_event, index) => index !== protectedGoalIndex);
+    if (anyUnprotected !== -1)
+        return events.splice(anyUnprotected, 1)[0];
     return events.shift();
 }
 /**
@@ -430,6 +444,13 @@ const DEFAULT_MAX_EVENTS = 2000;
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
 /** Same-turn `message_update` events inside this window coalesce into one persisted event. */
 const DEFAULT_COALESCE_WINDOW_MS = 100;
+/** B5-1: `message_update` appends persist at most once per this window (driven
+ *  by the event `at` clock, same as coalescing — no timers involved). */
+const DEFAULT_PERSIST_DEBOUNCE_MS = 250;
+/** B5-1: hard cap on pending debounced `message_update` appends before an
+ *  interim flush is forced, so a fast stream never widens the loss window
+ *  unboundedly even if the `at` clock stalls. */
+const DEFAULT_PERSIST_MAX_PENDING_UPDATES = 250;
 /** Conservative per-event scale for the byte pre-check gate (UTF-8 multibyte ≤ 4 bytes/char × pretty-print expansion). */
 const BYTE_GATE_SCALE = 12;
 /** Fixed envelope slack (schema keys, turnCount, nextSeq, minSeq, turns) for the byte pre-check gate. */
@@ -632,6 +653,9 @@ export function createChatEventStore(options) {
     const maxBytes = options?.maxBytesPerSession ?? DEFAULT_MAX_BYTES;
     const coalesceWindowMs = options?.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS;
     const eventEpoch = options?.epoch?.trim() || LEGACY_EPOCH;
+    const persistWriter = options?.persistWriter ?? writeSecureJsonSync;
+    const persistDebounceMs = options?.persistDebounceMs ?? DEFAULT_PERSIST_DEBOUNCE_MS;
+    const persistMaxPendingUpdates = options?.persistMaxPendingUpdates ?? DEFAULT_PERSIST_MAX_PENDING_UPDATES;
     const persistenceDir = options?.appData?.chatEvents
         ? path.resolve(options.appData.chatEvents)
         : undefined;
@@ -642,6 +666,9 @@ export function createChatEventStore(options) {
     const turnCounts = new Map();
     /** Live subscribers per session. */
     const subscribers = new Map();
+    /** B5-1: sessions whose latest `message_update` appends are still waiting
+     *  for the next persist (debounced; structural events / turn changes flush). */
+    const pendingPersists = new Map();
     function persistedPath(sessionId) {
         return persistenceDir
             ? path.join(persistenceDir, `${safeSessionId(sessionId)}.json`)
@@ -709,7 +736,7 @@ export function createChatEventStore(options) {
             // current limits if it was written by an older config or hand-edited.
             enforceBounds(sessionId, ring);
             if (orphaned)
-                persist(sessionId, ring);
+                persistNow(sessionId, ring);
             return ring;
         }
         catch (error) {
@@ -763,11 +790,36 @@ export function createChatEventStore(options) {
             ring.minSeq = ring.events[0].seq;
         }
     }
-    function persist(sessionId, ring) {
+    /** Persist the full ring synchronously (atomic tmp+rename) and clear any
+     *  B5-1 pending-debounce marker for this session. */
+    function persistNow(sessionId, ring) {
         const file = persistedPath(sessionId);
+        pendingPersists.delete(sessionId);
         if (!file)
             return;
-        writeSecureJsonSync(file, ringPayload(sessionId, ring));
+        persistWriter(file, ringPayload(sessionId, ring));
+    }
+    /** B5-1: defer the persist of a `message_update` append. The window is driven
+     *  by the append `at` clock (mirroring `shouldCoalesce`) — a structural event,
+     *  turn change, elapsed window or the pending-count cap each force a real
+     *  flush, so a streaming turn no longer serializes the whole ring per token. */
+    function persistDebounced(sessionId, ring, atMs) {
+        const file = persistedPath(sessionId);
+        if (!file)
+            return;
+        const pending = pendingPersists.get(sessionId);
+        if (!pending) {
+            pendingPersists.set(sessionId, {
+                firstPendingAtMs: atMs,
+                pendingUpdates: 1,
+            });
+            return;
+        }
+        pending.pendingUpdates += 1;
+        if (atMs - pending.firstPendingAtMs >= persistDebounceMs ||
+            pending.pendingUpdates >= persistMaxPendingUpdates) {
+            persistNow(sessionId, ring);
+        }
     }
     function ringFor(sessionId) {
         let ring = rings.get(sessionId);
@@ -870,7 +922,7 @@ export function createChatEventStore(options) {
             };
             ring.turns.push(turn);
             ring.approxBytes += byteHint(turn);
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ok: true, turn: { ...turn }, created: true, idempotent: false };
         },
         setTurnState(sessionId, turnId, state, error) {
@@ -889,7 +941,7 @@ export function createChatEventStore(options) {
                 turn.error = error;
             ring.approxBytes +=
                 (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ...turn };
         },
         markAbortRequested(sessionId, turnId, at) {
@@ -902,7 +954,7 @@ export function createChatEventStore(options) {
                 turn.abortRequestedAt = at ?? new Date().toISOString();
             ring.approxBytes +=
                 (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return { ...turn };
         },
         findTurnByClientRequestId(sessionId, clientRequestId) {
@@ -962,7 +1014,23 @@ export function createChatEventStore(options) {
                 ring.approxBytes += byteHint(live);
             }
             enforceBounds(sessionId, ring);
-            persist(sessionId, ring);
+            // B5-1: only high-frequency `message_update` appends defer the persist;
+            // every other kind (message_end / tool_call / error / turn signals …)
+            // still persists synchronously. Because persistNow writes the FULL
+            // in-memory ring, one flush also lands any earlier pending updates in
+            // order — no two-phase flush is needed.
+            if (partial.kind === "message_update") {
+                const atMs = partial.at ? Date.parse(partial.at) : Date.now();
+                if (!Number.isNaN(atMs)) {
+                    persistDebounced(sessionId, ring, atMs);
+                }
+                else {
+                    persistNow(sessionId, ring);
+                }
+            }
+            else {
+                persistNow(sessionId, ring);
+            }
             const subs = subscribers.get(sessionId);
             if (subs) {
                 for (const fn of subs) {
@@ -1017,7 +1085,7 @@ export function createChatEventStore(options) {
             const ring = ringFor(sessionId);
             const next = (turnCounts.get(sessionId) ?? 0) + 1;
             turnCounts.set(sessionId, next);
-            persist(sessionId, ring);
+            persistNow(sessionId, ring);
             return next;
         },
         latestTurnId(sessionId) {
@@ -1043,6 +1111,9 @@ export function createChatEventStore(options) {
             rings.delete(sessionId);
             turnCounts.delete(sessionId);
             subscribers.delete(sessionId);
+            // B5-1: drop any debounced (not yet written) updates with the ring itself —
+            // the file is being deleted, so flushing first would only resurrect it.
+            pendingPersists.delete(sessionId);
             const file = persistedPath(sessionId);
             if (file)
                 rmSync(file, { force: true });