@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,102 @@
+import { createHash } from "node:crypto";
+import { scrubSecrets } from "./explore-tools.js";
+const DEFAULT_SUMMARY_MAX = 320;
+/** Hard cap for inspectable full text returned to the browser. */
+export const RUNTIME_CONTEXT_TEXT_MAX = 120_000;
+function redact(text) {
+    return scrubSecrets(text).scrubbed
+        .replace(/\bghp_[A-Za-z0-9]{20,}\b/g, "[REDACTED]")
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/gi, "Bearer [REDACTED]");
+}
+function summary(text, max = DEFAULT_SUMMARY_MAX) {
+    if (!text)
+        return undefined;
+    const cleaned = redact(text).replace(/\s+/g, " ").trim();
+    if (!cleaned)
+        return undefined;
+    return cleaned.length > max ? `${cleaned.slice(0, max)}…` : cleaned;
+}
+function fullText(text, max = RUNTIME_CONTEXT_TEXT_MAX) {
+    if (!text)
+        return undefined;
+    const cleaned = redact(text);
+    if (cleaned.length <= max)
+        return cleaned;
+    return `${cleaned.slice(0, max)}\n\n…[truncated ${cleaned.length - max} chars for inspect UI]`;
+}
+/**
+ * Secret-scrub + length-limit a runtime text (system prompt / resource paths)
+ * before it leaves the server. Used by the runtime snapshot projection.
+ */
+export function redactRuntimeText(text, max = RUNTIME_CONTEXT_TEXT_MAX) {
+    if (!text)
+        return "";
+    const cleaned = redact(text);
+    if (cleaned.length <= max)
+        return cleaned;
+    return `${cleaned.slice(0, max)}\n\n…[truncated ${cleaned.length - max} chars for inspect UI]`;
+}
+export function projectRuntimeContext(input) {
+    const systemText = fullText(input.systemPrompt) ?? "";
+    const suffixText = fullText(input.systemPromptSuffix);
+    const projectResources = (resources) => (resources ?? []).map((resource) => ({
+        name: redactRuntimeText(resource.name, 200),
+        description: redactRuntimeText(resource.description, 600),
+        path: redactRuntimeText(resource.path, 400),
+        baseDir: resource.baseDir ? redactRuntimeText(resource.baseDir, 400) : undefined,
+        scope: resource.scope,
+        source: redactRuntimeText(resource.source, 200),
+        enabled: resource.enabled,
+        version: resource.version ? redactRuntimeText(resource.version, 80) : undefined,
+        cwd: resource.cwd ? redactRuntimeText(resource.cwd, 400) : undefined,
+        resolved: resource.resolved?.map((item) => ({
+            type: item.type,
+            name: redactRuntimeText(item.name, 200),
+            path: redactRuntimeText(item.path, 400),
+            source: redactRuntimeText(item.source, 200),
+            scope: item.scope,
+        })),
+        error: resource.error ? redactRuntimeText(resource.error, 400) : undefined,
+        diagnostics: (resource.diagnostics ?? []).map((diag) => redactRuntimeText(diag, 400)),
+    }));
+    return {
+        readOnly: true,
+        systemPrompt: {
+            hash: createHash("sha256").update(input.systemPrompt).digest("hex"),
+            summary: summary(input.systemPrompt),
+            text: systemText,
+            charCount: input.systemPrompt.length,
+        },
+        resources: {
+            mode: "open",
+            noContextFiles: false,
+            noSkills: false,
+            noExtensions: false,
+            hasBash: true,
+            activeToolCount: input.activeTools.length,
+            activeTools: [...input.activeTools],
+            contextFiles: (input.contextFiles ?? []).map((file) => ({
+                path: redactRuntimeText(file.path, 400),
+                characters: file.characters,
+            })),
+            skills: projectResources(input.skills),
+            extensions: projectResources(input.extensions),
+            packages: projectResources(input.packages),
+            diagnostics: (input.diagnostics ?? []).map((diag) => ({
+                type: diag.type,
+                message: redactRuntimeText(diag.message, 400),
+                ...(diag.path ? { path: redactRuntimeText(diag.path, 400) } : {}),
+            })),
+        },
+        model: input.model,
+        thinkingLevel: input.thinkingLevel,
+        suffix: input.systemPromptSuffix
+            ? {
+                present: true,
+                summary: summary(input.systemPromptSuffix),
+                ...(suffixText ? { text: suffixText } : {}),
+                charCount: input.systemPromptSuffix.length,
+            }
+            : { present: false },
+    };
+}

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

@@ -0,0 +1,96 @@
+/**
+ * Pure runtime-selection helpers shared by the Operator Chat UI and tests.
+ *
+ * These functions encode the merge/match semantics between persisted session
+ * runtime state (model + thinking level) and the read-only runtime context
+ * snapshot. They are intentionally side-effect-free so they can be unit-tested
+ * in a plain Node environment (the React component owns the network race
+ * guards; these helpers only define what "matches" and "merged" mean).
+ */
+/** Human-readable thinking-level labels (auto is always the first option). */
+export const THINKING_LEVEL_LABELS = {
+    auto: "auto（跟随 Pi 默认等级）",
+    off: "off · 关闭",
+    minimal: "minimal · 极简",
+    low: "low · 低",
+    medium: "medium · 中",
+    high: "high · 高",
+    xhigh: "xhigh · 极高",
+    max: "max · 最高",
+};
+/**
+ * Group (and optionally filter) models by provider, preserving the provider
+ * order of first appearance and the model order within each provider.
+ * The query matches provider id, model id and display name (case-insensitive).
+ * Empty query returns all models grouped — never a fake "no models" list.
+ */
+export function groupModelsByProvider(models, query) {
+    const q = query.trim().toLowerCase();
+    const groups = new Map();
+    for (const model of models) {
+        if (q &&
+            !model.provider.toLowerCase().includes(q) &&
+            !model.id.toLowerCase().includes(q) &&
+            !(model.name ?? "").toLowerCase().includes(q)) {
+            continue;
+        }
+        const list = groups.get(model.provider) ?? [];
+        list.push(model);
+        groups.set(model.provider, list);
+    }
+    return [...groups.entries()].map(([provider, models]) => ({
+        provider,
+        models,
+    }));
+}
+/**
+ * Build the thinking menu options: `auto` is always the first option, followed
+ * by the runtime-supported levels in their canonical order. `effective` is the
+ * Pi actual thinking level (shown as a badge on the auto entry when provided).
+ */
+export function buildThinkingMenuOptions(levels, effective) {
+    const seen = new Set();
+    const options = [];
+    const push = (value) => {
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        options.push({
+            value,
+            label: THINKING_LEVEL_LABELS[value] ?? value,
+            ...(value === "auto" && effective ? { effective } : {}),
+        });
+    };
+    push("auto");
+    for (const level of levels)
+        push(level);
+    return options;
+}
+/** Format a model reference for `<option value>` keys and equality checks. */
+export function formatModelRef(provider, modelId) {
+    return `${provider}/${modelId}`;
+}
+/** Normalize a server record into the optional model/thinking patch fields. */
+export function runtimeSelectionFromRecord(record) {
+    return {
+        ...(record.modelProvider && record.modelId
+            ? { model: { provider: record.modelProvider, modelId: record.modelId } }
+            : {}),
+        ...(record.thinkingLevel ? { thinkingLevel: record.thinkingLevel } : {}),
+    };
+}
+/** Merge a patch onto a session, preferring patch values and keeping the id. */
+export function mergeSessionRuntime(current, patch) {
+    return {
+        ...current,
+        model: patch.model ?? current.model,
+        thinkingLevel: patch.thinkingLevel ?? current.thinkingLevel,
+    };
+}
+/** True when `current` already carries the values in `patch`. */
+export function sessionRuntimeMatches(current, patch) {
+    const next = mergeSessionRuntime(current, patch);
+    return (next.model?.provider === current.model?.provider &&
+        next.model?.modelId === current.model?.modelId &&
+        next.thinkingLevel === current.thinkingLevel);
+}

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

@@ -0,0 +1,489 @@
+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: "恢复评估",
+    dagRerun: "从节点续跑",
+    dagInterruptEligibility: "中止资格",
+    standaloneTaskRerun: "完整重跑任务",
+    workerTaskRetry: "重试 Worker 任务",
+    workerPoolDoctor: "任务池诊断",
+    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: "暂时无法确定安全的恢复方式",
+    },
+    dagInterruptEligibility: {
+        running: "正在检查能否协作中止此运行",
+        success: "中止资格已经确认",
+        error: "当前运行不能协作中止",
+    },
+    dagRerun: {
+        running: "正在从失败节点续跑",
+        success: "已经从失败节点继续执行",
+        error: "从失败节点续跑时遇到问题",
+    },
+    standaloneTaskRerun: {
+        running: "正在完整重跑整单任务",
+        success: "已经启动完整重跑",
+        error: "完整重跑任务时遇到问题",
+    },
+    workerPoolDoctor: {
+        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) {
+    // Plan A (2026-08-16): server backfills operationId on the persisted tool
+    // entry (and live tool_result frames carry it in the result payload), so
+    // prefer the authoritative link before parsing args/result fallbacks.
+    const operationId = tool.operationId ??
+        operationIdFromArgs(tool.args) ??
+        operationIdFromArgs(tool.result) ??
+        operationIdFromArgs(tool.resultText);
+    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" };
+    }
+}