@tea-agent/loop-agent 0.35.4-beta.0 → 0.36.0

package/dist/worker/console/chat/semantic-activity.js

@@ -0,0 +1,465 @@
+const TECHNICAL_ONLY_TOOLS = new Set([
+    "operatorCapabilities",
+    "operationList",
+    "operationGet",
+    "operationEventSummary",
+    "statsContext",
+    "sourceInstructions",
+    "spineCheck",
+    "inspect",
+    "observeLink",
+]);
+export function semanticToolPresentation(toolName) {
+    if (TECHNICAL_ONLY_TOOLS.has(toolName))
+        return "technical-only";
+    if (toolName === "doctor")
+        return "inline-detail";
+    return "activity-detail";
+}
+const OPERATION_TITLES = {
+    newTask: "创建任务",
+    importPrd: "任务需求",
+    contractShow: "任务边界",
+    contractApply: "更新任务契约",
+    contractDiff: "任务契约差异",
+    contractDraftSave: "任务契约草稿",
+    contractValidate: "检查任务契约",
+    taskAdvance: "推进任务准备",
+    dagRunTask: "执行流程",
+    dagValidate: "校验执行流程",
+    prepareDagConfirmation: "执行确认",
+    confirmDagConfirmation: "确认执行边界",
+    prepareDagExecution: "执行边界",
+    runDag: "任务执行",
+    operationWait: "执行监督",
+    operationGet: "任务活动详情",
+    operationList: "会话活动",
+    operationEventSummary: "执行进展摘要",
+    dagStatus: "执行状态",
+    dagDoctor: "执行诊断",
+    dagReport: "执行结果",
+    dagRerunPlan: "恢复评估",
+    standaloneTaskRerun: "恢复执行",
+    workerTaskRetry: "重试任务",
+    promoteRun: "任务推进",
+    status: "任务状态",
+};
+const TOOL_SEMANTICS = {
+    newTask: {
+        running: "正在创建任务",
+        success: "任务已经创建",
+        error: "创建任务时遇到问题",
+    },
+    importPrd: {
+        running: "正在整理并导入任务需求",
+        success: "任务需求已经导入",
+        error: "导入任务需求时遇到问题",
+    },
+    contractShow: {
+        running: "正在读取任务目标和执行边界",
+        success: "任务目标与执行边界已经读取",
+        error: "读取任务边界时遇到问题",
+    },
+    taskAdvance: {
+        running: "正在推进任务契约并准备执行流程",
+        success: "任务已经推进到下一安全阶段",
+        error: "任务推进被契约或执行边界阻塞",
+    },
+    dagRunTask: {
+        running: "正在生成并校验执行流程",
+        success: "执行流程已经准备好",
+        error: "准备执行流程时遇到问题",
+    },
+    prepareDagExecution: {
+        running: "正在确认任务可以安全执行",
+        success: "执行边界已经确认",
+        error: "执行边界尚未通过确认",
+    },
+    runDag: {
+        running: "正在启动任务执行",
+        success: "任务执行已经启动",
+        error: "启动任务执行时遇到问题",
+    },
+    dagReport: {
+        running: "正在读取本次执行结果",
+        success: "本次执行结果已经读取",
+        error: "读取执行结果时遇到问题",
+    },
+    dagRerunPlan: {
+        running: "正在评估能否从失败位置继续",
+        success: "恢复条件评估已经完成",
+        error: "暂时无法确定安全的恢复方式",
+    },
+    standaloneTaskRerun: {
+        running: "正在从失败位置恢复执行",
+        success: "已经从失败位置继续执行",
+        error: "从失败位置恢复执行时遇到问题",
+    },
+    promoteRun: {
+        running: "正在推进任务状态",
+        success: "任务状态已经更新",
+        error: "推进任务状态时遇到问题",
+    },
+    status: {
+        running: "正在读取任务状态",
+        success: "任务状态已经更新",
+        error: "读取任务状态时遇到问题",
+    },
+    contractApply: {
+        running: "正在应用任务契约变更",
+        success: "任务契约已经更新",
+        error: "应用任务契约变更时遇到问题",
+    },
+    contractDiff: {
+        running: "正在比较任务契约版本",
+        success: "任务契约差异已经读取",
+        error: "比较任务契约时遇到问题",
+    },
+    contractDraftSave: {
+        running: "正在保存任务契约草稿",
+        success: "任务契约草稿已经保存",
+        error: "保存任务契约草稿时遇到问题",
+    },
+    contractValidate: {
+        running: "正在检查任务契约",
+        success: "任务契约检查已经完成",
+        error: "任务契约检查没有通过",
+    },
+    dagValidate: {
+        running: "正在校验执行流程",
+        success: "执行流程校验已经通过",
+        error: "执行流程校验没有通过",
+    },
+    prepareDagConfirmation: {
+        running: "正在准备执行确认",
+        success: "执行确认已经准备好",
+        error: "准备执行确认时遇到问题",
+    },
+    confirmDagConfirmation: {
+        running: "正在确认执行边界",
+        success: "执行边界已经确认",
+        error: "执行边界尚未通过确认",
+    },
+    operationGet: {
+        running: "正在读取任务活动详情",
+        success: "任务活动详情已经读取",
+        error: "读取任务活动详情时遇到问题",
+    },
+    operationList: {
+        running: "正在读取本次对话的活动",
+        success: "本次对话的活动已经读取",
+        error: "读取对话活动时遇到问题",
+    },
+    operationEventSummary: {
+        running: "正在汇总执行进展",
+        success: "执行进展已经汇总",
+        error: "汇总执行进展时遇到问题",
+    },
+    dagStatus: {
+        running: "正在读取执行状态",
+        success: "执行状态已经更新",
+        error: "读取执行状态时遇到问题",
+    },
+    dagDoctor: {
+        running: "正在诊断本次任务执行",
+        success: "任务执行诊断已经完成",
+        error: "诊断任务执行时遇到问题",
+    },
+    workerTaskRetry: {
+        running: "正在重试失败的任务",
+        success: "失败任务已经重新开始",
+        error: "重试失败任务时遇到问题",
+    },
+    doctor: {
+        running: "正在检查运行环境",
+        success: "运行环境检查已经完成",
+        error: "运行环境检查发现问题",
+    },
+    inspect: {
+        running: "正在读取详细运行信息",
+        success: "详细运行信息已经读取",
+        error: "读取详细运行信息时遇到问题",
+    },
+    observeLink: {
+        running: "正在准备运行看板入口",
+        success: "运行看板入口已经准备好",
+        error: "准备运行看板入口时遇到问题",
+    },
+    operatorCapabilities: {
+        running: "正在读取可用操作能力",
+        success: "可用操作能力已经读取",
+        error: "读取可用操作能力时遇到问题",
+    },
+    sourceInstructions: {
+        running: "正在读取任务来源说明",
+        success: "任务来源说明已经读取",
+        error: "读取任务来源说明时遇到问题",
+    },
+    spineCheck: {
+        running: "正在检查计划执行步骤",
+        success: "计划执行步骤检查已经完成",
+        error: "计划执行步骤检查发现问题",
+    },
+    statsContext: {
+        running: "正在统计上下文使用情况",
+        success: "上下文使用情况已经统计完成",
+        error: "统计上下文使用情况时遇到问题",
+    },
+};
+const NODE_LABELS = [
+    {
+        pattern: /(?:^|-)contract(?:-pi)?$/i,
+        running: "正在核对任务目标和执行边界",
+        finished: "任务目标与执行边界已确认",
+        error: "任务边界存在冲突，需要先处理",
+    },
+    {
+        pattern: /scout-src/i,
+        running: "正在梳理与任务相关的代码",
+        finished: "相关代码范围已梳理",
+        error: "梳理相关代码时遇到问题",
+    },
+    {
+        pattern: /scout-tests/i,
+        running: "正在检查现有测试和验证方式",
+        finished: "现有测试与验证方式已确认",
+        error: "检查现有测试时遇到问题",
+    },
+    {
+        pattern: /plan/i,
+        running: "正在整理具体实施步骤",
+        finished: "实施步骤已经准备好",
+        error: "实施方案还需要进一步完善",
+    },
+    {
+        pattern: /implement|writer/i,
+        running: "正在修改并保存相关文件",
+        finished: "文件修改已经完成",
+        error: "修改文件时遇到问题",
+    },
+    {
+        pattern: /verify|reverify/i,
+        running: "正在验证本次修改",
+        finished: "本次修改已通过验证",
+        error: "验证没有通过，正在检查原因",
+    },
+    {
+        pattern: /review/i,
+        running: "正在检查改动是否完整",
+        finished: "改动完整性检查已通过",
+        error: "发现需要补充或修正的内容",
+    },
+    {
+        pattern: /closeout/i,
+        running: "正在整理交付结果",
+        finished: "任务已经完成并形成交付记录",
+        error: "交付结果尚未整理完整",
+    },
+];
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return value;
+}
+function parseJsonRecord(value) {
+    if (value && typeof value === "object")
+        return value;
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return asRecord(JSON.parse(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function operationIdFromArgs(args) {
+    const record = parseJsonRecord(args);
+    const operationId = record?.operationId;
+    return typeof operationId === "string" && operationId ? operationId : undefined;
+}
+function maxWaitSeconds(args) {
+    const record = parseJsonRecord(args);
+    const raw = record?.maxWaitMs;
+    if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0)
+        return undefined;
+    return Math.max(1, Math.round(raw / 1000));
+}
+function activityRefForTool(tool) {
+    const operationId = operationIdFromArgs(tool.args);
+    return operationId ? `operation:${operationId}` : `tool:${tool.id}`;
+}
+function semanticKindForStatus(status) {
+    if (status === "running")
+        return "progress";
+    if (status === "error")
+        return "error";
+    return "success";
+}
+function resultRecord(tool) {
+    return parseJsonRecord(tool.resultText ?? tool.result);
+}
+function eventMessages(record) {
+    if (!Array.isArray(record.events))
+        return [];
+    return record.events.flatMap((value) => {
+        const event = asRecord(value);
+        if (!event)
+            return [];
+        const message = event.messagePreview ?? event.message;
+        return typeof message === "string" ? [message] : [];
+    });
+}
+function nodeActivityFromMessages(messages, id, activityRef) {
+    const facts = [];
+    for (const message of messages) {
+        for (const match of message.matchAll(/node-(started|finished)[^\n]*?node=([^\s,]+)/gi)) {
+            const lifecycle = match[1]?.toLowerCase();
+            const node = match[2] ?? "";
+            const statusMatch = message.match(/status=([^\s,]+)/i)?.[1]?.toUpperCase();
+            let status = "finished";
+            if (statusMatch === "ERROR" || statusMatch === "FAILED")
+                status = "error";
+            else if (lifecycle === "started")
+                status = "running";
+            facts.push({ node, status });
+        }
+    }
+    const latest = facts.at(-1);
+    if (!latest)
+        return undefined;
+    const scoutSrcFinished = facts.some((fact) => /scout-src/i.test(fact.node) && fact.status === "finished");
+    const scoutTestsFinished = facts.some((fact) => /scout-tests/i.test(fact.node) && fact.status === "finished");
+    if (scoutSrcFinished && scoutTestsFinished) {
+        return {
+            id,
+            kind: "success",
+            title: "代码与测试的影响范围已确认",
+            activityRef,
+        };
+    }
+    const label = NODE_LABELS.find((candidate) => candidate.pattern.test(latest.node));
+    if (!label) {
+        return { id, kind: "success", title: "执行状态已经更新", activityRef };
+    }
+    if (latest.status === "running") {
+        return { id, kind: "progress", title: label.running, activityRef };
+    }
+    if (latest.status === "error") {
+        return { id, kind: "error", title: label.error, activityRef };
+    }
+    return { id, kind: "success", title: label.finished, activityRef };
+}
+function operationWaitActivity(tool) {
+    const activityRef = activityRefForTool(tool);
+    const id = `activity:${tool.id}`;
+    const seconds = maxWaitSeconds(tool.args);
+    if (tool.status === "running") {
+        return {
+            id,
+            kind: "progress",
+            title: seconds
+                ? `正在等待新的执行进展，最长等待时间 ${seconds} 秒`
+                : "正在等待新的执行进展",
+            activityRef,
+        };
+    }
+    if (tool.status === "error") {
+        return {
+            id,
+            kind: "error",
+            title: "等待执行进展时遇到问题",
+            activityRef,
+        };
+    }
+    let rawResult = "";
+    if (typeof tool.resultText === "string")
+        rawResult = tool.resultText;
+    else if (typeof tool.result === "string")
+        rawResult = tool.result;
+    const record = resultRecord(tool);
+    const nodeActivity = nodeActivityFromMessages([rawResult, ...(record ? eventMessages(record) : [])], id, activityRef);
+    if (nodeActivity)
+        return nodeActivity;
+    if (record) {
+        if (record.timedOut === true || record.changed === false) {
+            return {
+                id,
+                kind: "warning",
+                title: "等待期间没有新的执行进展",
+                activityRef,
+            };
+        }
+        if (record.changed === true) {
+            return {
+                id,
+                kind: "success",
+                title: "已经收到新的执行进展",
+                activityRef,
+            };
+        }
+    }
+    return {
+        id,
+        kind: "success",
+        title: "执行状态已经更新",
+        activityRef,
+    };
+}
+/**
+ * Return a deterministic, human-written semantic event for Operator tools.
+ * Ordinary read/bash/edit tools intentionally return undefined and retain the
+ * existing technical ToolCard representation.
+ */
+export function semanticActivityForTool(tool) {
+    const presentation = semanticToolPresentation(tool.toolName);
+    if (presentation === "technical-only" || presentation === "inline-detail") {
+        return undefined;
+    }
+    if (tool.toolName === "operationWait")
+        return operationWaitActivity(tool);
+    const semantic = TOOL_SEMANTICS[tool.toolName];
+    if (!semantic)
+        return undefined;
+    let title = semantic.success;
+    if (tool.status === "running")
+        title = semantic.running;
+    else if (tool.status === "error")
+        title = semantic.error;
+    return {
+        id: `activity:${tool.id}`,
+        kind: semanticKindForStatus(tool.status),
+        title,
+        activityRef: activityRefForTool(tool),
+    };
+}
+export function semanticOperationTitle(action) {
+    return OPERATION_TITLES[action] ?? "任务活动";
+}
+export function semanticOperationState(state) {
+    switch (state) {
+        case "starting":
+            return { label: "正在启动", kind: "progress" };
+        case "running":
+            return { label: "运行中", kind: "progress" };
+        case "succeeded":
+        case "finished":
+        case "FINISHED":
+        case "pass":
+            return { label: "已完成", kind: "success" };
+        case "failed":
+        case "partial_failed":
+        case "ERROR":
+        case "FAILED":
+        case "timed-out":
+            return { label: "未完成", kind: "error" };
+        case "needs-reconcile":
+            return { label: "需要同步", kind: "warning" };
+        case "cancelled":
+        case "abandoned":
+        case "superseded":
+            return { label: "已停止", kind: "warning" };
+        default:
+            return { label: "状态已更新", kind: "success" };
+    }
+}

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

@@ -2,6 +2,7 @@
  * Turn grouping for Operator Chat inline process UX (pi-web ProcessDetails mind).
  */
 import { getDisplayableAssistantBlocks, joinAssistantText, parseAssistantContent, splitFinalAssistantBlocks, } from "./assistant-content.js";
+import { semanticActivityForTool, } from "./semantic-activity.js";
 function emptyGroup(key) {
     return {
         key,
@@ -76,6 +77,13 @@ export function hydrateSessionThread(raw) {
     }
     return { messages, toolCalls };
 }
+function pushToolProcessItem(processItems, tool) {
+    const activity = semanticActivityForTool(tool);
+    if (activity)
+        processItems.push({ kind: "activity", activity });
+    else
+        processItems.push({ kind: "tool", tool });
+}
 function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
     for (const block of blocks) {
         if (block.type === "thinking") {
@@ -89,7 +97,7 @@ function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
         }
         const tool = group.tools.find((entry) => entry.id === block.toolCallId);
         if (tool) {
-            processItems.push({ kind: "tool", tool });
+            pushToolProcessItem(processItems, tool);
             usedToolIds.add(tool.id);
         }
     }
@@ -98,7 +106,7 @@ function fillProcessDetails(group) {
     const usedToolIds = new Set();
     const processItems = [];
     const prior = group.assistants.slice(0, -1);
-    const finalAssistant = group.assistants[group.assistants.length - 1];
+    const finalAssistant = group.assistants.at(-1);
     for (const assistant of prior) {
         emitProcessBlocks(getDisplayableAssistantBlocks(assistant.content ?? []), group, processItems, usedToolIds);
     }
@@ -107,7 +115,7 @@ function fillProcessDetails(group) {
     emitProcessBlocks(split.processBlocks, group, processItems, usedToolIds);
     for (const tool of group.tools) {
         if (!usedToolIds.has(tool.id))
-            processItems.push({ kind: "tool", tool });
+            pushToolProcessItem(processItems, tool);
     }
     group.processItems = processItems;
     if (!finalAssistant)
@@ -161,7 +169,6 @@ export function buildTurnProcessGroups(input) {
             if (group) {
                 group.tools.push(tool);
                 assigned.add(tool.id);
-                continue;
             }
         }
     }
@@ -183,7 +190,6 @@ export function buildTurnProcessGroups(input) {
             if (restored) {
                 restored.tools.push(tool);
                 assigned.add(tool.id);
-                continue;
             }
         }
     }
@@ -200,13 +206,21 @@ export function buildTurnProcessGroups(input) {
             windowGroup.tools.push(tool);
             assigned.add(tool.id);
         }
-        else if (groups.length > 0) {
-            groups[groups.length - 1].tools.push(tool);
-            assigned.add(tool.id);
+        else {
+            const lastGroup = groups.at(-1);
+            if (lastGroup) {
+                lastGroup.tools.push(tool);
+                assigned.add(tool.id);
+            }
         }
     }
     for (const group of groups) {
-        group.tools.sort((a, b) => a.createdAt - b.createdAt);
+        group.tools.sort((a, b) => {
+            if (a.eventSeq !== undefined && b.eventSeq !== undefined) {
+                return a.eventSeq - b.eventSeq;
+            }
+            return a.createdAt - b.createdAt;
+        });
         group.live =
             input.streaming &&
                 input.activeAssistantId !== null &&
@@ -219,12 +233,17 @@ 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 activityCount = options?.activityCount ?? 0;
+    const stepCount = thinkingCount + textCount + activityCount + count;
+    const errorCount = tools.filter((t) => t.status === "error").length +
+        (options?.activityErrorCount ?? 0);
+    const runningCount = tools.filter((t) => t.status === "running").length +
+        (options?.activityRunningCount ?? 0);
     const parts = [`处理详情 · ${stepCount} 步`];
     if (count > 0)
         parts.push(`${count} 工具`);
+    if (activityCount > 0)
+        parts.push(`${activityCount} 进展`);
     if (errorCount > 0)
         parts.push(`${errorCount} 出错`);
     else if (runningCount > 0)