pi-ultracode 0.1.0 → 0.1.2

package/src/workflow/display.ts

@@ -3,28 +3,67 @@
  * for streamed tool updates and the final tool result.
  */
 
+import { safeDisplayText } from "./display-text.ts";
 import type { WorkflowMeta } from "./parser.ts";
 
-export type WorkflowAgentStatus = "running" | "done" | "error" | "skipped" | "cached";
+export type WorkflowAgentStatus = "running" | "done" | "error" | "cancelled" | "skipped" | "cached";
+
+export interface WorkflowActiveToolSnapshot {
+  id: string;
+  name: string;
+  args?: string;
+  startedAt: number;
+  lastUpdateAt: number;
+}
+
+export interface WorkflowAgentUsageSnapshot {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  totalTokens: number;
+  cost: number;
+  turns: number;
+  toolUses: number;
+  retries: number;
+  compactions: number;
+}
 
 export interface WorkflowAgentSnapshot {
   id: number;
   label: string;
   phase?: string;
+  workflowPath?: string[];
   status: WorkflowAgentStatus;
   resultPreview?: string;
   error?: string;
+  /** Actual model selected by the child session. */
+  modelId?: string;
+  /** Actual effort applied by the child session. */
+  effort?: string;
+  /** Requested values are retained for diagnostics but never rendered as actual. */
+  requestedModelId?: string;
+  requestedEffort?: string;
+  agentType?: string;
+  isolation?: string;
+  structuredOutput?: boolean;
+  usage?: WorkflowAgentUsageSnapshot;
+  currentTurn?: number;
+  legacyCache?: boolean;
+  transcriptPath?: string;
   /** Wall-clock ms when the agent started (host layer; set by the tool). */
   startedAt?: number;
   /** Wall-clock ms when the agent finished. */
   endedAt?: number;
   /** Runtime duration in ms (endedAt - startedAt). */
   durationMs?: number;
-  /** Wall-clock ms of the last observed activity inside the subagent. */
+  /** Wall-clock ms of the last observed session event inside the subagent. */
   lastActivityAt?: number;
-  /** Short activity label while running, e.g. "text", "bash", "thinking". */
+  /** Last known factual state, e.g. "waiting for model" or "retry 2/3". */
   activity?: string;
-  /** Ring buffer of recent text output while running (live, not persisted). */
+  /** Tool calls that have started but have not emitted tool_execution_end. */
+  activeTools?: WorkflowActiveToolSnapshot[];
+  /** @deprecated Raw assistant stream text is never captured or rendered. */
   streamTail?: string;
 }
 
@@ -40,8 +79,13 @@ export interface WorkflowSnapshot {
   runningCount: number;
   doneCount: number;
   errorCount: number;
+  cancelledCount: number;
   cachedCount: number;
   spentTokens: number;
+  newTokens: number;
+  replayedTokens: number;
+  /** Sanitized session-scoped workflow detail manifest for headless consumers. */
+  detailsManifestPath?: string;
   budgetTotal: number | null;
   durationMs?: number;
   result?: unknown;
@@ -52,26 +96,29 @@ export interface RenderOptions {
   maxAgents?: number;
   maxLogs?: number;
   showResultPreviews?: boolean;
-  /** Show the live streaming tail under each running agent (inspect view). */
+  /** @deprecated No-op retained for source compatibility. */
   showStream?: boolean;
-  /** Override `Date.now()` for deterministic elapsed/idle rendering in tests. */
+  /** Override `Date.now()` for deterministic elapsed/activity rendering in tests. */
   now?: number;
 }
 
 export function createSnapshot(meta: WorkflowMeta, runId: string, budgetTotal: number | null): WorkflowSnapshot {
   return {
     runId,
-    name: meta.name,
-    description: meta.description,
-    phases: meta.phases?.map((p) => p.title) ?? [],
+    name: safeDisplayText(meta.name, 120) || "workflow",
+    description: meta.description ? safeDisplayText(meta.description, 240) : undefined,
+    phases: meta.phases?.map((p) => safeDisplayText(p.title, 120)).filter(Boolean) ?? [],
     logs: [],
     agents: [],
     agentCount: 0,
     runningCount: 0,
     doneCount: 0,
     errorCount: 0,
+    cancelledCount: 0,
     cachedCount: 0,
     spentTokens: 0,
+    newTokens: 0,
+    replayedTokens: 0,
     budgetTotal,
     status: "running",
   };
@@ -81,28 +128,34 @@ export function recompute(snapshot: WorkflowSnapshot): WorkflowSnapshot {
   const runningCount = snapshot.agents.filter((a) => a.status === "running").length;
   const doneCount = snapshot.agents.filter((a) => a.status === "done" || a.status === "cached").length;
   const errorCount = snapshot.agents.filter((a) => a.status === "error").length;
+  const cancelledCount = snapshot.agents.filter((a) => a.status === "cancelled" || a.status === "skipped").length;
   const cachedCount = snapshot.agents.filter((a) => a.status === "cached").length;
-  return { ...snapshot, agentCount: snapshot.agents.length, runningCount, doneCount, errorCount, cachedCount };
+  return { ...snapshot, agentCount: snapshot.agents.length, runningCount, doneCount, errorCount, cancelledCount, cachedCount };
 }
 
 export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderOptions = {}): string[] {
   const maxAgents = options.maxAgents ?? 6;
   const maxLogs = options.maxLogs ?? 2;
   const showResultPreviews = options.showResultPreviews ?? false;
-  const showStream = options.showStream ?? false;
   const now = options.now ?? Date.now();
 
-  const tokens = snapshot.spentTokens
-    ? ` · ${formatTokens(snapshot.spentTokens)}${snapshot.budgetTotal ? `/${formatTokens(snapshot.budgetTotal)}` : ""} tok`
+  const representedTokens = snapshot.newTokens + snapshot.replayedTokens;
+  const tokens = representedTokens
+    ? ` · ${formatTokens(representedTokens)} token${snapshot.replayedTokens ? ` (${formatTokens(snapshot.newTokens)} new, ${formatTokens(snapshot.replayedTokens)} replayed)` : ""}`
+    : snapshot.spentTokens
+      ? ` · ${formatTokens(snapshot.spentTokens)} output token`
+      : "";
+  const budget = snapshot.budgetTotal
+    ? ` · ${formatTokens(snapshot.spentTokens)}/${formatTokens(snapshot.budgetTotal)} out`
     : "";
-  const state =
-    snapshot.errorCount > 0
-      ? `, ${snapshot.errorCount} errors`
-      : snapshot.runningCount > 0
-        ? `, ${snapshot.runningCount} running`
-        : "";
+  const stateParts = [
+    snapshot.runningCount > 0 ? `${snapshot.runningCount} running` : undefined,
+    snapshot.errorCount > 0 ? `${snapshot.errorCount} errors` : undefined,
+    snapshot.cancelledCount > 0 ? `${snapshot.cancelledCount} cancelled` : undefined,
+  ].filter(Boolean);
+  const state = stateParts.length ? `, ${stateParts.join(", ")}` : "";
   const cached = snapshot.cachedCount ? ` · ${snapshot.cachedCount} cached` : "";
-  const header = `◆ ${statusMark(snapshot.status)} ${snapshot.name} (${snapshot.doneCount}/${snapshot.agentCount} done${state})${cached}${tokens}`;
+  const header = `◆ ${statusMark(snapshot.status)} ${shorten(snapshot.name, 60)} (${snapshot.doneCount}/${snapshot.agentCount} done${state})${cached}${tokens}${budget}`;
   const lines = [header];
 
   const phaseNames = unique([
@@ -119,13 +172,22 @@ export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderO
     const done = agents.filter((a) => a.status === "done" || a.status === "cached").length;
     const running = agents.filter((a) => a.status === "running").length;
     const errors = agents.filter((a) => a.status === "error").length;
-    const complete = agents.length > 0 && done + errors === agents.length;
-    const marker = running > 0 || (!complete && snapshot.currentPhase === phase) ? "▶" : complete ? "✓" : " ";
+    const cancelled = agents.filter((a) => a.status === "cancelled" || a.status === "skipped").length;
+    const complete = agents.length > 0 && running === 0;
+    const marker = running > 0 || (!complete && snapshot.currentPhase === phase)
+      ? "▶"
+      : errors
+        ? "✗"
+        : cancelled
+          ? "■"
+          : complete
+            ? "✓"
+            : " ";
     lines.push(
-      `  ${marker} ${phase} ${done}/${agents.length}${running ? ` · ${running} running` : ""}${errors ? ` · ${errors} errors` : ""}`,
+      `  ${marker} ${shorten(phase, 60)} ${done}/${agents.length}${running ? ` · ${running} running` : ""}${errors ? ` · ${errors} errors` : ""}${cancelled ? ` · ${cancelled} cancelled` : ""}`,
     );
     for (const agent of agents.slice(-maxAgents)) {
-      lines.push(renderAgentLine(agent, { showResultPreviews, showStream, now }));
+      lines.push(...renderAgentLines(agent, { showResultPreviews, now }));
     }
     if (agents.length > maxAgents) lines.push(`    … ${agents.length - maxAgents} earlier agents`);
   }
@@ -134,8 +196,9 @@ export function renderWorkflowLines(snapshot: WorkflowSnapshot, options: RenderO
   if (unphased.length) {
     lines.push("  (unphased)");
     for (const agent of unphased.slice(-maxAgents)) {
-      lines.push(renderAgentLine(agent, { showResultPreviews, showStream, now }));
+      lines.push(...renderAgentLines(agent, { showResultPreviews, now }));
     }
+    if (unphased.length > maxAgents) lines.push(`    … ${unphased.length - maxAgents} earlier agents`);
   }
 
   for (const log of snapshot.logs.slice(-maxLogs)) lines.push(`  log: ${shorten(log, 100)}`);
@@ -147,10 +210,8 @@ export function renderWorkflowText(snapshot: WorkflowSnapshot, options: RenderOp
 }
 
 export function preview(value: unknown, max = 80): string {
-  const text = typeof value === "string" ? value : safeJson(value);
-  if (!text) return "";
-  const oneLine = text.replace(/\s+/g, " ").trim();
-  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+  const text = typeof value === "string" ? value : boundedProjection(value, max);
+  return text ? safeDisplayText(text, max) : "";
 }
 
 function statusMark(status: WorkflowSnapshot["status"]): string {
@@ -176,6 +237,8 @@ function statusIcon(status: WorkflowAgentStatus): string {
       return "⟲";
     case "error":
       return "✗";
+    case "cancelled":
+      return "■";
     case "skipped":
       return "-";
   }
@@ -186,38 +249,88 @@ function unique(values: string[]): string[] {
 }
 
 function shorten(value: string, max: number): string {
-  const text = value.replace(/\s+/g, " ").trim();
-  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+  return safeDisplayText(value, max);
 }
 
 function formatTokens(n: number): string {
   if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(n % 1_000 === 0 ? 0 : 1)}k`;
   return String(n);
 }
 
-function safeJson(value: unknown): string {
+const PREVIEW_MAX_STRING = 256;
+const UNINSPECTABLE_PREVIEW = "[Uninspectable]";
+
+/**
+ * Build a UI-only projection without invoking arbitrary object hooks. Objects
+ * and arrays intentionally remain opaque: JavaScript has no bounded own-key
+ * enumeration API, and Proxy/accessor traps must never affect agent success.
+ */
+function boundedProjection(value: unknown, _max: number): string {
   try {
-    return JSON.stringify(value) ?? "";
+    if (value === null) return "null";
+    if (typeof value === "string") {
+      const bounded = value.length > PREVIEW_MAX_STRING
+        ? `${value.slice(0, PREVIEW_MAX_STRING)}…`
+        : value;
+      return JSON.stringify(bounded);
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "undefined") {
+      return String(value);
+    }
+    if (typeof value === "bigint") return "[BigInt]";
+    if (typeof value === "symbol") return "[Symbol]";
+    if (typeof value === "function") return "[Function]";
+    return Array.isArray(value) ? "[Array]" : "[Object]";
   } catch {
-    return String(value);
+    return UNINSPECTABLE_PREVIEW;
   }
 }
 
-/** Seconds of silence after which a running agent is flagged as idle. */
+/** Seconds without an observable session event before visibility escalates. */
 export const IDLE_THRESHOLD_S = 30;
 
-function renderAgentLine(
+function renderAgentLines(
   agent: WorkflowAgentSnapshot,
-  opts: { showResultPreviews: boolean; showStream: boolean; now: number },
-): string {
+  opts: {
+    showResultPreviews: boolean;
+    now: number;
+  },
+): string[] {
   const meta = agentMeta(agent, opts.now);
-  const result = opts.showResultPreviews && agent.resultPreview ? ` — ${agent.resultPreview}` : "";
-  const stream =
-    opts.showStream && agent.status === "running" && agent.streamTail
-      ? `\n      ┊ ${shorten(agent.streamTail, 120)}`
-      : "";
-  return `    #${agent.id} ${statusIcon(agent.status)} ${shorten(agent.label, 48)}${meta}${result}${stream}`;
+  const result = opts.showResultPreviews && agent.resultPreview
+    ? ` — ${safeDisplayText(agent.resultPreview, 80)}`
+    : "";
+  return [
+    `    #${agent.id} ${statusIcon(agent.status)} ${shorten(agent.label, 48)}${meta}${result}`,
+    `      ${agentStats(agent)}`,
+  ];
+}
+
+function agentStats(agent: WorkflowAgentSnapshot): string {
+  const running = agent.status === "running";
+  const model = agent.modelId
+    ?? (running ? "resolving model…" : agent.legacyCache ? "model unavailable" : "model unresolved");
+  const effort = agent.effort
+    ?? (running ? "resolving effort…" : agent.legacyCache ? "effort unavailable" : "effort unresolved");
+  if (agent.legacyCache) {
+    return `${shorten(model, 48)} • ${shorten(effort, 24)} · metrics unavailable · cached legacy entry`;
+  }
+  const usage = agent.usage ?? {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    cost: 0,
+    turns: 0,
+    toolUses: 0,
+    retries: 0,
+    compactions: 0,
+  };
+  const partial = agent.status === "cancelled" || agent.status === "error" || (running && agent.currentTurn != null);
+  const cache = agent.status === "cached" ? " · cached" : "";
+  return `${shorten(model, 48)} • ${shorten(effort, 24)} · ${usage.turns} turn${usage.turns === 1 ? "" : "s"} · ${usage.toolUses} tool use${usage.toolUses === 1 ? "" : "s"} · ${formatTokens(usage.totalTokens)}${partial ? "+" : ""} token${partial ? " · partial" : ""}${cache}`;
 }
 
 /** Compact per-agent timing/activity suffix for the live snapshot. */
@@ -226,20 +339,40 @@ function agentMeta(agent: WorkflowAgentSnapshot, now: number): string {
     const startedAt = agent.startedAt ?? now;
     const elapsed = Math.max(0, Math.floor((now - startedAt) / 1000));
     const lastAct = agent.lastActivityAt ?? startedAt;
-    const idle = Math.max(0, Math.floor((now - lastAct) / 1000));
-    if (idle >= IDLE_THRESHOLD_S) return ` · ${elapsed}s · ⚠ idle ${idle}s`;
-    const act = agent.activity ? ` · ${shorten(agent.activity, 20)}` : "";
-    return ` · ${elapsed}s${act}`;
+    const silence = Math.max(0, Math.floor((now - lastAct) / 1000));
+    const activeTools = agent.activeTools ?? [];
+
+    if (activeTools.length > 0) {
+      const tool = visibleTool(activeTools);
+      const toolDuration = formatDuration(Math.max(0, now - tool.startedAt));
+      const toolName = shorten(tool.name, 30) || "tool";
+      const args = tool.args ? `: ${shorten(tool.args, 60)}` : "";
+      const others = activeTools.length > 1 ? ` +${activeTools.length - 1} more` : "";
+      const noToolEvents = Math.max(0, Math.floor((now - tool.lastUpdateAt) / 1000));
+      const warning = noToolEvents >= IDLE_THRESHOLD_S ? ` · ⚠ no tool events ${noToolEvents}s` : "";
+      return ` · ${elapsed}s · running ${toolName}${args} (${toolDuration})${others}${warning}`;
+    }
+
+    if (silence >= IDLE_THRESHOLD_S) {
+      const last = agent.activity ? ` · last: ${shorten(agent.activity, 64)}` : "";
+      return ` · ${elapsed}s · ⚠ no events ${silence}s${last}`;
+    }
+    const activity = agent.activity ? ` · ${shorten(agent.activity, 64)}` : "";
+    return ` · ${elapsed}s${activity}`;
   }
   if (agent.durationMs != null && agent.durationMs > 0) return ` · ${formatDuration(agent.durationMs)}`;
   return "";
 }
 
+function visibleTool(tools: WorkflowActiveToolSnapshot[]): WorkflowActiveToolSnapshot {
+  return tools.reduce((stalest, tool) => tool.lastUpdateAt < stalest.lastUpdateAt ? tool : stalest);
+}
+
 function formatDuration(ms: number): string {
-  const s = ms / 1000;
-  if (s < 1) return "<1s";
-  if (s < 60) return `${Math.round(s)}s`;
-  const m = Math.floor(s / 60);
-  const rem = Math.round(s % 60);
-  return `${m}m${rem ? ` ${rem}s` : ""}`;
+  const totalSeconds = Math.round(ms / 1000);
+  if (totalSeconds < 1) return "<1s";
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m${seconds ? ` ${seconds}s` : ""}`;
 }

package/src/workflow/registry.ts

@@ -4,31 +4,114 @@
  * by the workflow tool as a run progresses.
  */
 
-import type { WorkflowSnapshot } from "./display.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { recompute, type WorkflowSnapshot } from "./display.ts";
+import { WorkflowRunDetails } from "./run-details.ts";
 
 export interface RunHandle {
   snapshot: WorkflowSnapshot;
   abort: () => void;
   startedAt: number;
+  details?: WorkflowRunDetails;
 }
 
 export class WorkflowRegistry {
   private readonly runs = new Map<string, RunHandle>();
+  private readonly listeners = new Set<() => void>();
   private order: string[] = [];
+  private scopeDir?: string;
 
-  register(runId: string, snapshot: WorkflowSnapshot, abort: () => void): RunHandle {
-    const handle: RunHandle = { snapshot, abort, startedAt: Date.now() };
+  register(
+    runId: string,
+    snapshot: WorkflowSnapshot,
+    abort: () => void,
+    details?: WorkflowRunDetails,
+  ): RunHandle {
+    const handle: RunHandle = { snapshot, abort, startedAt: Date.now(), details };
     this.runs.set(runId, handle);
     this.order = this.order.filter((id) => id !== runId);
     this.order.push(runId);
-    // Keep at most the 50 most recent runs in memory.
-    while (this.order.length > 50) {
-      const evict = this.order.shift();
-      if (evict) this.runs.delete(evict);
-    }
+    // Keep at most the 50 most recent runs in memory without evicting active work.
+    this.trimRuns();
+    this.notify();
     return handle;
   }
 
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  notify(): void {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch {
+        // UI observers must not affect workflow execution.
+      }
+    }
+  }
+
+  /** Restore the newest task-detail manifests for the current Pi session. */
+  restoreRuns(runsDir: string): number {
+    this.setScope(runsDir);
+    let files: string[];
+    try {
+      files = fs.readdirSync(runsDir)
+        .filter((name) => /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.details\.json$/.test(name))
+        .map((name) => path.join(runsDir, name))
+        .sort((a, b) => fs.statSync(a).mtimeMs - fs.statSync(b).mtimeMs)
+        .slice(-50);
+    } catch {
+      return 0;
+    }
+    let restored = 0;
+    for (const file of files) {
+      const loaded = WorkflowRunDetails.restore(file);
+      if (!loaded || this.runs.has(loaded.snapshot.runId ?? loaded.details.runId)) continue;
+      const runId = loaded.snapshot.runId ?? loaded.details.runId;
+      if (loaded.snapshot.status === "running") {
+        loaded.snapshot.status = "aborted";
+        for (const agent of loaded.snapshot.agents) {
+          if (agent.status !== "running") continue;
+          agent.status = "cancelled";
+          agent.currentTurn = undefined;
+          loaded.details.finishTask(agent.id, { status: "cancelled", error: "Session ended before the task completed." });
+        }
+        loaded.snapshot = recompute(loaded.snapshot);
+        loaded.details.persist(loaded.snapshot);
+      }
+      let startedAt = Date.now();
+      try {
+        startedAt = fs.statSync(file).mtimeMs;
+      } catch {
+        // Keep a deterministic in-memory fallback if the manifest disappears.
+      }
+      const handle: RunHandle = {
+        snapshot: loaded.snapshot,
+        abort: () => {},
+        startedAt,
+        details: loaded.details,
+      };
+      this.runs.set(runId, handle);
+      this.order.push(runId);
+      restored++;
+    }
+    this.trimRuns();
+    if (restored) this.notify();
+    return restored;
+  }
+
+  setScope(runsDir: string): void {
+    const resolved = path.resolve(runsDir);
+    if (this.scopeDir === resolved) return;
+    this.scopeDir = resolved;
+    this.runs.clear();
+    this.order = [];
+    this.notify();
+  }
+
   get(runId: string): RunHandle | undefined {
     return this.runs.get(runId);
   }
@@ -36,8 +119,8 @@ export class WorkflowRegistry {
   list(): RunHandle[] {
     return this.order
       .map((id) => this.runs.get(id))
-      .filter((h): h is RunHandle => Boolean(h))
-      .reverse();
+      .filter((handle): handle is RunHandle => Boolean(handle))
+      .sort((left, right) => right.startedAt - left.startedAt);
   }
 
   active(): RunHandle[] {
@@ -55,6 +138,19 @@ export class WorkflowRegistry {
       }
     }
   }
+
+  private trimRuns(): void {
+    while (this.runs.size > 50) {
+      const candidate = [...this.runs.entries()].sort((left, right) => {
+        const leftActive = left[1].snapshot.status === "running" ? 1 : 0;
+        const rightActive = right[1].snapshot.status === "running" ? 1 : 0;
+        return leftActive - rightActive || left[1].startedAt - right[1].startedAt;
+      })[0];
+      if (!candidate) break;
+      this.runs.delete(candidate[0]);
+      this.order = this.order.filter((id) => id !== candidate[0]);
+    }
+  }
 }
 
 let singleton: WorkflowRegistry | undefined;