@tt-a1i/openpi 0.3.1 → 0.5.0

package/extensions/workflows/journal.ts

@@ -38,6 +38,148 @@ export interface WorkflowJournal {
   readonly entries: readonly JournalEntry[];
 }
 
+interface EncodedJournalEntry {
+  readonly entry: JournalEntry;
+  /** The entry formatted at the indentation used inside the journal array. */
+  readonly json: string;
+  readonly bytes: number;
+}
+
+const JOURNAL_PREFIX = `{
+  "version": ${JOURNAL_VERSION},
+  "entries": [
+`;
+const JOURNAL_SUFFIX = "\n  ]\n}";
+const JOURNAL_SEPARATOR = ",\n";
+const JOURNAL_EMPTY = JSON.stringify(
+  { version: JOURNAL_VERSION, entries: [] },
+  null,
+  2,
+);
+const JOURNAL_PREFIX_BYTES = Buffer.byteLength(JOURNAL_PREFIX, "utf8");
+const JOURNAL_SUFFIX_BYTES = Buffer.byteLength(JOURNAL_SUFFIX, "utf8");
+const JOURNAL_SEPARATOR_BYTES = Buffer.byteLength(JOURNAL_SEPARATOR, "utf8");
+const JOURNAL_EMPTY_BYTES = Buffer.byteLength(JOURNAL_EMPTY, "utf8");
+
+function encodeJournalEntry(entry: JournalEntry): EncodedJournalEntry {
+  // JSON.stringify on an array serializes an undefined element as null. The
+  // public type only permits objects, but retaining that fallback keeps this
+  // helper's behavior total if a malformed caller reaches it at runtime.
+  const json = JSON.stringify(entry, null, 2) ?? "null";
+  const indented = `    ${json.replaceAll("\n", "\n    ")}`;
+  return {
+    entry,
+    json: indented,
+    bytes: Buffer.byteLength(indented, "utf8"),
+  };
+}
+
+function journalBytes(entryCount: number, entryBytes: number) {
+  if (entryCount === 0) return JOURNAL_EMPTY_BYTES;
+  return (
+    JOURNAL_PREFIX_BYTES +
+    entryBytes +
+    JOURNAL_SUFFIX_BYTES +
+    (entryCount - 1) * JOURNAL_SEPARATOR_BYTES
+  );
+}
+
+/**
+ * Incrementally bounded journal storage for a running Workflow.
+ *
+ * Each entry is encoded once when appended. The active queue uses a head
+ * cursor, so dropping old entries only subtracts their already-known byte
+ * contribution. `toJson()` assembles the complete canonical artifact without
+ * re-stringifying each entry or repeatedly measuring the whole suffix.
+ */
+export interface WorkflowJournalAccumulator {
+  readonly bytes: number;
+  readonly dropped: number;
+  readonly length: number;
+  append(entry: JournalEntry): void;
+  toJournal(): WorkflowJournal;
+  toJson(): string;
+}
+
+export function createJournalAccumulator(
+  maxBytes = JOURNAL_MAX_BYTES,
+): WorkflowJournalAccumulator {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < JOURNAL_EMPTY_BYTES) {
+    throw new RangeError(
+      `Journal byte budget must be at least ${JOURNAL_EMPTY_BYTES} bytes`,
+    );
+  }
+
+  let queue: Array<EncodedJournalEntry | undefined> = [];
+  let head = 0;
+  let entryBytes = 0;
+  let dropped = 0;
+
+  const activeLength = () => queue.length - head;
+  const activeBytes = () => journalBytes(activeLength(), entryBytes);
+
+  const compact = () => {
+    // Release the encoded payload immediately when it is evicted. Compact the
+    // sparse prefix only occasionally so eviction remains amortized O(1).
+    if (head === queue.length) {
+      queue = [];
+      head = 0;
+      return;
+    }
+    if (head >= 64 && head * 2 >= queue.length) {
+      queue = queue.slice(head);
+      head = 0;
+    }
+  };
+
+  return {
+    get bytes() {
+      return activeBytes();
+    },
+    get dropped() {
+      return dropped;
+    },
+    get length() {
+      return activeLength();
+    },
+    append(entry) {
+      const encoded = encodeJournalEntry(entry);
+      queue.push(encoded);
+      entryBytes += encoded.bytes;
+
+      while (activeLength() > 0 && activeBytes() > maxBytes) {
+        const oldest = queue[head];
+        if (!oldest) break;
+        queue[head] = undefined;
+        head++;
+        entryBytes -= oldest.bytes;
+        dropped++;
+      }
+      compact();
+    },
+    toJournal() {
+      const entries: JournalEntry[] = [];
+      for (let index = head; index < queue.length; index++) {
+        const encoded = queue[index];
+        if (encoded) entries.push(encoded.entry);
+      }
+      return {
+        version: JOURNAL_VERSION,
+        entries,
+      };
+    },
+    toJson() {
+      if (activeLength() === 0) return JOURNAL_EMPTY;
+      const entries: string[] = [];
+      for (let index = head; index < queue.length; index++) {
+        const encoded = queue[index];
+        if (encoded) entries.push(encoded.json);
+      }
+      return JOURNAL_PREFIX + entries.join(JOURNAL_SEPARATOR) + JOURNAL_SUFFIX;
+    },
+  };
+}
+
 /**
  * Only semantic options change what an agent produces, so only these are
  * hashed. Callers pass their whole options object; `label` and `phase` are
@@ -146,19 +288,12 @@ export type ReplayCache = ReturnType<typeof createReplayCache>;
  * journal that serializes to a useless preview string.
  */
 export function boundedJournal(entries: readonly JournalEntry[]) {
-  const size = (kept: readonly JournalEntry[]) =>
-    Buffer.byteLength(
-      JSON.stringify({ version: JOURNAL_VERSION, entries: kept }, null, 2),
-      "utf8",
-    );
-
-  let kept = [...entries];
-  let dropped = 0;
-  while (kept.length > 0 && size(kept) > JOURNAL_MAX_BYTES) {
-    kept = kept.slice(1);
-    dropped++;
-  }
-  return { journal: { version: JOURNAL_VERSION, entries: kept }, dropped };
+  const accumulator = createJournalAccumulator();
+  for (const entry of entries) accumulator.append(entry);
+  return {
+    journal: accumulator.toJournal(),
+    dropped: accumulator.dropped,
+  };
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/extensions/workflows/model.ts

@@ -5,10 +5,11 @@
 
 import * as os from "node:os";
 import {
-  truncateHead,
   type ExtensionContext,
+  truncateHead,
 } from "@earendil-works/pi-coding-agent";
 import { formatContextUtilization } from "../shared/context-utilization.ts";
+import { spinnerFrame } from "../shared/spinner.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import type { WorktreeCleanup } from "../shared/worktree.ts";
 import type { AcceptanceLedger } from "./acceptance.ts";
@@ -47,8 +48,31 @@ export function emptyUsage(): AgentUsage {
   };
 }
 
-export type AgentState = "running" | "done" | "error";
-export type WorkflowStatus = "running" | "completed" | "failed" | "aborted";
+export type AgentState = "running" | "done" | "error" | "uncertain";
+export type WorkflowStatus =
+  | "running"
+  | "completed"
+  | "failed"
+  | "aborted"
+  | "uncertain";
+
+export type WorkflowDeliveryState =
+  | "none"
+  | "held-for-inline"
+  | "pending"
+  | "delivered"
+  | "consumed-inline";
+
+/** Durable completion-delivery plane, independent from execution status. */
+export interface WorkflowDelivery {
+  /** Stable per-run idempotency identity, never a transport-batch id. */
+  id: string;
+  state: WorkflowDeliveryState;
+  attempts: number;
+  updatedAt: number;
+  deliveredAt?: number;
+  lastError?: string;
+}
 
 export type TranscriptRole =
   | "user"
@@ -84,6 +108,8 @@ export interface AgentRecord {
   inputCallIds?: string[];
   /** Opaque same-run reference returned to the workflow script. */
   resultRef?: string;
+  /** Run-directory-relative authoritative result captured before projection. */
+  resultArtifact?: string;
   label: string;
   phase?: string;
   state: AgentState;
@@ -115,6 +141,23 @@ export interface AgentRecord {
 export interface WorkflowLogEntry {
   at: number;
   text: string;
+  /** Runtime-authored evidence, distinct from free-form script narration. */
+  kind?: "pipeline-drop";
+}
+
+/** Metadata attached only to the bounded in-memory settled-run projection. */
+export interface WorkflowMemoryProjection {
+  readonly kind: "settled";
+  readonly maxBytes: number;
+  readonly bytes: number;
+  readonly truncated: boolean;
+  readonly omitted: {
+    readonly agents: number;
+    readonly logs: number;
+    readonly transcriptEntries: number;
+    readonly result: boolean;
+    readonly graph: boolean;
+  };
 }
 
 export interface WorkflowDetails {
@@ -124,6 +167,8 @@ export interface WorkflowDetails {
   name?: string;
   description?: string;
   background: boolean;
+  /** Whether this run's terminal result is pending, delivered, or inline. */
+  delivery?: WorkflowDelivery;
   status: WorkflowStatus;
   startedAt: number;
   finishedAt?: number;
@@ -144,6 +189,54 @@ export interface WorkflowDetails {
   /** Read-only lineage projection; never execution or admission authority. */
   graph?: WorkflowGraphProjection;
   error?: string;
+  /** Present only on the session-memory projection, never canonical history. */
+  memoryProjection?: WorkflowMemoryProjection;
+}
+
+/** Bounded tool-result projection; authoritative details remain in run artifacts. */
+export function compactWorkflowToolDetails(
+  details: WorkflowDetails,
+): WorkflowDetails {
+  return {
+    ...details,
+    ...(details.result !== undefined
+      ? {
+          result: JSON.parse(
+            safeStringify(details.result, { maxBytes: 64 * 1024 }),
+          ),
+        }
+      : {}),
+    agents: details.agents.map((agent) => ({ ...agent, transcript: [] })),
+  };
+}
+
+/**
+ * Bound only the current-session terminal projection. Persisted workflow
+ * records and side artifacts remain the canonical history.
+ */
+export const MAX_SETTLED_RUNS = 32;
+
+/** Evict the oldest terminal projections without touching active-run state. */
+export function evictOldestSettledRuns(
+  settledRuns: Map<string, WorkflowDetails>,
+  maxRuns = MAX_SETTLED_RUNS,
+): string[] {
+  const limit = Number.isFinite(maxRuns)
+    ? Math.max(0, Math.floor(maxRuns))
+    : MAX_SETTLED_RUNS;
+  const evicted: string[] = [];
+  while (settledRuns.size > limit) {
+    let oldest: { runId: string; at: number } | undefined;
+    for (const [runId, details] of settledRuns) {
+      if (details.status === "running") continue;
+      const at = details.finishedAt ?? details.startedAt;
+      if (!oldest || at < oldest.at) oldest = { runId, at };
+    }
+    if (!oldest) break;
+    settledRuns.delete(oldest.runId);
+    evicted.push(oldest.runId);
+  }
+  return evicted;
 }
 
 export function workflowGraphRecords(
@@ -278,11 +371,12 @@ export function appendLog(
   details: WorkflowDetails,
   text: string,
   at: number,
+  kind?: WorkflowLogEntry["kind"],
 ): void {
   const clean = sanitizeLine(text, MAX_LOG_TEXT);
   if (!clean) return;
   const logs = (details.logs ??= []);
-  logs.push({ at, text: clean });
+  logs.push({ at, text: clean, ...(kind ? { kind } : {}) });
   const excess = logs.length - MAX_LOG_ENTRIES;
   if (excess > 0) {
     logs.splice(0, excess);
@@ -334,19 +428,31 @@ export function createUsageReader(agents: readonly AgentRecord[]) {
   };
 }
 
-/** Colored square state indicator (no emojis/glyphs). */
-export const SQUARE = "■";
-
-export function stateSquare(state: AgentState, theme: Theme): string {
-  if (state === "done") return theme.fg("success", SQUARE);
-  if (state === "error") return theme.fg("error", SQUARE);
-  return theme.fg("warning", SQUARE);
+/**
+ * One status indicator per state, shared by the transcript card, the
+ * dashboard, and the strips. Running spins on the package-wide cadence so
+ * every live view animates in step.
+ */
+export function stateGlyph(
+  state: AgentState,
+  theme: Theme,
+  now: number,
+): string {
+  if (state === "done") return theme.fg("success", "✓");
+  if (state === "error") return theme.fg("error", "✗");
+  if (state === "uncertain") return theme.fg("warning", "?");
+  return theme.fg("warning", spinnerFrame(now));
 }
 
-export function statusSquare(status: WorkflowStatus, theme: Theme): string {
-  if (status === "completed") return theme.fg("success", SQUARE);
-  if (status === "running") return theme.fg("warning", SQUARE);
-  return theme.fg("error", SQUARE);
+export function statusGlyph(
+  status: WorkflowStatus,
+  theme: Theme,
+  now: number,
+): string {
+  if (status === "completed") return theme.fg("success", "✓");
+  if (status === "running") return theme.fg("warning", spinnerFrame(now));
+  if (status === "uncertain") return theme.fg("warning", "?");
+  return theme.fg("error", "✗");
 }
 
 export function statusWord(status: WorkflowStatus): string {
@@ -357,7 +463,7 @@ export function statusColor(
   status: WorkflowStatus,
 ): "success" | "warning" | "error" {
   if (status === "completed") return "success";
-  if (status === "running") return "warning";
+  if (status === "running" || status === "uncertain") return "warning";
   return "error";
 }
 
@@ -392,10 +498,14 @@ export function agentContext(agent: AgentRecord): string {
   });
 }
 
-export function formatElapsed(startedAt: number, finishedAt?: number): string {
+export function formatElapsed(
+  startedAt: number,
+  finishedAt?: number,
+  now = Date.now(),
+): string {
   const totalSeconds = Math.max(
     0,
-    Math.round(((finishedAt ?? Date.now()) - startedAt) / 1000),
+    Math.round(((finishedAt ?? now) - startedAt) / 1000),
   );
   const minutes = Math.floor(totalSeconds / 60);
   const seconds = totalSeconds % 60;
@@ -420,13 +530,15 @@ export function aggregateUsage(agents: AgentRecord[]): AgentUsage {
 export function countStates(details: WorkflowDetails) {
   let done = 0;
   let failed = 0;
+  let uncertain = 0;
   let running = 0;
   for (const agent of details.agents) {
     if (agent.state === "done") done++;
     else if (agent.state === "error") failed++;
+    else if (agent.state === "uncertain") uncertain++;
     else running++;
   }
-  return { done, failed, running };
+  return { done, failed, uncertain, running };
 }
 
 export interface PhaseGroup {

package/extensions/workflows/navigation.ts

@@ -4,7 +4,9 @@ import {
   BelowEditorStripState,
   belowEditorStripInput,
   fitNavigationSides,
+  renderNavigationMetrics,
 } from "../shared/below-editor-navigation.ts";
+import { SPINNER_INTERVAL_MS, spinnerFrame } from "../shared/spinner.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import {
   aggregateUsage,
@@ -12,9 +14,9 @@ import {
   formatElapsed,
   formatTokens,
   statusColor,
-  statusSquare,
   type Theme,
   type WorkflowDetails,
+  type WorkflowStatus,
 } from "./model.ts";
 
 /** Workflow-named aliases preserve the public seam while sharing interaction. */
@@ -29,13 +31,29 @@ export interface WorkflowStripEntry {
   details: WorkflowDetails;
 }
 
+/** Changes only when the strip needs an immediate lifecycle repaint. */
+export function workflowStripEntryKey(entry: WorkflowStripEntry | undefined) {
+  return entry ? `${entry.runId}:${entry.details.status}` : undefined;
+}
+
 function cleanLine(value: string) {
   return sanitizeTerminalText(value).replace(/\s+/g, " ").trim();
 }
 
+/**
+ * One status indicator per run state; doubles as the focus marker when
+ * selected. Running spins, in step with the dashboard and takeover headers.
+ */
+function statusGlyph(status: WorkflowStatus, theme: Theme, now: number) {
+  if (status === "completed") return theme.fg("success", "✓");
+  if (status === "running") return theme.fg("warning", spinnerFrame(now));
+  if (status === "uncertain") return theme.fg("warning", "?");
+  return theme.fg("error", "✗");
+}
+
 /** Live, one-line Claude-style workflow entry rendered below the editor. */
 export class WorkflowStripWidget {
-  private readonly timer: ReturnType<typeof setInterval>;
+  private timer: ReturnType<typeof setInterval> | undefined;
   private readonly tui: TUI;
   private readonly theme: Theme;
   private readonly strip: BelowEditorStripState;
@@ -51,43 +69,68 @@ export class WorkflowStripWidget {
     this.theme = theme;
     this.strip = strip;
     this.getEntry = getEntry;
-    this.timer = setInterval(() => this.tui.requestRender(), 500);
-    this.timer.unref?.();
+    this.syncSpinner();
   }
 
   dispose() {
-    clearInterval(this.timer);
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
   }
 
-  invalidate() {}
+  invalidate() {
+    this.syncSpinner();
+  }
+
+  private syncSpinner() {
+    if (this.getEntry()?.details.status === "running") {
+      if (this.timer) return;
+      const timer = setInterval(() => {
+        if (this.timer !== timer) return;
+        if (this.getEntry()?.details.status !== "running") {
+          clearInterval(timer);
+          this.timer = undefined;
+        }
+        this.tui.requestRender();
+      }, SPINNER_INTERVAL_MS);
+      this.timer = timer;
+      timer.unref?.();
+      return;
+    }
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+  }
 
   render(width: number) {
+    this.syncSpinner();
     const entry = this.getEntry();
     if (!entry || width <= 0) return [];
     const details = entry.details;
-    const { done, failed } = countStates(details);
+    const { done, failed, uncertain } = countStates(details);
     const settled = done + failed;
     const usage = aggregateUsage(details.agents);
     const tokenCount = usage.input + usage.output;
-    const marker = this.strip.focused
+    const glyph = this.strip.focused
       ? this.theme.fg("accent", "❯")
-      : this.theme.fg("dim", "○");
+      : statusGlyph(details.status, this.theme, Date.now());
     const displayName = cleanLine(details.name ?? entry.runId) || entry.runId;
     const name = this.strip.focused
       ? this.theme.bold(this.theme.fg("accent", displayName))
       : this.theme.fg("text", displayName);
     const rawContext = details.currentPhase ?? details.description;
     const context = rawContext ? cleanLine(rawContext) : undefined;
-    const left = ` ${marker} ${statusSquare(details.status, this.theme)} ${name}${context ? this.theme.fg("dim", ` · ${context}`) : ""}`;
-    const metrics = [
-      `${settled}/${details.agents.length} agents`,
-      formatElapsed(details.startedAt, details.finishedAt),
-      tokenCount > 0 ? `${formatTokens(tokenCount)} tokens` : undefined,
+    const left = ` ${glyph} ${name}${context ? this.theme.fg("dim", ` · ${context}`) : ""}`;
+    const right = renderNavigationMetrics(
+      this.theme,
+      [
+        details.agents.length > 0
+          ? `${settled}/${details.agents.length} agents${uncertain ? ` · ${uncertain} uncertain` : ""}`
+          : undefined,
+        formatElapsed(details.startedAt, details.finishedAt),
+        tokenCount > 0 ? `${formatTokens(tokenCount)} tokens` : undefined,
+      ],
       this.strip.focused ? "enter open · ↑ back" : "↓ to manage",
-    ]
-      .filter((part): part is string => Boolean(part))
-      .join(" · ");
-    const right = this.theme.fg(statusColor(details.status), metrics);
+      details.status === "running" ? undefined : statusColor(details.status),
+    );
     return [fitNavigationSides(left, right, width)];
   }
 }