@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

package/src/interface/views/WorkflowsView.ts

@@ -17,9 +17,9 @@
  *
  * 关键实现点：(a) overlay 第二参数必须传，否则 view 不全屏；(b) trace 必须 per-render
  * 重读（run.state.trace.toArray 返回内部数组引用，trace.append 后下次 render 可见），
- * 配 1s tick invalidate + requestRender 保证运行中刷新；(c) 's' save 模式无条件可用
- * （saveWorkflow 内部对非 tmp workflow 返回错误消息）；(d) pause/resume/abort 失败时
- * notify 反馈，不静默吞。
+ * 配条件失效 tick（签名比对，IF11）+ requestRender 保证运行中刷新；(c) 's' save 模式无条件可用
+ * （saveWorkflow 内部对非 tmp workflow 返回错误消息）；(d) abort 失败时 notify 反馈，
+ * 不静默吞（run 一次性生命周期——无 pause/resume，abort 是唯一提前停止方式）。
  */
 
 import { promises as fsPromises } from "node:fs";
@@ -30,12 +30,14 @@ import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
 
 import {
+  countAllToolCalls,
   getAllToolCalls,
   projectLiveProgress,
 } from "../../execution/execution-record.ts";
 import type { ExecutionTraceNode } from "../../orchestration/models/types.ts";
 import type { WorkflowRun } from "../../orchestration/models/workflow-run.ts";
 import { saveWorkflow } from "../../orchestration/workflow-files.ts";
+import { displayAgentName } from "../../shared/agent-ref.ts";
 import {
   BOX_BORDER_CHARS,
   BUDGET_TOKENS_DIVISOR,
@@ -122,14 +124,75 @@ interface TuiLike {
 
 /**
  * view 可触发的 lifecycle 操作（由调用方注入，避免 view 直接依赖 Engine 函数）。
- * 每个 action 接收 runId；调用方绑到 pauseRun/resumeRun/abortRun。
+ * 每个 action 接收 runId；调用方绑到 abortRun（一次性生命周期——仅 abort）。
  */
 export interface ViewActions {
-  pause: (runId: string) => Promise<void>;
-  resume: (runId: string) => Promise<void>;
   abort: (runId: string) => Promise<void>;
 }
 
+// ── 渲染签名（IF11/TC7/DM6：tick 条件失效的判据，渲染动态字段 SSOT）──────
+
+/**
+ * computeRenderSignature — 渲染输出中全部动态决定字段的签名（now 参数化，供测试）。
+ *
+ * 纯度说明：now 是显式参数，但 live 节点的 elapsedSeconds 经 projectLiveProgress
+ * 内的 computeElapsedSeconds 现算（record.endedAt 缺省时取 Date.now()）——即使两次
+ * 调用传同一 now，跨秒的真实时钟也会使签名变。该内含实时源只朝「多失效」方向
+ * 偏离（多失效、不多绘、更不漏绘），对「签名同 → 跳过重绘」的单向判据安全。
+ *
+ * 用途：200ms tick 用它与上次签名比对——相同则该帧内容无可见变化，跳过清缓存 +
+ * requestRender（纯等待场景零重建零重绘）；不同则走现状失效路径。可见行为逐帧
+ * 等价的前提 = 签名字段集覆盖当前渲染的全部动态字段（漏字段 = 该字段渲染滞后一拍，
+ * ES7；签名取原始值时粒度细于显示量化值，只多失效不多绘不漏绘）。
+ *
+ * **字段核对表**（每字段 ↔ 渲染消费点 file:line，完备性唯一证据——测试只能证
+ * 「已入字段变 → 签名变」，不能证无漏字段）：
+ *
+ * | 签名字段 | 消费点 |
+ * |---|---|
+ * | run.state.status | WorkflowsView.ts renderHeader :652 / detail-content.ts :75（statusDotStr+statusLabel）/ renderFooter :695-699 |
+ * | 秒桶 Math.floor(now/1000) | renderHeader :651 formatElapsed（现算 elapsed）+ detail-content.ts :69-72（now 参与未完成节点 elapsed）|
+ * | completed/total（节点 status 推导）| renderHeader :649-652 |
+ * | budget 量化值（tokens round-k + cost toFixed(4)=BUDGET_COST_DECIMALS，与 :654 同精度——第 3-4 位小数变化是可见变化）| renderHeader :654 / saveTraceToFile :942 |
+ * | run.state.errorLogs 指纹 = length+末条 level:message（errorLogs 仅经 push + slice(-MAX_ERROR_LOGS) 变异——append-only + 前向淘汰、条目不可变；封顶后 length 不变内容移，单取 length 会漏失效，而任何可见变化必伴随 length 变或末条变，故 length+末条是完备且最小的指纹）| detail-content.ts :174-191（renderWorkerLogSection：total 标签 + 末 20 条）|
+ * | 节点 stepIndex | nodeParts 首字段（trace 数组序参与拼接，节点重排→签名变）/ saveTraceToFile :947（trace 导出 `### [#stepIndex]` 标题）|
+ * | 节点 sessionFile | detail-content.ts :314-317（renderSessionSection）|
+ * | 节点 status | 节点行 :832 statusDotStr / detail :75 |
+ * | live.totalTokens | 节点行 :836 / detail :79 / :275 |
+ * | 工具计数（签名路径用 countAllToolCalls 免克隆计数，与 getAllToolCalls(node.live).length 恒等——projectLiveProgress 投影无 toolCallCount 字段，不得引用）| 节点行 :837 / detail :80 / :223 |
+ * | live.elapsedSeconds | 节点行 :838 / detail :81 / :276 |
+ * | live.turns | detail :224 / :276 |
+ * | live.eventLog.length（append-only，长度变化即尾部窗口右移出新事件）| detail :222（filter turn_end）+ :231-235 |
+ * | live.currentActivity（type+label 均入签名）| detail :227-228 |
+ * | live.lastError（内容入签名，防同存在性不同文本漏绘）| detail :277-278 |
+ *
+ * 维护约定（DS8）：WorkflowsView/detail-content 新增任何动态展示字段必须同步
+ * 并入本签名并更新上表，否则该字段渲染滞后一拍。本文件编辑会使表内 WorkflowsView
+ * 行号漂移——改动核对表下方代码后必须 grep 实际位置刷新本表。
+ */
+/** 秒桶宽度（ms）：签名取 Math.floor(now / SECOND_MS)，秒桶推进 = 可见 elapsed 变化。 */
+const SECOND_MS = 1000;
+
+export function computeRenderSignature(run: WorkflowRun, now: number): string {
+  const traceArr = run.state.trace.toArray();
+  const completed = traceArr.filter((n) => n.status === "completed").length;
+  const budget = run.state.budget;
+  // budget 量化串与 renderHeader budgetStr 同源同精度（round-k token / toFixed(4) cost）
+  const budgetPart = `${Math.round(budget.usedTokens / BUDGET_TOKENS_DIVISOR)}k/${budget.maxTokens ? `${Math.round(budget.maxTokens / BUDGET_TOKENS_DIVISOR)}k` : "∞"}::$${budget.usedCost.toFixed(BUDGET_COST_DECIMALS)}`;
+  // errorLogs 指纹：detail 只渲染 total 标签 + 末 20 条（renderWorkerLogSection），
+  // 而 errorLogs 仅经 push + slice(-MAX_ERROR_LOGS) 变异（append-only + 前向淘汰、
+  // 条目不可变）——封顶后 length 不变内容移，单取 length 漏失效；任何可见变化必
+  // 伴随「length 变」或「末条变」，故 length+末条（level:message）是完备最小指纹。
+  const logs = run.state.errorLogs;
+  const lastLog = logs && logs.length > 0 ? `${logs[logs.length - 1].level}:${logs[logs.length - 1].message}` : "-";
+  const errorLogsPart = `${logs?.length ?? 0}:${lastLog}`;
+  const nodeParts = traceArr.map((n) => {
+    const live = n.live ? projectLiveProgress(n.live) : undefined;
+    return `${n.stepIndex}:${n.status}:${n.sessionFile ?? "-"}:${live?.totalTokens ?? -1}:${n.live ? countAllToolCalls(n.live) : -1}:${live?.elapsedSeconds ?? -1}:${live?.turns ?? -1}:${live?.eventLog.length ?? -1}:${live?.currentActivity ? `${live.currentActivity.type}:${live.currentActivity.label}` : "-"}:${live?.lastError ?? "-"}`;
+  });
+  return [run.state.status, Math.floor(now / SECOND_MS), `${completed}/${traceArr.length}`, budgetPart, errorLogsPart, ...nodeParts].join("|");
+}
+
 // ── View state ────────────────────────────────────────────────
 
 interface ViewState {
@@ -181,7 +244,7 @@ function createInitialState(): ViewState {
  * @param run WorkflowRun 聚合根（读 state.status/spec/trace/meta）
  * @param theme ThemeLike（避免直接 import Pi runtime）
  * @param ctx ExtensionContext（调 ui.custom 渲染 + ui.notify 错误反馈）
- * @param actions lifecycle 操作（pause/resume/abort），由调用方注入
+ * @param actions lifecycle 操作（abort），由调用方注入
  */
 export function createWorkflowsView(
   run: WorkflowRun,
@@ -212,10 +275,17 @@ export function createWorkflowsView(
     const requestRender = () => tui.requestRender();
 
  // ── 轮询 tick：engine 无事件推送，view 自轮询 trace 变化 ──
- // 每 200ms 重绘，保证 header 动态数据（elapsed/tokens）实时更新。
- // 行数固定后，diff-redraw 引擎能正确逐行对比，不会出现残影。
+ // 每 200ms 条件失效（IF11/TC7）：先算渲染签名（computeRenderSignature，
+ // 覆盖 header/节点行/L2 detail 全部动态字段），与上次相同 → 该帧内容无可见
+ // 变化，直接 return（不清 cache、不 requestRender——纯等待场景零重建零重绘）；
+ // 不同 → 现状路径（清缓存 + requestRender）。lastSignature 初始 undefined，
+ // 首 tick 必失效（保证首绘）。签名计算 O(N)（N=trace 节点数）远低于全量 render。
+    let lastSignature: string | undefined;
     const tick = setInterval(() => {
       if (state.disposed) return;
+      const signature = computeRenderSignature(run, Date.now());
+      if (signature === lastSignature) return;
+      lastSignature = signature;
       cache.key = undefined;
       cache.lines = undefined;
       requestRender();
@@ -358,21 +428,9 @@ export function createWorkflowsView(
         return;
       }
 
- // ── Lifecycle shortcuts (no restart per D-9) ──
-      if (data === "p") {
-        if (run.state.status === "running") {
-          void actions.pause(run.runId)
-            .then(() => { cache.key = undefined; requestRender(); })
-            .catch((err: Error) => ctx.ui.notify(`Pause failed: ${err.message}`, "error"));
-        } else if (run.state.status === "paused") {
-          void actions.resume(run.runId)
-            .then(() => { cache.key = undefined; requestRender(); })
-            .catch((err: Error) => ctx.ui.notify(`Resume failed: ${err.message}`, "error"));
-        }
-        return;
-      }
+ // ── Lifecycle shortcuts (no restart per D-9; no pause/resume — one-shot) ──
       if (data === "a") {
-        if (run.state.status === "running" || run.state.status === "paused") {
+        if (run.state.status === "running") {
           void actions.abort(run.runId)
             .then(() => { cache.key = undefined; requestRender(); })
             .catch((err: Error) => ctx.ui.notify(`Abort failed: ${err.message}`, "error"));
@@ -498,7 +556,7 @@ export function createWorkflowsView(
 // │ ● 2 deploy 0/1 │ ● tester model ... │
 // │ (pad) │ (pad) │
 // ╰───────────────────────────────────────────────────╯
-// ↑↓ phase · ⏎ enter · p pause · a abort · s save · esc back ← footer (框外)
+// ↑↓ phase · ⏎ enter · a abort · s save · esc back ← footer (框外)
 //
 // body = sidebar(SIDEBAR_WIDTH) │ main(rest)
 // save overlay 活跃时居中覆盖 body。
@@ -621,10 +679,8 @@ function renderFooter(
       ? "↑↓ agent · ⏎ detail"
       : "↑↓ agent · ⏎ prompt · PgUp/PgDn scroll";
   const actionParts: string[] = [];
-  const status = run.state.status;
-  if (status === "running" || status === "paused") {
+  if (run.state.status === "running") {
     actionParts.push("a abort");
-    actionParts.push(status === "paused" ? "p resume" : "p pause");
   }
   actionParts.push("s save");
   actionParts.push("S trace");
@@ -765,7 +821,7 @@ function renderLevel1(
       const tokStr = live.totalTokens > 0 ? `${Math.round(live.totalTokens / BUDGET_TOKENS_DIVISOR)}k tok` : "";
       const tcCount = getAllToolCalls(node.live).length;
       const elapsed = formatElapsedSeconds(live.elapsedSeconds);
-      rightLines.push(`${pointer}${dot} ${node.agent}    ${node.model}    ${tokStr} · ${tcCount} tools · ${elapsed}`);
+      rightLines.push(`${pointer}${dot} ${displayAgentName(node.agent)}    ${node.model}    ${tokStr} · ${tcCount} tools · ${elapsed}`);
     } else {
       const elapsed = formatElapsed(
         node.startedAt,
@@ -774,7 +830,7 @@ function renderLevel1(
       const tok = node.result?.usage;
       const tokStr = tok ? `${Math.round((tok.input + tok.output) / BUDGET_TOKENS_DIVISOR)}k tok` : "";
       const tcCount = node.result?.toolCalls?.length ?? 0;
-      rightLines.push(`${pointer}${dot} ${node.agent}    ${node.model}    ${tokStr} · ${tcCount} tools · ${elapsed}`);
+      rightLines.push(`${pointer}${dot} ${displayAgentName(node.agent)}    ${node.model}    ${tokStr} · ${tcCount} tools · ${elapsed}`);
     }
   }
   state.agentScrollOffset = agentStart;
@@ -808,9 +864,10 @@ function renderLevel2(
     const a = agents[i];
     const pointer = i === state.agentIdx ? "❯ " : "  ";
     const maxNameWidth = SIDEBAR_WIDTH - AGENT_NAME_BUDGET;
-    const agentName = visibleLen(a.agent) > maxNameWidth
-      ? a.agent.slice(0, maxNameWidth - 1) + ELLIPSIS
-      : a.agent;
+    const agentRef = displayAgentName(a.agent);
+    const agentName = visibleLen(agentRef) > maxNameWidth
+      ? agentRef.slice(0, maxNameWidth - 1) + ELLIPSIS
+      : agentRef;
     leftLines.push(`${pointer}${agentName}`);
   }
 

package/src/interface/views/__tests__/WorkflowsView-signature.test.ts

@@ -0,0 +1,264 @@
+/**
+ * computeRenderSignature（IF11/TC7/DM6）— 渲染签名单测（now 参数化）。
+ *
+ * 契约：tick 条件失效的判据——签名字段集覆盖 header（renderHeader）/节点行
+ * （renderLevel1 agent list）/L2 detail（buildDetailContent）当前消费的全部动态
+ * 字段。本测试证明「已入字段变化 → 签名变」+「静态 run 不变」（完备性无法靠
+ * 测试证明，字段核对表见 WorkflowsView.ts computeRenderSignature doc）。
+ *
+ * 确定性说明：签名非完全纯——live 节点 elapsedSeconds 由 projectLiveProgress 内
+ * computeElapsedSeconds 现算（record.endedAt ?? Date.now()）。fake timers 控制
+ * Date.now() 与 now 参数同源推进，保证确定性。
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+import { computeRenderSignature } from "../WorkflowsView.ts";
+import type { ExecutionRecord } from "../../../execution/types.ts";
+import type { ExecutionTraceNode, WorkerLogEntry } from "../../../orchestration/models/types.ts";
+import type { WorkflowRun } from "../../../orchestration/models/workflow-run.ts";
+
+// ── Fixtures（duck typing，对齐 detail-content-session-file.test.ts 先例）──
+
+const T0 = 1_700_000_000_000; // 固定 epoch ms
+
+function makeLive(overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
+  return {
+    id: "run-0",
+    agent: "worker",
+    model: "default",
+    thinkingLevel: undefined,
+    mode: "sync",
+    task: "t",
+    slug: "s",
+    startedAt: T0,
+    rootSessionId: undefined,
+    parentRecordId: undefined,
+    depth: 0,
+    status: "running",
+    turns: [],
+    turnCount: 0,
+    totalTokens: 0,
+    lastError: undefined,
+    endedAt: T0 + 5000,
+    result: undefined,
+    error: undefined,
+    agentResult: undefined,
+    ...overrides,
+  } as unknown as ExecutionRecord;
+}
+
+function makeNode(overrides: Partial<ExecutionTraceNode> = {}): ExecutionTraceNode {
+  return {
+    stepIndex: 0,
+    agent: "worker",
+    task: "do",
+    model: "default",
+    status: "running",
+    ...overrides,
+  };
+}
+
+interface RunShape {
+  status?: string;
+  budget?: { usedTokens: number; maxTokens?: number; usedCost: number };
+  nodes?: ExecutionTraceNode[];
+  errorLogs?: WorkerLogEntry[];
+}
+
+function makeRun(shape: RunShape = {}): WorkflowRun {
+  return {
+    state: {
+      status: shape.status ?? "running",
+      budget: shape.budget ?? { usedTokens: 0, maxTokens: 200_000, usedCost: 0 },
+      trace: { toArray: () => shape.nodes ?? [] },
+      errorLogs: shape.errorLogs ?? [],
+    },
+  } as unknown as WorkflowRun;
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(T0);
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("computeRenderSignature — 基础确定性", () => {
+  it("同输入同签名（含 live 节点，endedAt 固定使 elapsed 确定）", () => {
+    const run = makeRun({ nodes: [makeNode({ live: makeLive() })] });
+    expect(computeRenderSignature(run, T0)).toBe(computeRenderSignature(run, T0));
+  });
+
+  it("静态 run（无 live、同秒桶）200ms 内签名不变", () => {
+    const run = makeRun({ nodes: [makeNode({ status: "completed" })] });
+    expect(computeRenderSignature(run, T0)).toBe(computeRenderSignature(run, T0 + 200));
+  });
+
+  it("秒桶跨秒（now 相差 1s 桶）→ 签名变", () => {
+    const run = makeRun();
+    expect(computeRenderSignature(run, T0)).not.toBe(computeRenderSignature(run, T0 + 1000));
+  });
+});
+
+describe("computeRenderSignature — run 级字段", () => {
+  it("run.state.status 变化 → 签名变", () => {
+    const a = makeRun({ status: "running" });
+    const b = makeRun({ status: "done" });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("completed/total 变化（节点 status 推导）→ 签名变", () => {
+    const a = makeRun({ nodes: [makeNode({ status: "running" })] });
+    const b = makeRun({ nodes: [makeNode({ status: "completed" })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("budget tokens 量化值变化 → 签名变", () => {
+    const a = makeRun({ budget: { usedTokens: 1500, maxTokens: 200_000, usedCost: 0.01 } });
+    const b = makeRun({ budget: { usedTokens: 2500, maxTokens: 200_000, usedCost: 0.01 } });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("budget cost 第 4 位小数变化（toFixed(4) 可见精度）→ 签名变", () => {
+    // 0.0100 vs 0.0101：量化展示相同到第 3 位，第 4 位是渲染可见精度
+    const a = makeRun({ budget: { usedTokens: 0, maxTokens: 200_000, usedCost: 0.0100 } });
+    const b = makeRun({ budget: { usedTokens: 0, maxTokens: 200_000, usedCost: 0.0101 } });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("run.state.errorLogs 追加 → 签名变（末条内容入指纹）", () => {
+    const a = makeRun({ errorLogs: [{ level: "error", message: "E-0" }] });
+    const b = makeRun({ errorLogs: [{ level: "error", message: "E-0" }, { level: "warn", message: "W-1" }] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("errorLogs 封顶后 length 不变内容移（push+slice(-MAX_ERROR_LOGS)）→ 签名仍变（指纹非 length）", () => {
+    // 模拟 error-recovery 的变异路径：push 后 slice(-500) 截断。两次 state 均 500 条
+    // （length 相同），仅末条/窗口内容不同——指纹含末条内容才不漏失效。
+    const MAX_ERROR_LOGS = 500;
+    const mk = (n: number): WorkerLogEntry[] => ({ level: "error", message: `E-${n}` });
+    const before: WorkerLogEntry[] = Array.from({ length: MAX_ERROR_LOGS }, (_, i) => mk(i));
+    const after = [...before, mk(MAX_ERROR_LOGS)].slice(-MAX_ERROR_LOGS); // E-1..E-500
+    expect(after).toHaveLength(MAX_ERROR_LOGS); // 前置校验：封顶后 length 不变
+    const a = makeRun({ errorLogs: before });
+    const b = makeRun({ errorLogs: after });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+});
+
+describe("computeRenderSignature — 节点级字段（live 投影）", () => {
+  it("节点 status 变化 → 签名变", () => {
+    const a = makeRun({ nodes: [makeNode({ status: "running" })] });
+    const b = makeRun({ nodes: [makeNode({ status: "failed" })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("live.totalTokens 变化 → 签名变", () => {
+    const a = makeRun({ nodes: [makeNode({ live: makeLive({ totalTokens: 1000 }) })] });
+    const b = makeRun({ nodes: [makeNode({ live: makeLive({ totalTokens: 2000 }) })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("getAllToolCalls(node.live).length 变化 → 签名变（toolCalls 追加）", () => {
+    const live1 = makeLive({
+      turns: [{ text: "", closed: false, toolCalls: [{ toolName: "read", args: {}, result: "", isError: false, _status: "completed", startedTs: T0 }] }],
+    });
+    const live2 = makeLive({
+      turns: [{ text: "", closed: false, toolCalls: [
+        { toolName: "read", args: {}, result: "", isError: false, _status: "completed", startedTs: T0 },
+        { toolName: "bash", args: {}, result: "", isError: false, _status: "completed", startedTs: T0 },
+      ] }],
+    });
+    const a = makeRun({ nodes: [makeNode({ live: live1 })] });
+    const b = makeRun({ nodes: [makeNode({ live: live2 })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("live.elapsedSeconds 变化 → 签名变（running 节点跨秒）", () => {
+    // endedAt undefined → computeElapsedSeconds 用真实 Date.now()；fake timers 推进 1s
+    const live = makeLive({ endedAt: undefined });
+    const run = makeRun({ nodes: [makeNode({ live })] });
+    const before = computeRenderSignature(run, T0);
+    vi.setSystemTime(T0 + 1000);
+    const after = computeRenderSignature(run, T0 + 1000);
+    expect(after).not.toBe(before);
+  });
+
+  it("live.turns 计数变化 → 签名变", () => {
+    const a = makeRun({ nodes: [makeNode({ live: makeLive({ turnCount: 1 }) })] });
+    const b = makeRun({ nodes: [makeNode({ live: makeLive({ turnCount: 2 }) })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("live.eventLog 追加（turn 闭合产生 turn_end 条目）→ 签名变", () => {
+    const live1 = makeLive({
+      turns: [{ text: "partial", closed: false, toolCalls: [] }],
+    });
+    const live2 = makeLive({
+      turns: [{ text: "partial", closed: true, closedTs: T0, toolCalls: [] }],
+    });
+    const a = makeRun({ nodes: [makeNode({ live: live1 })] });
+    const b = makeRun({ nodes: [makeNode({ live: live2 })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("live.currentActivity 出现 / 变化（type+label）→ 签名变", () => {
+    const noActivity = makeLive({ turns: [{ text: "", closed: false, toolCalls: [] }] });
+    const toolRunning = makeLive({
+      turns: [{ text: "", closed: false, toolCalls: [{ toolName: "write", args: {}, result: "", isError: false, _status: "running", startedTs: T0 }] }],
+    });
+    const toolRunningOtherLabel = makeLive({
+      turns: [{ text: "", closed: false, toolCalls: [{ toolName: "bash", args: {}, result: "", isError: false, _status: "running", startedTs: T0 }] }],
+    });
+    const base = makeRun({ nodes: [makeNode({ live: noActivity })] });
+    const withTool = makeRun({ nodes: [makeNode({ live: toolRunning })] });
+    const otherLabel = makeRun({ nodes: [makeNode({ live: toolRunningOtherLabel })] });
+
+    const s0 = computeRenderSignature(base, T0);
+    expect(computeRenderSignature(withTool, T0)).not.toBe(s0); // 出现
+    expect(computeRenderSignature(otherLabel, T0)).not.toBe(computeRenderSignature(withTool, T0)); // label 变
+  });
+
+  it("live.lastError 出现（内容入签名）→ 签名变", () => {
+    const a = makeRun({ nodes: [makeNode({ live: makeLive({ lastError: undefined }) })] });
+    const b = makeRun({ nodes: [makeNode({ live: makeLive({ lastError: "EPIPE: broken pipe" }) })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("node.sessionFile 出现 → 签名变", () => {
+    const a = makeRun({ nodes: [makeNode({})] });
+    const b = makeRun({ nodes: [makeNode({ sessionFile: "/tmp/sessions/run-0.jsonl" })] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+});
+
+describe("computeRenderSignature — 多节点与无 live 终态", () => {
+  it("多节点逐一拼接（节点序参与签名）", () => {
+    const run = makeRun({
+      nodes: [
+        makeNode({ stepIndex: 0, status: "completed" }),
+        makeNode({ stepIndex: 1, status: "running", live: makeLive({ totalTokens: 500 }) }),
+      ],
+    });
+    const sig = computeRenderSignature(run, T0);
+    expect(sig).toContain("0:completed:-:-1:-1:-1:-1:-1:-:-");
+    expect(sig).toContain("1:running:-:500:0:5:0:0:-:-");
+  });
+
+  it("节点重排（trace 数组序对调，stepIndex 维度）→ 签名变", () => {
+    // 同一节点集、字段值均不变，仅 trace 数组顺序对调——nodeParts 按 trace 序拼接，
+    // 首字段 stepIndex 随之换位，签名必变（不漏失效）。
+    const first = makeNode({ stepIndex: 0, status: "completed" });
+    const second = makeNode({ stepIndex: 1, status: "running", live: makeLive() });
+    const a = makeRun({ nodes: [first, second] });
+    const b = makeRun({ nodes: [second, first] });
+    expect(computeRenderSignature(a, T0)).not.toBe(computeRenderSignature(b, T0));
+  });
+
+  it("无节点 run 签名仅含 run 级五段（status/秒桶/completed-total/budget/errorLogs）", () => {
+    const sig = computeRenderSignature(makeRun({ nodes: [] }), T0);
+    expect(sig.split("|")).toHaveLength(5);
+  });
+});

package/src/interface/views/__tests__/detail-content-session-file.test.ts

@@ -21,7 +21,7 @@ const plainTheme: ThemeLike = {
 function makeNode(overrides: Partial<ExecutionTraceNode> = {}): ExecutionTraceNode {
   return {
     stepIndex: 0,
-    agent: "worker",
+    agent: "coder",
     task: "do something",
     model: "default",
     status: "completed",

package/src/interface/views/format.ts

@@ -10,6 +10,7 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import type { AgentEventLogEntry } from "../../execution/types.ts";
 import type { ExecutionTraceNode, ToolCallEntry } from "../../orchestration/models/types.ts";
 import type { DoneReason, RunStatus } from "../../orchestration/models/types.ts";
+import { displayAgentName } from "../../shared/agent-ref.ts";
 
 // ── Constants ─────────────────────────────────────────────────
 
@@ -39,7 +40,7 @@ const SECS_PER_MIN = 60;
 /**
  * 可显示的状态文本集合。
  *
- * 包含 RunStatus（"running"|"paused"|"done" 不直接显示，转 reason）+ DoneReason
+ * 包含 RunStatus（"running"|"done" 不直接显示，转 reason）+ DoneReason
  * （completed/failed/aborted/budget_limited/time_limited）+ ExecutionTraceNode.status
  * （含 "pending"——trace 节点的初始态）。
  *
@@ -85,7 +86,6 @@ export function formatStatusBadge(
 ): string {
   switch (status) {
     case "running": return theme.fg("warning", "\u25CF running");
-    case "paused": return theme.fg("warning", "\u23F8 PAUSED");
     case "completed": return theme.fg("success", "\u2713 completed");
     case "failed": return theme.fg("error", "\u2717 failed");
     case "aborted": return theme.fg("error", "\u2717 aborted");
@@ -311,7 +311,7 @@ export function formatAgentOneLiner(node: ExecutionTraceNode, theme: ThemeLike):
     ? `${Math.round((tok.input + tok.output) / TOKEN_K)}k tok`
     : "";
   const tcCount = node.result?.toolCalls?.length ?? 0;
-  const parts = [dot, node.agent, node.model];
+  const parts = [dot, displayAgentName(node.agent), node.model];
   if (tokStr) parts.push(`${tokStr} · ${tcCount} tools`);
   parts.push(elapsed);
   return parts.join("    ");