@tea-agent/loop-agent 0.34.3 → 0.34.5

package/AGENTS.md

@@ -38,7 +38,7 @@
 4. 涉及测试纪律/验证声明/调试时继续读：`docs/governance/harness-methodology-*.md`。
 5. 查看最近提交、相关 plan/progress/report；`git status --short --branch`；跑最小基线验证。
 6. 后端/接口/pytest → `taskKind: "backend-test"`（不是 `--profile`）；知识回写 `knowledge-sync`；图谱开荒 `knowledge-graph-bootstrap`。`--profile` 仅 `auto|minimal|standard|reviewed|supervised`。
-7. 看板/observe → `agent-worker console`（默认 repo=当前目录、port=8790；兼容入口 `agent-worker console serve --repo . --port 8790`）（`/inspect/` 只读）；`observe serve` 已下线（`OBSERVE_SERVE_REMOVED` + exit 2）；`observe snapshot` 仍可用。
+7. 看板/observe → `agent-worker console`（默认 repo=当前目录、port=8790；listen 成功后默认打开系统浏览器，`--no-open` 禁止）（`/inspect/` 只读）；`observe serve` 已下线（`OBSERVE_SERVE_REMOVED` + exit 2）；`observe snapshot` 仍可用。
 8. 分支合并 → 先读 `docs/operations/branch-merge-guideline.md`。
 
 ## 会话协议
@@ -74,7 +74,9 @@ DAG 执行期间，主 agent 不得修改 writeSet 外的任何工作区文件
 
 权威源：`docs/governance/verification-matrix.md`。
 
-默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 跑 `bash scripts/ci.sh`（全量 typecheck + `npm test`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
+默认节奏：编辑中只跑矩阵「最低验证」（typecheck + 定向 Vitest）；`git commit` 的 `pre-commit` 只做 `check-repo`；`git push` 的 `pre-push` 经 `node scripts/pre-push-verify.mjs` 在 receipt 命中时复用、miss 时跑 full `bash scripts/ci.sh`（全量 typecheck + `npm test`）。每个 clone 安装一次 hooks：`bash scripts/install-git-hooks.sh`。
+
+连续 source→target 交付遵循**单一最终树全量验证**：同一 Git tree、相同环境与命令合同在 receipt TTL 内只选一个本地 full authority（有效 receipt / target pre-push / 可选 `npm run verify:tree`），不按分支名策略化，也不机械双跑 full CI。细节见 verification-matrix 与 branch-merge-guideline。
 
 常用：
 
@@ -83,7 +85,10 @@ DAG 执行期间，主 agent 不得修改 writeSet 外的任何工作区文件
 npm run typecheck
 npx vitest run <相关测试路径>
 
-# push / 交付前（或依赖 pre-push）
+# 可选：提前验证当前 clean HEAD 并写 receipt（随后同 tree push 可复用）
+npm run verify:tree
+
+# push / 交付前（或依赖 pre-push；receipt miss 时安全回退 full）
 bash scripts/ci.sh
 npm run build
 node bin/loop-agent.js --help

package/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## [Unreleased]
 
+## [0.34.5] - 2026-08-13
+
+### 重点更新
+
+- 优化 Operator Chat 对话页体验，包括隐藏重复标题、升级 Markdown 渲染、改进工具调用展示，并合并了 `/` 命令面板
+- 控制台启动后默认自动打开系统浏览器看板
+
+### 改进
+
+- 优化 Operator Chat 对话页（UI-01 至 UI-11）：隐藏重复标题、补齐品牌空态与真实注入上下文侧栏、改进工具调用摘要与结果展示、修复遮罩 hover 形变、为截断会话标题提供 tooltip、升级 Markdown/GFM 渲染，并增加用户主动打开的调用记录入口与合并后的 `/` 命令面板
+- 会话列表操作改为按需显示 Remix Icon，同时保留键盘 focus 与触屏可访问路径
+- 输入区将图片上传收敛为图标按钮，并避免“全部工具 · N · 状态”歧义
+- 控制台在服务监听成功后默认打开系统浏览器
+
+## [0.34.4] - 2026-08-12
+
+### 重点更新
+
+- 裸 `agent-worker console` 收敛为唯一看板入口，监听成功后默认打开系统浏览器，并删除 `console serve`
+- 本地连续交付改为按精确 Git tree 复用验证结果，避免提交、推送和分支合并之间机械重复全量测试，同时保持不同 tree、不同环境和远程 CI 的独立质量门槛
+- 全面加固 Operator Chat 的 Turn 所有权、停止与异常恢复流程，解决浏览器与服务端状态错位时的重复提交、停止失效和错误提示问题
+- Operator Chat 新增按仓库保存的 Skills 自动使用偏好，用户可控制技能是否进入模型自动发现范围，同时保留手动调用能力
+- 修复控制台任务导航无法自主执行后端测试与前端测试 DAG 的问题，现可正确识别 pytest、playwright 等多种测试框架的验证命令
+
+### 新增
+
+- 新增可选的 `npm run verify:tree`，对当前严格 clean HEAD 执行完整验证并写入 receipt，随后推送同一 tree 时可直接复用
+- 新增只读的当前 tree receipt 诊断，可区分匹配、缺失、过期、损坏和工作区不合格等状态，不执行测试或写入 receipt
+- Operator Chat 引入完整的 Turn ownership 协议和服务端真实中止接口，并在状态接口中提供 active/latest Turn 与 runtime busy 事实
+- Operator Chat Skills 新增「允许自动使用」开关，偏好按仓库持久化；关闭后仍可通过 `/skill:<name>` 手动调用
+
+### 改进
+
+- 裸 `agent-worker console` 成为唯一 Console 启动入口：本地图形交互环境在服务监听成功后默认打开系统浏览器，`--no-open` 可明确禁止；删除 `console serve` 兼容子命令
+- source→target 连续交付统一选择一个本地全量验证权威；默认 commit/push 不增加步骤，远程 CI 与发布环境不复用本地 receipt
+- pre-push receipt 诊断和执行日志改用有界命令摘要，并严格校验 tree、环境、命令合同、有效期及 receipt 内容一致性
+- Skills 运行时快照改为使用服务端资源标识和独立的自动调用状态，资源变更仅接受当前 inventory 中的合法条目
+- Turn 已占用时返回可恢复的中文状态提示和真实 active Turn，不再向用户暴露裸露的 `chat turn already active` 错误
+
+### 修复
+
+- 修复浏览器已认为对话结束、服务端却仍持有 active Turn 时的重复提交竞态；提交现在支持幂等请求标识、boot epoch orphan 隔离和 durable Turn/runtime busy 联合对账
+- 修复创建 Turn 的响应不确定时状态被过早释放的问题；客户端会保留 ambiguous 状态，通过 `/state` 绑定或释放真实 ownership，不会重新生成请求标识
+- 修复停止请求在 Turn 尚未绑定时丢失的问题；绑定成功后只发送一次真实 abort，且服务端缺少 abort 能力时不会通过 dispose 会话伪造停止
+- 修复 active bind、terminal SSE 与 React streaming 状态交错时提交锁未释放的问题，并统一 adopt、停止中和 abort-pending 为非致命提示
+- 修复控制台任务导航执行 backend-test 和 frontend-test DAG 时，因结构化验证门禁未识别 pytest/playwright 等命令而始终被阻断的问题
+
 ## [0.34.3] - 2026-08-12
 
 ### 重点更新
@@ -85,36 +132,33 @@
 
 ## [0.33.6] - 2026-08-11
 
+### 重点更新
+
+- 加固 PRD 导入与 Semantic Intake，在结构化解析不足时提供安全回退，并增强 writeSet 审查与运行结果摘要
+- Operator Chat 接入单一事件流、启动 epoch 隔离、实时运行时控制与开放资源加载，提升长会话恢复和自主 DAG 监督能力
+- 统一 Windows 等环境下只读 Git 命令的有界恢复机制，同时保留用户自有的 Pi 模型路由配置
+
 ### 新增
 
-- stabilize PRD intake + add Semantic Intake fallback
-- Operator Chat 单事件流 + boot epoch fence（Task C）
-- gate writeSet delta + run summary（操作面增强）
-- supervise DAG runs autonomously
-- ChatEventStore 事件持久化压缩（coalescing + maxBytes 双限制）
-- reconcile(cursor_expired) 自动恢复而非全局致命错误
-- 接入 Operator Chat 实时运行时控制
-- open operator chat resource loading
-- enrich execution report and URL resolution
+- task advance 新增 writeSet delta 与 run summary，直接展示边界扩张来源、节点结果和下一步操作
+- Operator Chat 引入单一事件流与 boot epoch fence，支持 cursor 过期后的自动对账恢复，避免将可恢复问题升级为全局错误
+- ChatEventStore 增加事件合并与容量上限双重压缩，控制长期会话持久化体积
+- Operator Chat 新增实时模型、thinking 和运行时资源控制，并按开放资源加载规则解析 Skills、Extensions 与 Packages
+- Operator Chat 可对安全的 bounded DAG 进行持续监督和恢复，执行报告同步补充运行细节与目标 URL 来源
 
 ### 改进
 
-- style(task-advance): biome autoformat 对齐（无功能变化）
-- style(console): apply biome formatting from pi-lens autoformat
+- 只读 Git 查询统一使用共享韧性执行器，在 Windows 启动型故障下有界恢复，不扩大 mutation 命令权限
+- 初始化与升级流程保留用户自行配置的 Pi 模型路由，不再因默认配置变化机械覆盖
+- Packages 面板区分配置状态与真实安装元数据，并统一使用品牌图标
 
 ### 修复
 
-- unify resilient read-only command execution
-- preserve user-owned Pi model routing
-- show installed package metadata
-- escape preflight backtick matcher
-- align chat streaming reliability with pi-web
-- split rerun defaults and repair selector escaping
-- ignore delimiters inside pytest strings
-- resolve target URL from runtime context
-- reject priority-only module stems
-- stop desiredSha256 mechanical checks from blocking generated-content upgrades
-- use mobius header brand icon
+- 修复 Operator Chat 流式状态与 pi-web 可靠性机制未完全对齐的问题，提升重连和终态收敛稳定性
+- 修复前端测试环境预检中的反引号转义错误，以及重跑默认值和 repair 选择器转义不一致的问题
+- 修复后端测试完整性检查误判字符串内部未配对分隔符，以及按优先级生成非法单模块文件的问题
+- 修复前端测试目标 URL 未从运行时上下文解析的问题，执行时现使用可审计的真实地址来源
+- 修复 generated init 内容因 `desiredSha256` 机械比较而阻断安全升级的问题
 
 ## [0.33.5] - 2026-08-11
 

package/README.md

@@ -104,8 +104,8 @@ loop-agent dag report --run-id <run-id>
 
 ```bash
 # 终端 A：Console（任务/运行操作面；canonical mutation 只经 sibling loop-agent）
-agent-worker console                              # 默认 repo=当前目录、port=8790
-agent-worker console serve --repo .               # 兼容入口，等价于裸入口
+agent-worker console                              # 默认 repo=当前目录、port=8790；本地图形环境默认打开浏览器
+agent-worker console --no-open                    # 只启动服务，不打开浏览器
 agent-worker console doctor --repo .
 
 ```

package/dist/shared/operator/capabilities.js

@@ -2299,13 +2299,6 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
         source: "agent-worker",
         exclusionReason: "Not exposed to Operator Chat in M5.",
     },
-    {
-        command: "agent-worker console serve",
-        coverage: "excluded",
-        action: null,
-        source: "agent-worker",
-        exclusionReason: "Not exposed to Operator Chat in M5.",
-    },
     {
         command: "agent-worker console doctor",
         coverage: "excluded",

package/dist/worker/cli.js

@@ -712,37 +712,22 @@ export function buildAgentWorkerProgram() {
         process.stdout.write(`${JSON.stringify(snapshot)}\n`);
     });
     consoleCmd
-        .description("Loop Operator Console (local); bare `agent-worker console` starts it directly (repo defaults to current working directory, port defaults to 8790)")
-        .enablePositionalOptions()
-        .passThroughOptions()
+        .description("Loop Operator Console (local); bare `agent-worker console` starts it directly (repo defaults to current working directory, port defaults to 8790). Opens the system browser after listen unless --no-open or a non-graphical environment.")
         .option("--repo <repo-root>", "Target repo root (default: current working directory)", process.cwd())
         .option("--port <port>", "HTTP port", "8790")
         .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no network auth)", "127.0.0.1")
         .option("--debug", "Log request source/method/path/status to stderr")
         .option("--app-data <path>", "Override Console application-data root (Draft/Operation/confirmation)")
         .option("--default-timeout-ms <ms>", "LoopAgentClient hard timeout for Console operations (ms; default 14400000 / 4h; 0 disables)")
-        .action(async (options) => {
-        await runConsoleServe({
-            repoRoot: path.resolve(options.repo),
-            host: options.host,
-            port: Number.parseInt(options.port, 10),
-            debug: options.debug === true,
-            appDataRoot: options.appData
-                ? path.resolve(options.appData)
-                : undefined,
-            defaultTimeoutMsRaw: options.defaultTimeoutMs,
-        });
-    });
-    consoleCmd
-        .command("serve")
-        .option("--repo <repo-root>", "Target repo root (default: current working directory)", process.cwd())
-        .option("--port <port>", "HTTP port", "8790")
-        .option("--host <host>", "Bind host (default 127.0.0.1; use 0.0.0.0 for LAN, no network auth)", "127.0.0.1")
-        .option("--debug", "Log request source/method/path/status to stderr")
-        .option("--app-data <path>", "Override Console application-data root (Draft/Operation/confirmation)")
-        .option("--default-timeout-ms <ms>", "LoopAgentClient hard timeout for Console operations (ms; default 14400000 / 4h; 0 disables)")
-        .description("Start Loop Operator Console HTTP server (compat entry; equivalent to bare `agent-worker console`)")
-        .action(async (options) => {
+        .option("--no-open", "Do not open the system browser after the Console listens")
+        .action(async (options, command) => {
+        // Reject unknown tokens such as legacy `console serve` instead of starting HTTP.
+        const extras = command.args.filter((arg) => arg.length > 0);
+        if (extras.length > 0) {
+            process.stderr.write(`error: unknown command '${extras[0]}' for agent-worker console\n`);
+            process.exitCode = 1;
+            return;
+        }
         await runConsoleServe({
             repoRoot: path.resolve(options.repo),
             host: options.host,
@@ -752,6 +737,8 @@ export function buildAgentWorkerProgram() {
                 ? path.resolve(options.appData)
                 : undefined,
             defaultTimeoutMsRaw: options.defaultTimeoutMs,
+            // Commander maps --no-open to open:false; default remains open:true.
+            noOpen: options.open === false,
         });
     });
     consoleCmd
@@ -850,9 +837,10 @@ function parseOptionalTimeoutMs(raw) {
     }
     return value;
 }
-/** Shared console serve entry used by both bare `console` and `console serve`. */
+/** Console HTTP entry for bare `agent-worker console` (listen first, then optional browser open). */
 async function runConsoleServe(options) {
     const { createConsoleServer } = await import("./console/server.js");
+    const { maybeOpenConsoleBrowser } = await import("./console/open-browser.js");
     try {
         const server = await createConsoleServer({
             repoRoot: options.repoRoot,
@@ -862,7 +850,13 @@ async function runConsoleServe(options) {
             appDataRoot: options.appDataRoot,
             defaultTimeoutMs: parseOptionalTimeoutMs(options.defaultTimeoutMsRaw),
         });
-        process.stdout.write(`${server.url}\n`);
+        // Keep stdout bind URL contract (may include 0.0.0.0 / ::); browser URL is normalized separately.
+        process.stdout.write(`${server.url}
+`);
+        await maybeOpenConsoleBrowser({
+            noOpen: options.noOpen === true,
+            serverUrl: server.url,
+        });
         await new Promise((resolve) => {
             const shutdown = () => resolve();
             process.once("SIGINT", shutdown);

package/dist/worker/console/app-data.js

@@ -43,6 +43,7 @@ export function openConsoleAppData(options) {
         chats: path.join(repoNamespace, "chats"),
         chatSessions: path.join(repoNamespace, "chat-sessions"),
         chatEvents: path.join(repoNamespace, "chat-events"),
+        resourcePreferences: path.join(repoNamespace, "resource-preferences.json"),
     };
     for (const dir of [
         paths.drafts,
@@ -55,6 +56,7 @@ export function openConsoleAppData(options) {
         paths.chats,
         paths.chatSessions,
         paths.chatEvents,
+        path.dirname(paths.resourcePreferences),
     ]) {
         ensureSecureDir(dir);
     }

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

@@ -129,9 +129,56 @@ function boundedRedactedJson(value) {
         previewHash: createHash("sha256").update(preview).digest("hex"),
     };
 }
+/** Prefer readable Pi ToolResult text content; fall back to JSON shell. */
+function projectToolResultPreview(value) {
+    if (typeof value === "string") {
+        const preview = boundedRedactedText(value) ?? "";
+        return {
+            preview,
+            previewHash: createHash("sha256").update(preview).digest("hex"),
+        };
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const record = value;
+        const content = record.content;
+        if (Array.isArray(content)) {
+            const texts = [];
+            for (const block of content) {
+                if (!block || typeof block !== "object")
+                    continue;
+                const item = block;
+                if (typeof item.text === "string")
+                    texts.push(item.text);
+            }
+            if (texts.length > 0) {
+                const joined = texts.join("\n");
+                const preview = boundedRedactedText(joined) ?? "";
+                return {
+                    preview,
+                    previewHash: createHash("sha256").update(preview).digest("hex"),
+                };
+            }
+        }
+        if (typeof record.text === "string") {
+            const preview = boundedRedactedText(record.text) ?? "";
+            return {
+                preview,
+                previewHash: createHash("sha256").update(preview).digest("hex"),
+            };
+        }
+        if (typeof record.output === "string") {
+            const preview = boundedRedactedText(record.output) ?? "";
+            return {
+                preview,
+                previewHash: createHash("sha256").update(preview).digest("hex"),
+            };
+        }
+    }
+    return boundedRedactedJson(value);
+}
 export function projectChatToolEventPayload(input) {
-    const { preview, previewHash } = boundedRedactedJson(input.value);
     if (input.kind === "tool_call") {
+        const { preview, previewHash } = boundedRedactedJson(input.value);
         return {
             toolCallId: input.toolCallId,
             toolName: input.toolName,
@@ -139,6 +186,7 @@ export function projectChatToolEventPayload(input) {
             previewHash,
         };
     }
+    const { preview, previewHash } = projectToolResultPreview(input.value);
     return {
         toolCallId: input.toolCallId,
         toolName: input.toolName,
@@ -221,6 +269,20 @@ function shouldCoalesce(ring, turnId, partial) {
         return false;
     return nowMs - Date.parse(tail.at) <= ring.coalesceWindowMs;
 }
+/** Stable hash of the normalized prompt payload for clientRequestId binding. */
+export function hashChatTurnPayload(input) {
+    const normalized = {
+        text: input.text,
+        images: (input.images ?? []).map((image) => ({
+            type: image.type ?? "image",
+            mimeType: image.mimeType ?? "",
+            data: image.data ?? "",
+        })),
+    };
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex");
+}
 const DEFAULT_MAX_EVENTS = 2000;
 /** Mirrors pi-web's bounded-ring orientation (2000 events / 10 MiB). */
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
@@ -399,6 +461,24 @@ export function createChatEventStore(options) {
                 eventId: eventIdFor(sessionId, event.seq),
             }));
             const turns = Array.isArray(parsed.turns) ? parsed.turns : [];
+            // New Console epoch: orphan any queued/running turn whose ownerEpoch is
+            // missing or mismatched. Releases the active lease without pretending the
+            // user aborted (CHAT_TURN_OWNER_LOST fence).
+            let orphaned = false;
+            const now = new Date().toISOString();
+            for (const turn of turns) {
+                if (turn.state !== "queued" && turn.state !== "running")
+                    continue;
+                if (turn.ownerEpoch === eventEpoch)
+                    continue;
+                turn.state = "failed";
+                turn.finishedAt = now;
+                turn.error = {
+                    code: "CHAT_TURN_OWNER_LOST",
+                    message: "turn ownership lost after Console restart; previous execution is no longer owned",
+                };
+                orphaned = true;
+            }
             turnCounts.set(sessionId, parsed.turnCount ?? 0);
             const ring = {
                 events,
@@ -415,6 +495,8 @@ export function createChatEventStore(options) {
             // R6: re-check the bounds after a restart — a persisted file may exceed the
             // current limits if it was written by an older config or hand-edited.
             enforceBounds(sessionId, ring);
+            if (orphaned)
+                persist(sessionId, ring);
             return ring;
         }
         catch (error) {
@@ -521,11 +603,35 @@ export function createChatEventStore(options) {
             }
             return { copiedCount };
         },
-        createTurn(sessionId) {
+        createTurn(sessionId, input) {
             const ring = ringFor(sessionId);
+            const clientRequestId = input?.clientRequestId?.trim() || undefined;
+            const payloadHash = input?.payloadHash?.trim() || undefined;
+            if (clientRequestId) {
+                const existing = ring.turns.find((turn) => turn.clientRequestId === clientRequestId);
+                if (existing) {
+                    if (payloadHash &&
+                        existing.payloadHash &&
+                        existing.payloadHash !== payloadHash) {
+                        return {
+                            ok: false,
+                            code: "REQUEST_ID_REUSE_CONFLICT",
+                            message: `clientRequestId ${clientRequestId} was reused with a different payload`,
+                            existingTurn: { ...existing },
+                        };
+                    }
+                    // Same id + same (or missing) payload: idempotent return, no new lease.
+                    return {
+                        ok: true,
+                        turn: { ...existing },
+                        created: false,
+                        idempotent: true,
+                    };
+                }
+            }
             const active = ring.turns.find((turn) => turn.state === "queued" || turn.state === "running");
             if (active)
-                return { ok: false, code: "TURN_ACTIVE", activeTurn: active };
+                return { ok: false, code: "TURN_ACTIVE", activeTurn: { ...active } };
             const ordinal = (turnCounts.get(sessionId) ?? 0) + 1;
             turnCounts.set(sessionId, ordinal);
             const now = new Date().toISOString();
@@ -536,11 +642,14 @@ export function createChatEventStore(options) {
                 ordinal,
                 state: "queued",
                 createdAt: now,
+                ownerEpoch: eventEpoch,
+                ...(clientRequestId ? { clientRequestId } : {}),
+                ...(payloadHash ? { payloadHash } : {}),
             };
             ring.turns.push(turn);
             ring.approxBytes += byteHint(turn);
             persist(sessionId, ring);
-            return { ok: true, turn };
+            return { ok: true, turn: { ...turn }, created: true, idempotent: false };
         },
         setTurnState(sessionId, turnId, state, error) {
             const ring = ringFor(sessionId);
@@ -561,6 +670,27 @@ export function createChatEventStore(options) {
             persist(sessionId, ring);
             return { ...turn };
         },
+        markAbortRequested(sessionId, turnId, at) {
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.turnId === turnId);
+            if (!turn)
+                return undefined;
+            const before = JSON.stringify(turn).length;
+            if (!turn.abortRequestedAt)
+                turn.abortRequestedAt = at ?? new Date().toISOString();
+            ring.approxBytes +=
+                (JSON.stringify(turn).length - before) * BYTE_GATE_SCALE;
+            persist(sessionId, ring);
+            return { ...turn };
+        },
+        findTurnByClientRequestId(sessionId, clientRequestId) {
+            const id = clientRequestId.trim();
+            if (!id)
+                return undefined;
+            const ring = ringFor(sessionId);
+            const turn = ring.turns.find((candidate) => candidate.clientRequestId === id);
+            return turn ? { ...turn } : undefined;
+        },
         getTurn(sessionId, turnId) {
             const ring = ringFor(sessionId);
             const turn = ring.turns.find((candidate) => candidate.turnId === turnId);