@tea-agent/loop-agent 0.34.3 → 0.34.5

package/dist/worker/console/chat/shortcuts.js

@@ -1,16 +1,215 @@
+/**
+ * Operator Chat slash command catalog (UI-11).
+ *
+ * Local Operator + Pi Web commands are always available. Dynamic extension /
+ * prompt / skill commands are merged via mergeSlashCommands with conflict
+ * priority: operator/web > extension > skill > prompt.
+ */
 export const SHORTCUTS = [
-    { command: "/task", label: "Task context", description: "查看当前任务、Draft 与 assessment", action: "focus-panel:task" },
-    { command: "/contract", label: "Contract", description: "查看 contract diff 与 apply gate", action: "focus-panel:contract" },
-    { command: "/dag", label: "DAG", description: "查看 DAG spine、确认与运行状态", action: "focus-panel:dag" },
-    { command: "/interview", label: "Interview", description: "打开 Requirement Interview", action: "focus:interview" },
-    { command: "/reload", label: "Reload session", description: "重新加载当前 Pi 会话的设置、扩展、技能、提示词、主题与上下文文件（不产生消息）", action: "reload" },
-    { command: "/help", label: "Shortcuts", description: "显示可用 shortcut", action: "show-help" },
+    {
+        command: "/task",
+        label: "Task context",
+        description: "查看当前任务、Draft 与 assessment",
+        action: "focus-panel:task",
+        source: "operator",
+    },
+    {
+        command: "/contract",
+        label: "Contract",
+        description: "查看 contract diff 与 apply gate",
+        action: "focus-panel:contract",
+        source: "operator",
+    },
+    {
+        command: "/dag",
+        label: "DAG",
+        description: "查看 DAG spine、确认与运行状态",
+        action: "focus-panel:dag",
+        source: "operator",
+    },
+    {
+        command: "/interview",
+        label: "Interview",
+        description: "打开 Requirement Interview",
+        action: "focus:interview",
+        source: "operator",
+    },
+    {
+        command: "/reload",
+        label: "Reload session",
+        description: "重新加载当前 Pi 会话的设置、扩展、技能、提示词、主题与上下文文件（不产生消息）",
+        action: "reload",
+        source: "operator",
+    },
+    {
+        command: "/help",
+        label: "Shortcuts",
+        description: "显示可用 shortcut",
+        action: "show-help",
+        source: "operator",
+    },
 ];
-/** Pure navigation/display resolver. It deliberately has no mutation decisions. */
+/** Pi Web commands with real browser-equivalent behavior (UI-11). */
+export const WEB_SLASH_COMMANDS = [
+    {
+        command: "/compact",
+        label: "压缩上下文",
+        description: "压缩当前会话上下文，释放 token",
+        action: "compact",
+        source: "web",
+    },
+    {
+        command: "/name",
+        label: "重命名会话",
+        description: "设置当前会话标题",
+        action: "name",
+        source: "web",
+    },
+    {
+        command: "/session",
+        label: "会话信息",
+        description: "显示当前会话元信息",
+        action: "session",
+        source: "web",
+    },
+    {
+        command: "/copy",
+        label: "复制回复",
+        description: "复制最后一条助手消息原文",
+        action: "copy",
+        source: "web",
+    },
+];
+const SOURCE_PRIORITY = {
+    operator: 0,
+    web: 1,
+    extension: 2,
+    skill: 3,
+    prompt: 4,
+};
+function normalizeCommandName(raw) {
+    const token = raw.trim().split(/\s+/, 1)[0] ?? "";
+    if (!token)
+        return "";
+    return token.startsWith("/") ? token.toLowerCase() : `/${token.toLowerCase()}`;
+}
+/** Pure navigation/display resolver for local Operator + Web commands. */
 export function resolveShortcut(input) {
     const token = input.trim().split(/\s+/, 1)[0]?.toLowerCase();
     if (!token?.startsWith("/"))
         return undefined;
-    const found = SHORTCUTS.find((shortcut) => shortcut.command === token);
-    return found ? { command: found.command, action: found.action } : { command: token, action: "unknown" };
+    const local = [...SHORTCUTS, ...WEB_SLASH_COMMANDS].find((shortcut) => shortcut.command === token);
+    if (local)
+        return { command: local.command, action: local.action };
+    return { command: token, action: "unknown" };
+}
+/**
+ * Merge Operator, Web, and dynamic Session commands with conflict dedupe.
+ * Priority: operator/web > extension > skill > prompt. /reload is single-card.
+ */
+export function mergeSlashCommands(dynamic = []) {
+    const byName = new Map();
+    const upsert = (item) => {
+        const key = normalizeCommandName(item.command);
+        if (!key)
+            return;
+        const existing = byName.get(key);
+        if (!existing) {
+            byName.set(key, { ...item, command: key });
+            return;
+        }
+        if (SOURCE_PRIORITY[item.source] < SOURCE_PRIORITY[existing.source]) {
+            byName.set(key, { ...item, command: key });
+        }
+    };
+    for (const item of SHORTCUTS) {
+        upsert({
+            command: item.command,
+            label: item.label,
+            description: item.description,
+            source: item.source,
+            action: item.action,
+        });
+    }
+    for (const item of WEB_SLASH_COMMANDS) {
+        upsert({
+            command: item.command,
+            label: item.label,
+            description: item.description,
+            source: item.source,
+            action: item.action,
+        });
+    }
+    for (const item of dynamic) {
+        const command = normalizeCommandName(item.command);
+        if (!command)
+            continue;
+        upsert({
+            command,
+            label: item.label || command,
+            description: item.description || "",
+            source: item.source,
+            action: "pi-prompt",
+        });
+    }
+    return [...byName.values()].sort((a, b) => {
+        const src = SOURCE_PRIORITY[a.source] - SOURCE_PRIORITY[b.source];
+        if (src !== 0)
+            return src;
+        return a.command.localeCompare(b.command);
+    });
+}
+/** Filter + rank slash candidates by name/description. */
+export function filterSlashCommands(commands, rawQuery) {
+    const token = (rawQuery.trim().split(/\s+/, 1)[0] ?? "").toLowerCase();
+    // After a space (args), hide the palette.
+    if (/\s/.test(rawQuery.trimStart().slice(1)) || rawQuery.includes(" ")) {
+        // Only hide when user has typed past the command token.
+        const after = rawQuery.trimStart();
+        if (after.includes(" "))
+            return [];
+    }
+    const q = token.startsWith("/") ? token : token ? `/${token}` : "/";
+    const needle = q === "/" ? "" : q.slice(1);
+    const scored = [];
+    for (const item of commands) {
+        const name = item.command.toLowerCase();
+        const bare = name.startsWith("/") ? name.slice(1) : name;
+        const desc = item.description.toLowerCase();
+        let score = 100;
+        if (!needle) {
+            score = 10 + SOURCE_PRIORITY[item.source];
+        }
+        else if (name === q || bare === needle) {
+            score = 0;
+        }
+        else if (name.startsWith(q) || bare.startsWith(needle)) {
+            score = 1;
+        }
+        else if (bare.includes(needle) || name.includes(needle)) {
+            score = 2;
+        }
+        else if (desc.includes(needle)) {
+            score = 3;
+        }
+        else {
+            continue;
+        }
+        scored.push({ ...item, score });
+    }
+    return scored.sort((a, b) => {
+        if (a.score !== b.score)
+            return a.score - b.score;
+        const src = SOURCE_PRIORITY[a.source] - SOURCE_PRIORITY[b.source];
+        if (src !== 0)
+            return src;
+        return a.command.localeCompare(b.command);
+    });
 }
+export const SLASH_SOURCE_LABEL = {
+    operator: "Operator",
+    web: "Pi Web",
+    extension: "Extensions",
+    prompt: "Prompts",
+    skill: "Skills",
+};

package/dist/worker/console/chat/tool-preview.js

@@ -1,13 +1,19 @@
 /**
- * Human-readable one-line preview for tool call arguments (pi-web getToolPreview).
+ * Human-readable tool argument / result projection for Operator Chat (UI-04).
+ *
+ * Display-only: never mutates raw Pi ToolResult, session JSONL, or model context.
  */
 const PREVIEW_KEYS = [
     "command",
+    "query",
+    "operation",
+    "tool",
+    "server",
+    "symbol",
     "path",
     "file_path",
     "filePath",
     "pattern",
-    "query",
     "glob",
     "url",
 ];
@@ -34,6 +40,76 @@ function parseArgs(args) {
     }
     return asRecord(args);
 }
+function clampOneLine(value, maxLen) {
+    const s = value.replace(/\s+/g, " ").trim();
+    if (!s)
+        return "";
+    return s.length > maxLen ? `${s.slice(0, maxLen)}…` : s;
+}
+function fieldString(input, key) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return undefined;
+}
+/** Tool-specific header adapters (display only). */
+function adapterPreview(toolName, input, maxLen) {
+    const name = (toolName ?? "").toLowerCase();
+    if (name === "bash" || name === "shell") {
+        const command = fieldString(input, "command");
+        return command ? clampOneLine(command, maxLen) : undefined;
+    }
+    if (name === "mcp" || name.startsWith("mcp_")) {
+        const server = fieldString(input, "server");
+        const tool = fieldString(input, "tool") ?? fieldString(input, "name");
+        const query = fieldString(input, "query");
+        if (server && tool)
+            return clampOneLine(`${server} · ${tool}`, maxLen);
+        if (tool)
+            return clampOneLine(tool, maxLen);
+        if (query)
+            return clampOneLine(query, maxLen);
+        if (server)
+            return clampOneLine(server, maxLen);
+        return undefined;
+    }
+    if (name === "lsp_navigation" || name.includes("lsp")) {
+        const parts = [
+            fieldString(input, "operation"),
+            fieldString(input, "symbol"),
+            fieldString(input, "path") ??
+                fieldString(input, "file_path") ??
+                fieldString(input, "filePath"),
+        ].filter(Boolean);
+        const line = fieldString(input, "line") ?? fieldString(input, "position");
+        if (parts.length === 0 && !line)
+            return undefined;
+        const base = parts.join(" · ");
+        return clampOneLine(line ? `${base}${base ? ":" : ""}${line}` : base, maxLen);
+    }
+    if (name === "symbol_search" || name.includes("symbol_search")) {
+        const query = fieldString(input, "query") ?? fieldString(input, "symbol");
+        return query ? clampOneLine(query, maxLen) : undefined;
+    }
+    if (name === "read" ||
+        name === "read_symbol" ||
+        name === "read_enclosing" ||
+        name.startsWith("read_")) {
+        const path = fieldString(input, "path") ??
+            fieldString(input, "file_path") ??
+            fieldString(input, "filePath");
+        const symbol = fieldString(input, "symbol");
+        const line = fieldString(input, "line");
+        if (!path && !symbol)
+            return undefined;
+        const bits = [path, symbol, line].filter(Boolean);
+        return clampOneLine(bits.join(" · "), maxLen);
+    }
+    // Family prefixes (pi-lens / codegraph) — generic field heuristic below.
+    return undefined;
+}
 /** One-line summary for a tool-call header; empty when nothing useful. */
 export function getToolPreview(args, options) {
     const maxLen = options?.maxLen ?? DEFAULT_PREVIEW_MAX;
@@ -47,11 +123,13 @@ export function getToolPreview(args, options) {
         }
         return "";
     }
+    const adapted = adapterPreview(options?.toolName, input, maxLen);
+    if (adapted)
+        return adapted;
     for (const key of PREVIEW_KEYS) {
         const value = input[key];
         if (typeof value === "string" && value.trim()) {
-            const s = value.replace(/\s+/g, " ").trim();
-            return s.length > maxLen ? `${s.slice(0, maxLen)}…` : s;
+            return clampOneLine(value, maxLen);
         }
     }
     const keys = Object.keys(input);
@@ -63,6 +141,83 @@ export function getToolPreview(args, options) {
         return "";
     return s.length > maxLen ? `${s.slice(0, maxLen)}…` : s;
 }
+/** Section labels for ToolCard expand body. */
+export function getToolSectionLabels(toolName) {
+    const name = (toolName ?? "").toLowerCase();
+    if (name === "bash" || name === "shell") {
+        return { argsLabel: "命令", resultLabel: "输出" };
+    }
+    if (name === "mcp" || name.startsWith("mcp_")) {
+        return { argsLabel: "参数", resultLabel: "结果" };
+    }
+    return { argsLabel: "入参", resultLabel: "结果" };
+}
+/**
+ * Extract human-readable text from a Pi ToolResult-like value or its
+ * already-serialized browser preview string.
+ */
+export function extractToolResultText(result) {
+    if (result === undefined || result === null)
+        return "";
+    if (typeof result === "string") {
+        const trimmed = result.trim();
+        if (!trimmed)
+            return "";
+        // Prefer unwrapping standard Pi ToolResult JSON shells.
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+            try {
+                return extractToolResultText(JSON.parse(trimmed));
+            }
+            catch {
+                return result;
+            }
+        }
+        return result;
+    }
+    if (typeof result === "number" || typeof result === "boolean") {
+        return String(result);
+    }
+    const record = asRecord(result);
+    if (!record) {
+        try {
+            return JSON.stringify(result, null, 2);
+        }
+        catch {
+            return String(result);
+        }
+    }
+    // Standard Pi ToolResult: { content: [{ type: "text", text }] }
+    const content = record.content;
+    if (Array.isArray(content)) {
+        const texts = [];
+        for (const block of content) {
+            const item = asRecord(block);
+            if (!item)
+                continue;
+            if (item.type === "text" && typeof item.text === "string") {
+                texts.push(item.text);
+            }
+            else if (typeof item.text === "string") {
+                texts.push(item.text);
+            }
+        }
+        if (texts.length > 0)
+            return texts.join("\n");
+    }
+    if (typeof record.text === "string")
+        return record.text;
+    if (typeof record.output === "string")
+        return record.output;
+    if (typeof record.message === "string")
+        return record.message;
+    try {
+        return JSON.stringify(result, null, 2);
+    }
+    catch {
+        return String(result);
+    }
+}
 export function formatToolArgsDisplay(args) {
     if (args === undefined || args === null)
         return "";
@@ -82,7 +237,9 @@ export function truncateToolResult(text, options) {
     return { text: `${text.slice(0, maxLen)}…`, truncated: true };
 }
 export function toolCallDurationSeconds(createdAt, finishedAt) {
-    if (finishedAt === undefined || !Number.isFinite(createdAt) || !Number.isFinite(finishedAt)) {
+    if (finishedAt === undefined ||
+        !Number.isFinite(createdAt) ||
+        !Number.isFinite(finishedAt)) {
         return undefined;
     }
     const secs = Math.round((finishedAt - createdAt) / 1000);

package/dist/worker/console/chat/turn-execution-registry.js

@@ -0,0 +1,82 @@
+/**
+ * Session-scoped ownership of in-flight Chat Turn executions.
+ *
+ * Registry entries must exist before HTTP 202 is returned, and every
+ * completion path (success / abort / failure) must clear them in finally so
+ * durable active leases cannot outlive the owning process.
+ */
+function keyFor(sessionId, turnId) {
+    return `${sessionId}\0${turnId}`;
+}
+export function createChatTurnExecutionRegistry() {
+    const entries = new Map();
+    const bySession = new Map();
+    return {
+        register(input) {
+            const existingSession = bySession.get(input.sessionId);
+            if (existingSession && existingSession !== input.turnId) {
+                throw new Error(`CHAT_TURN_EXECUTION_ACTIVE: ${input.sessionId} already owns ${existingSession}`);
+            }
+            const key = keyFor(input.sessionId, input.turnId);
+            const prior = entries.get(key);
+            if (prior)
+                return prior;
+            let resolveCompletion;
+            const completion = new Promise((resolve) => {
+                resolveCompletion = resolve;
+            });
+            // Prevent unhandled rejection if nobody awaits.
+            void completion.catch(() => undefined);
+            const entry = {
+                sessionId: input.sessionId,
+                turnId: input.turnId,
+                clientRequestId: input.clientRequestId,
+                controller: input.controller ?? new AbortController(),
+                completion,
+                resolveCompletion,
+            };
+            entries.set(key, entry);
+            bySession.set(input.sessionId, input.turnId);
+            return entry;
+        },
+        get(sessionId, turnId) {
+            return entries.get(keyFor(sessionId, turnId));
+        },
+        getBySession(sessionId) {
+            const turnId = bySession.get(sessionId);
+            if (!turnId)
+                return undefined;
+            return entries.get(keyFor(sessionId, turnId));
+        },
+        clear(sessionId, turnId) {
+            const key = keyFor(sessionId, turnId);
+            entries.delete(key);
+            if (bySession.get(sessionId) === turnId)
+                bySession.delete(sessionId);
+        },
+        async waitForCompletion(sessionId, turnId, timeoutMs) {
+            const entry = entries.get(keyFor(sessionId, turnId));
+            if (!entry)
+                return { status: "missing" };
+            let timer;
+            try {
+                const outcome = await Promise.race([
+                    entry.completion.then((value) => ({ kind: "done", value })),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+                    }),
+                ]);
+                if (outcome.kind === "timeout")
+                    return { status: "timeout" };
+                return { status: "completed", outcome: outcome.value };
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        },
+        size() {
+            return entries.size;
+        },
+    };
+}

package/dist/worker/console/dag-execution-receipt.js

@@ -22,6 +22,19 @@ import path from "node:path";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { readJsonIfExists, sha256Utf8, writeSecureJson, } from "./app-data.js";
 import { hashDagBytes, } from "./dag-confirmation.js";
+/**
+ * Structured verification command patterns for the G2 autonomous-execution
+ * gate. A DAG is only eligible for autonomous execution when it carries at
+ * least one shell verification node whose id or command is recognized as a
+ * real test/verification suite (not just an arbitrary shell command).
+ *
+ * Covers the Console workflow kinds: standard/frontend (npm run test/lint/
+ * typecheck, vitest, check-repo.sh), backend-test (pytest) and frontend-test
+ * (playwright). Ids ending in -verify / -verification / -validate / -gate are
+ * treated as verification shells by the caller; commands broaden the match to
+ * framework invocations that don't embed the word "verify".
+ */
+export const STRUCTURED_VERIFICATION_COMMAND_RE = /\b(vitest|jest|playwright|cypress|pytest|py-test|go\s+test|cargo\s+test|npm\s+run\s+(lint|typecheck|test|verify)|npm\s+(test|run\s+test)|check-repo\.sh|loop-agent-standard-verify)\b/i;
 export const DEFAULT_EXECUTION_RECEIPT_TTL_MS = 30 * 60 * 1000;
 function normalizePathEntry(entry) {
     return entry.trim().replace(/\\/g, "/").replace(/^\.\//, "");
@@ -145,7 +158,7 @@ export function deriveEligibilityFactsFromDagSpec(input) {
         if (/verify|verification/i.test(task.id ?? ""))
             return true;
         const commands = stringList(task.shell.commands);
-        return commands.some((command) => /(vitest|npm run (lint|typecheck|test)|check-repo\.sh|loop-agent-standard-verify)/.test(command));
+        return commands.some((command) => STRUCTURED_VERIFICATION_COMMAND_RE.test(command));
     });
     return {
         writersWriteSets: writers,

package/dist/worker/console/doctor.js

@@ -54,7 +54,7 @@ async function probeInspect(consoleBaseUrl, fetchImpl) {
             source: "static-assets",
             routeCapabilities,
             message: ready
-                ? "Inspect 静态资源可用；启动 agent-worker console serve 以提供统一入口"
+                ? "Inspect 静态资源可用；启动 agent-worker console 以提供统一入口"
                 : "Inspect 静态资源缺失；请运行构建或检查发布包",
         };
     }

package/dist/worker/console/index.js

@@ -2,6 +2,7 @@ export { createConsoleServer, defaultConsoleStaticDir } from "./server.js";
 export { buildOperatorSurfaceHealthV1 } from "./operator-surface-health.js";
 export { runConsoleDoctor, formatConsoleDoctorHuman } from "./doctor.js";
 export { isLoopbackHost } from "./loopback.js";
+export { shouldOpenConsoleBrowser, normalizeConsoleBrowserUrl, openSystemBrowser, maybeOpenConsoleBrowser, } from "./open-browser.js";
 export { repoFingerprintV1, normalizeWorktreeRealpath, } from "./repo-fingerprint.js";
 export { buildObserveDeepLink } from "./observe-link.js";
 export { classifyObserveHealth, probeAndClassifyObserve, capabilityForObserveTarget, OBSERVE_START_COMMAND, DEFAULT_OBSERVE_BASE_URL, } from "./observe-health-match.js";