@tea-agent/loop-agent 0.35.1-beta.4 → 0.35.2

package/dist/worker/console/chat/pi-runtime.js

@@ -28,6 +28,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { access } from "node:fs/promises";
 import path from "node:path";
+import { extractAssistantContentBlocks, extractAssistantText, } from "./assistant-content.js";
 import { projectCompactSnapshot, } from "./chat-event-store.js";
 import { extractUsageSample } from "./usage.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, authorizeOperatorChatTool, assertNoWriteToolInList, } from "./tools.js";
@@ -563,28 +564,7 @@ export function projectRuntimeSnapshot(input) {
         hasBash: input.hasBash,
     };
 }
-/**
- * Extract the latest assistant text fragment from an SDK message object.
- * Tolerant of multiple message shapes the SDK emits.
- */
-export function extractAssistantText(message) {
-    if (!message || typeof message !== "object")
-        return "";
-    const m = message;
-    if (typeof m.text === "string")
-        return m.text;
-    const contents = Array.isArray(m.content) ? m.content : [];
-    const parts = Array.isArray(m.parts) ? m.parts : [];
-    const segments = [];
-    for (const c of [...contents, ...parts]) {
-        if (!c || typeof c !== "object")
-            continue;
-        const seg = c;
-        if (typeof seg.text === "string")
-            segments.push(seg.text);
-    }
-    return segments.join("");
-}
+export { extractAssistantContentBlocks, extractAssistantText };
 function readSessionManagerId(manager) {
     if (!manager || typeof manager !== "object")
         return undefined;
@@ -2116,6 +2096,15 @@ export class ConsolePiRuntime {
             this.dispose(id);
     }
 }
+function mapAssistantMessageEvent(type, sessionId, message) {
+    const content = extractAssistantContentBlocks(message);
+    return {
+        type,
+        sessionId,
+        text: extractAssistantText(message),
+        ...(content.length > 0 ? { content } : {}),
+    };
+}
 function mapSdkEvent(sessionId, event) {
     switch (event.type) {
         case "agent_start":
@@ -2127,17 +2116,9 @@ function mapSdkEvent(sessionId, event) {
                 willRetry: Boolean(event.willRetry),
             };
         case "message_update":
-            return {
-                type: "message_update",
-                sessionId,
-                text: extractAssistantText(event.message),
-            };
+            return mapAssistantMessageEvent("message_update", sessionId, event.message);
         case "message_end":
-            return {
-                type: "message_end",
-                sessionId,
-                text: extractAssistantText(event.message),
-            };
+            return mapAssistantMessageEvent("message_end", sessionId, event.message);
         case "turn_end":
             // Usage is emitted from message_end (see prompt subscribe). turn_end
             // carries the same final assistant message and would double-count.

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

@@ -12,6 +12,7 @@
  * Mutation routes go through the Console mutation gate (boot token + Origin).
  * Read routes (GET capabilities / sessions) are open to loopback.
  */
+import { parseAssistantContent } from "./assistant-content.js";
 import { OPERATOR_CHAT_ALLOWED_TOOLS, OPERATOR_CHAT_DENIED_TOOLS, OPERATOR_CHAT_DENIED_OPERATOR_ACTIONS, } from "./tools.js";
 import { buildModelCallableToolSchemas } from "./tool-adapter.js";
 import { cleanChatTitle } from "./session-store.js";
@@ -83,12 +84,16 @@ function turnEventToStorePartial(event) {
         case "agent_start":
             return { kind: "agent_start", data: {} };
         case "message_update":
+        case "message_end": {
+            const content = parseAssistantContent(event.content);
             return {
-                kind: "message_update",
-                data: { text: String(event.text ?? "") },
+                kind: event.type,
+                data: {
+                    text: String(event.text ?? ""),
+                    ...(content ? { content } : {}),
+                },
             };
-        case "message_end":
-            return { kind: "message_end", data: { text: String(event.text ?? "") } };
+        }
         case "usage":
             return { kind: "usage", data: (event.usage ?? {}) };
         case "tool_call":

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

@@ -368,6 +368,9 @@ export async function runChatTurn(options) {
                         pending.push(store.appendMessage(sessionId, {
                             role: "assistant",
                             text: event.text,
+                            ...(event.content && event.content.length > 0
+                                ? { content: event.content }
+                                : {}),
                         }));
                     }
                     break;

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

@@ -41,13 +41,6 @@ export const SHORTCUTS = [
         action: "reload",
         source: "operator",
     },
-    {
-        command: "/help",
-        label: "Shortcuts",
-        description: "显示可用 shortcut",
-        action: "show-help",
-        source: "operator",
-    },
 ];
 /** Pi Web commands with real browser-equivalent behavior (UI-11). */
 export const WEB_SLASH_COMMANDS = [
@@ -103,6 +96,15 @@ export function resolveShortcut(input) {
         return { command: local.command, action: local.action };
     return { command: token, action: "unknown" };
 }
+/** Map Operator panel shortcuts onto Console workspace routes. */
+export function workspaceForShortcut(action) {
+    if (action === "focus-panel:task" || action === "focus-panel:contract") {
+        return "tasks";
+    }
+    if (action === "focus-panel:dag")
+        return "recovery";
+    return undefined;
+}
 /**
  * Merge Operator, Web, and dynamic Session commands with conflict dedupe.
  * Priority: operator/web > extension > skill > prompt. /reload is single-card.

package/dist/worker/console/chat/turn-process.js

@@ -1,6 +1,16 @@
 /**
  * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
  */
+import { joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
+function emptyGroup(key) {
+    return {
+        key,
+        assistants: [],
+        tools: [],
+        processItems: [],
+        live: false,
+    };
+}
 /**
  * Restore chat bubbles + tool cards from durable session messages.
  * Tool rows often appear before the final assistant `message_end` message;
@@ -36,11 +46,13 @@ export function hydrateSessionThread(raw) {
         if (item.role === "assistant") {
             if (!turnId)
                 turnId = `restored-${item.id}`;
+            const content = parseAssistantContent(item.content);
             messages.push({
                 id: item.id,
                 role: "assistant",
                 text: item.text,
                 createdAt,
+                ...(content && content.length > 0 ? { content } : {}),
             });
             flushPendingToAssistant(item.id);
             continue;
@@ -64,6 +76,45 @@ export function hydrateSessionThread(raw) {
     }
     return { messages, toolCalls };
 }
+function fillProcessDetails(group) {
+    const finalAssistant = group.assistants[group.assistants.length - 1];
+    const blocks = finalAssistant?.content ?? [];
+    const split = splitFinalAssistantBlocks(blocks, { isStreaming: group.live });
+    const usedToolIds = new Set();
+    const processItems = [];
+    for (const block of split.processBlocks) {
+        if (block.type === "thinking") {
+            processItems.push({ kind: "thinking", thinking: block.thinking });
+            continue;
+        }
+        if (block.type === "text") {
+            processItems.push({ kind: "text", text: block.text });
+            continue;
+        }
+        const tool = group.tools.find((entry) => entry.id === block.toolCallId);
+        if (tool) {
+            processItems.push({ kind: "tool", tool });
+            usedToolIds.add(tool.id);
+        }
+    }
+    for (const tool of group.tools) {
+        if (!usedToolIds.has(tool.id))
+            processItems.push({ kind: "tool", tool });
+    }
+    group.processItems = processItems;
+    if (!finalAssistant)
+        return;
+    if (blocks.length === 0) {
+        group.answer = finalAssistant;
+        return;
+    }
+    const answerText = joinAssistantText(split.answerBlocks);
+    group.answer = {
+        ...finalAssistant,
+        text: answerText,
+        content: split.answerBlocks,
+    };
+}
 /**
  * Build user → process → answer groups for the message timeline.
  */
@@ -72,12 +123,7 @@ export function buildTurnProcessGroups(input) {
     const groups = [];
     let current = null;
     const startGroup = (key) => {
-        const group = {
-            key,
-            assistants: [],
-            tools: [],
-            live: false,
-        };
+        const group = emptyGroup(key);
         groups.push(group);
         return group;
     };
@@ -92,12 +138,7 @@ export function buildTurnProcessGroups(input) {
         current.assistants.push(message);
     }
     if (groups.length === 0 && input.toolCalls.length > 0) {
-        groups.push({
-            key: "orphan-tools",
-            assistants: [],
-            tools: [],
-            live: false,
-        });
+        groups.push(emptyGroup("orphan-tools"));
     }
     const assigned = new Set();
     const assistantToGroup = new Map();
@@ -162,17 +203,23 @@ export function buildTurnProcessGroups(input) {
             input.streaming &&
                 input.activeAssistantId !== null &&
                 group.assistants.some((a) => a.id === input.activeAssistantId);
+        fillProcessDetails(group);
     }
     return groups;
 }
-export function processGroupSummary(tools) {
+export function processGroupSummary(tools, options) {
     const count = tools.length;
+    const thinkingCount = options?.thinkingCount ?? 0;
+    const textCount = options?.textCount ?? 0;
+    const stepCount = thinkingCount + textCount + count;
     const errorCount = tools.filter((t) => t.status === "error").length;
     const runningCount = tools.filter((t) => t.status === "running").length;
-    const parts = [`执行过程 · ${count} 工具`];
+    const parts = [`处理详情 · ${stepCount} 步`];
+    if (count > 0)
+        parts.push(`${count} 工具`);
     if (errorCount > 0)
         parts.push(`${errorCount} 出错`);
     else if (runningCount > 0)
         parts.push("运行中");
-    return { count, errorCount, runningCount, label: parts.join(" · ") };
+    return { count, errorCount, runningCount, stepCount, label: parts.join(" · ") };
 }

package/dist/worker/console/operator-actions.js

@@ -17,6 +17,9 @@ import { toCanonicalDraftForCli, } from "./draft-store.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
 import { appendEngineeringCliArgs, buildDraftFromTaskIntake, parseEngineeringBoundaryFromParams, } from "./prd-intake-bridge.js";
+import { discoverPrdReferences } from "./prd-reference-discovery.js";
+import { clearSemanticIntakeAttempt } from "../../task/source-prepare/semantic-intake.js";
+import nodePath from "node:path";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
 import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
@@ -1364,7 +1367,9 @@ export async function dispatchOperatorAction(ctx, req) {
             if (!taskId || !content) {
                 return invalid(action, "taskId and content are required");
             }
-            const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+            const taskKindRaw = str(p.taskKind)?.trim();
+            const taskKind = normalizeConsoleWorkflowKind(taskKindRaw, "standard");
+            const taskKindExplicit = Boolean(taskKindRaw);
             const engineering = parseEngineeringBoundaryFromParams(p);
             const identity = deriveTaskIdentityFromPrd(content);
             const title = str(p.title) ?? identity.title;
@@ -1407,7 +1412,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 };
             }
             const intakeArgs = ["task", "advance", taskId, "--json"];
-            if (taskKind && taskKind !== "standard") {
+            if (taskKindExplicit) {
                 intakeArgs.push("--task-kind", taskKind);
             }
             appendEngineeringCliArgs(intakeArgs, engineering);
@@ -1424,6 +1429,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 taskId,
                 title,
                 taskKind,
+                taskKindExplicit,
                 advanceJson: intakeJson,
                 engineering,
             });
@@ -2495,7 +2501,38 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         return invalid("bootstrapFromPrd", parsedDocs.message);
     }
     const documents = parsedDocs.documents;
-    const taskKind = normalizeConsoleWorkflowKind(str(p.taskKind), "standard");
+    // B1: free-form prose that references repo-local markdown paths (e.g.
+    // "请参照这三个prd路径 docs/product-analysis/foo.md …") only materializes
+    // the sentence itself. Discover the referenced files and import them as
+    // additional documents so intake has real requirement facts to structure.
+    let autoImportedReferences = [];
+    let unresolvedReferences = [];
+    const autoDocs = [];
+    if (!documents) {
+        const discovery = await discoverPrdReferences({
+            prose: content,
+            repoRoot: ctx.repoRoot,
+        });
+        autoImportedReferences = discovery.references.map((r) => ({
+            repoRelative: r.repoRelative,
+            role: r.role,
+        }));
+        unresolvedReferences = discovery.unresolved;
+        for (const ref of discovery.references) {
+            const absolute = nodePath.resolve(ctx.repoRoot, ref.repoRelative);
+            const refContent = await readFile(absolute, "utf-8").catch(() => "");
+            if (!refContent.trim())
+                continue;
+            autoDocs.push({
+                name: ref.repoRelative.split("/").pop() ?? ref.repoRelative,
+                content: refContent,
+                fileName: ref.repoRelative,
+            });
+        }
+    }
+    const taskKindRaw = str(p.taskKind)?.trim();
+    const taskKind = normalizeConsoleWorkflowKind(taskKindRaw, "standard");
+    const taskKindExplicit = Boolean(taskKindRaw);
     const engineering = parseEngineeringBoundaryFromParams(p);
     const identity = deriveTaskIdentityFromPrd(content);
     let taskId;
@@ -2547,7 +2584,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
     }
     const succeededImports = [];
     const importResults = [];
-    const runImportViaAdvance = async (label, text, name) => {
+    const runImportViaAdvance = async (label, text, name, role = "requirement") => {
         const staged = await stageUtf8Text(ctx.appData, text, {
             extension: ".md",
         });
@@ -2558,7 +2595,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
             "--prd",
             staged.path,
             "--role",
-            "requirement",
+            role,
             "--json",
         ], {
             cwd: ctx.repoRoot,
@@ -2599,6 +2636,23 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         if (composedFailure)
             return composedFailure;
     }
+    else if (autoDocs.length > 0) {
+        // B1: discovered repo-local references become explicit imports (role
+        // inferred per document), then the prose itself imports as composed.
+        const roleByBase = new Map(autoImportedReferences.map((r) => {
+            const base = r.repoRelative.split("/").pop() ?? r.repoRelative;
+            return [base, r.role];
+        }));
+        for (const doc of autoDocs) {
+            const role = roleByBase.get(doc.name) ?? "requirement";
+            const failure = await runImportViaAdvance(doc.name, doc.content, doc.name, role);
+            if (failure)
+                return failure;
+        }
+        const composedFailure = await runImportViaAdvance("composed", content, "composed");
+        if (composedFailure)
+            return composedFailure;
+    }
     else {
         const staged = await stageUtf8Text(ctx.appData, content, {
             extension: ".md",
@@ -2625,11 +2679,16 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         }
         importResults.push(imported.json ?? null);
     }
+    // C: a fresh import (manual or discovered) is new evidence; clear the
+    // one-shot semantic-intake attempt marker so intake may run again.
+    if (succeededImports.length > 0) {
+        await clearSemanticIntakeAttempt(ctx.repoRoot, taskId);
+    }
     // Phase 2 (design 2026-08-11): drive task advance intake after import so
     // deterministic parse + one-shot Semantic Intake run on archived references.
     // Timeout is longer than import: Pi MED may take minutes.
     const intakeArgs = ["task", "advance", taskId, "--json"];
-    if (taskKind && taskKind !== "standard") {
+    if (taskKindExplicit) {
         intakeArgs.push("--task-kind", taskKind);
     }
     appendEngineeringCliArgs(intakeArgs, engineering);
@@ -2646,6 +2705,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         taskId,
         title,
         taskKind,
+        taskKindExplicit,
         advanceJson: intakeJson,
         engineering,
     });
@@ -2679,7 +2739,13 @@ async function dispatchBootstrapFromPrd(ctx, p) {
             imports: importResults,
             documentNames: documents && documents.length > 0
                 ? [...documents.map((d) => d.name), "composed"]
+                : autoDocs.length > 0
+                    ? [...autoDocs.map((d) => d.name), "composed"]
+                    : undefined,
+            autoImportedReferences: autoImportedReferences.length > 0
+                ? autoImportedReferences
                 : undefined,
+            unresolvedReferences: unresolvedReferences.length > 0 ? unresolvedReferences : undefined,
             draftPreview: {
                 objective: draftSaved.draft.requirement?.objective ?? null,
                 scope: draftSaved.draft.requirement?.scope ?? [],

package/dist/worker/console/prd-intake-bridge.js

@@ -215,6 +215,7 @@ export function applyEngineeringBoundaryToDraft(draft, boundary) {
 }
 export async function buildDraftFromTaskIntake(input) {
     const taskKind = normalizeConsoleWorkflowKind(input.taskKind, "standard");
+    const taskKindExplicit = Boolean(input.taskKindExplicit);
     const paths = getTaskPaths(input.repoRoot, input.taskId);
     const warnings = warningList(input.advanceJson);
     const lifecycleState = lifecycleFromAdvanceJson(input.advanceJson);
@@ -262,6 +263,14 @@ export async function buildDraftFromTaskIntake(input) {
         const semDraftConstraints = artifact?.draft?.constraints;
         const semDraftVerification = artifact?.draft?.verification;
         const semTaskKind = artifact?.draft?.taskKind?.trim();
+        // User-explicit Console taskKind is a hard contract: semantic intake
+        // must never overwrite it (it may recommend backend-test for prose like
+        // "削减单元测试数量" even when the operator picked standard/后端研发).
+        const resolvedTaskKind = taskKindExplicit
+            ? taskKind
+            : semTaskKind
+                ? normalizeConsoleWorkflowKind(semTaskKind, taskKind)
+                : taskKind;
         const mergedAllowed = filterPlaceholderPaths(semDraftConstraints?.allowedPaths);
         const mergedForbidden = filterPlaceholderPaths(semDraftConstraints?.forbiddenPaths);
         const mergedVerify = Array.isArray(semDraftVerification?.commands)
@@ -280,9 +289,7 @@ export async function buildDraftFromTaskIntake(input) {
         draft = {
             ...draft,
             title,
-            ...(semTaskKind
-                ? { taskKind: normalizeConsoleWorkflowKind(semTaskKind, taskKind) }
-                : {}),
+            taskKind: resolvedTaskKind,
             requirement: {
                 objective: semanticReq.objective.trim(),
                 scope: asStringList(semanticReq.scope),

package/dist/worker/console/prd-reference-discovery.js

@@ -0,0 +1,124 @@
+/**
+ * B1: discover repo-local markdown references inside free-form PRD prose.
+ *
+ * Console "文字录入" flows often paste one sentence like
+ * "请参照这三个prd路径 docs/product-analysis/foo/*.md 完成业务需求".
+ * The deterministic import only materializes the sentence itself; the
+ * referenced files never reach source/references/, so semantic intake has
+ * no requirement facts to structure. This module extracts candidate
+ * repo-relative .md paths from the prose, filters exclusions, and resolves
+ * each to an importable document (path + inferred role) so the caller can
+ * auto-import them before intake.
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { resolvePrdImportRole } from "../../task/source-prepare/artifact-meta.js";
+/** Repo paths that must never be auto-imported as PRD references. */
+const EXCLUDED_PREFIXES = [
+    ".harness/",
+    "node_modules/",
+    ".git/",
+    "ai_workspace/",
+    "dist/",
+    "build/",
+    "coverage/",
+];
+/** Derived contract files are never valid PRD inputs. */
+const EXCLUDED_BASENAMES = new Set(["需求.md", "执行约束.md"]);
+/** Markdown path tokens with unicode path segments (supports Chinese dirs/files). */
+const MD_PATH_TOKEN_RE = /(?:[\w\u4e00-\u9fff.-]+\/)+[\w\u4e00-\u9fff.-]+\.(?:md|markdown)\b/gu;
+/** Strip URLs so their path fragments are never treated as repo paths. */
+const URL_RE = /(?:https?|ftp|file):\/\/[^\s\u4e00-\u9fff\uff08\uff09]+/gu;
+const MAX_AUTO_IMPORT_BYTES = 512 * 1024;
+const MAX_AUTO_IMPORT_COUNT = 8;
+function isExcluded(repoRelative) {
+    const posix = repoRelative.replace(/\\/g, "/");
+    for (const prefix of EXCLUDED_PREFIXES) {
+        if (posix === prefix.slice(0, -1) || posix.startsWith(prefix)) {
+            return `excluded prefix ${prefix}`;
+        }
+    }
+    const base = posix.split("/").pop() ?? posix;
+    if (EXCLUDED_BASENAMES.has(base)) {
+        return `derived contract file ${base}`;
+    }
+    return null;
+}
+/**
+ * Extract candidate markdown path tokens from free-form prose.
+ * Returns unique tokens in first-occurrence order.
+ */
+export function extractPrdPathTokens(prose) {
+    const withoutUrls = prose.replace(URL_RE, " ");
+    const seen = new Set();
+    const out = [];
+    for (const match of withoutUrls.matchAll(MD_PATH_TOKEN_RE)) {
+        const token = match[0];
+        if (!token || token.length <= "x.md".length)
+            continue;
+        if (seen.has(token))
+            continue;
+        seen.add(token);
+        out.push(token);
+        if (out.length >= 32)
+            break;
+    }
+    return out;
+}
+/**
+ * Resolve prose path tokens against the repo root. Existing, non-excluded,
+ * size-bounded markdown files become importable references.
+ */
+export async function discoverPrdReferences(input) {
+    const tokens = extractPrdPathTokens(input.prose);
+    const references = [];
+    const unresolved = [];
+    for (const token of tokens) {
+        if (references.length >= MAX_AUTO_IMPORT_COUNT) {
+            unresolved.push({ token, reason: "auto-import limit reached" });
+            continue;
+        }
+        const repoRelative = token.replace(/\\/g, "/");
+        const excludedReason = isExcluded(repoRelative);
+        if (excludedReason) {
+            unresolved.push({ token, reason: excludedReason });
+            continue;
+        }
+        const absolute = path.resolve(input.repoRoot, repoRelative);
+        // Defense in depth: resolved candidates must stay under repoRoot.
+        const rel = path.relative(input.repoRoot, absolute);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) {
+            unresolved.push({ token, reason: "outside repo root" });
+            continue;
+        }
+        let content;
+        try {
+            const fileStat = await stat(absolute);
+            if (!fileStat.isFile()) {
+                unresolved.push({ token, reason: "not a regular file" });
+                continue;
+            }
+            if (fileStat.size > MAX_AUTO_IMPORT_BYTES) {
+                unresolved.push({
+                    token,
+                    reason: `exceeds ${MAX_AUTO_IMPORT_BYTES} bytes`,
+                });
+                continue;
+            }
+            content = await readFile(absolute, "utf-8");
+        }
+        catch {
+            unresolved.push({ token, reason: "not found in repo" });
+            continue;
+        }
+        references.push({
+            repoRelative,
+            role: resolvePrdImportRole({
+                filePath: absolute,
+                markdown: content,
+            }),
+            sizeBytes: Buffer.byteLength(content, "utf-8"),
+        });
+    }
+    return { references, unresolved };
+}