@tt-a1i/openpi 0.3.0 → 0.4.0

package/extensions/tasks/ui.ts

@@ -4,15 +4,35 @@ import type {
   Theme,
 } from "@earendil-works/pi-coding-agent";
 import {
+  type Component,
   Key,
   matchesKey,
   Text,
-  truncateToWidth,
-  type Component,
   type TUI,
+  truncateToWidth,
+  visibleWidth,
 } from "@earendil-works/pi-tui";
+import { fitNavigationSides } from "../shared/below-editor-navigation.ts";
+import {
+  hintLine,
+  panelFrame,
+  screenTitleLine,
+} from "../shared/screen-chrome.ts";
 import type { TaskItem, TaskSnapshot } from "./tasks.ts";
 
+/**
+ * One colour per status, shared by every surface. The widget used to paint
+ * in-progress amber while the full list painted it accent, so the same item
+ * changed colour depending on where you looked at it.
+ */
+const STATUS_COLOR = {
+  pending: "muted",
+  in_progress: "accent",
+  blocked: "warning",
+  done: "success",
+  dropped: "error",
+} as const satisfies Record<TaskItem["status"], string>;
+
 const STATUS_ICON: Record<TaskItem["status"], string> = {
   pending: "○",
   in_progress: "●",
@@ -86,45 +106,41 @@ export function taskCounts(items: readonly TaskItem[]): TaskCounts {
 }
 
 /**
- * One-line census: `4 tasks (3 done, 1 in progress, 0 open)`.
+ * One-line census: `4 tasks · 3 done · 1 open`.
  *
- * Counts carry the weight and the words recede, so the shape of the batch
- * reads before any individual row does. `done`, `in progress`, and `open` are
- * always listed even at zero — a stable set of three keeps the line from
- * reflowing as work moves between them. `blocked` and `dropped` are
- * exceptional and appear only when they are not zero.
+ * Colour carries the status and the total anchors the line, so nothing needs
+ * bold numbers alternating with dim words — that zebra was the loudest thing
+ * on screen and said the least. Zeros are dropped: "0 in progress" costs a
+ * segment to tell you nothing, and a segment appearing when work starts is a
+ * signal, not a glitch. When one status covers everything the redundant count
+ * collapses to `all`, so a fresh batch reads `8 tasks · all open` rather than
+ * `8 tasks · 8 open`.
  *
  * Takes counts rather than items because a view often shows a bounded subset
  * of rows; the header must describe the whole batch regardless.
  */
 export function renderTaskSummary(counts: TaskCounts, theme: Theme): string {
-  const number = (value: number) => theme.bold(theme.fg("text", String(value)));
-  const dim = (text: string) => theme.fg("dim", text);
   // Coerced, not trusted: these counts can arrive from a tool-result record
   // persisted by an older build, where a missing key would render the literal
   // word "undefined" (or "NaN tasks") into the header.
   const count = (status: TaskItem["status"]) =>
     Number.isFinite(counts[status]) ? counts[status] : 0;
   const total = Number.isFinite(counts.total) ? counts.total : 0;
+  if (total <= 0) return theme.fg("dim", "no tasks");
+  const present = SUMMARY_ORDER.filter((status) => count(status) > 0);
   // Built segment by segment rather than by wrapping the whole line: each
   // styled run emits its own reset, so an outer color would stop applying at
   // the first inner one.
-  const parts = SUMMARY_ORDER.filter(
-    (status) =>
-      status === "done" ||
-      status === "in_progress" ||
-      status === "pending" ||
-      count(status) > 0,
-  ).map((status) => `${number(count(status))} ${dim(SUMMARY_LABEL[status])}`);
+  const chips = present.map((status) =>
+    theme.fg(
+      STATUS_COLOR[status],
+      `${present.length === 1 && count(status) === total ? "all" : count(status)} ${SUMMARY_LABEL[status]}`,
+    ),
+  );
   return [
-    number(total),
-    " ",
-    dim(total === 1 ? "task" : "tasks"),
-    " ",
-    dim("("),
-    parts.join(dim(", ")),
-    dim(")"),
-  ].join("");
+    theme.fg("dim", `${total} ${total === 1 ? "task" : "tasks"}`),
+    ...chips,
+  ].join(theme.fg("dim", " · "));
 }
 
 export interface TaskToolDetails {
@@ -150,16 +166,7 @@ export function renderTaskRows(
   // (all of them) — would otherwise shift every subject sideways by a column.
   const idWidth = Math.max(...items.map((item) => `T${item.id}`.length), 3);
   return items.flatMap((item) => {
-    const color =
-      item.status === "done"
-        ? "success"
-        : item.status === "blocked"
-          ? "warning"
-          : item.status === "dropped"
-            ? "error"
-            : item.status === "in_progress"
-              ? "accent"
-              : "muted";
+    const color = STATUS_COLOR[item.status];
     // No `[status]` text: the icon, its color, and the subject's own weight
     // already say it, and repeating it in words crowded every row.
     const id = `T${item.id}`.padStart(idWidth);
@@ -215,17 +222,23 @@ export function renderTaskWidget(
 
   const hasOverflow = actionable.length > TASK_WIDGET_LIMIT;
   const toggleHint = hasOverflow
-    ? `  ·  ctrl+shift+t ${expanded ? "collapse" : "show all"}`
+    ? ` · ctrl+shift+t ${expanded ? "collapse" : "show all"}`
     : "";
   // Same census as the full list and the /tasks screen. Counted over `tracked`
   // rather than every item, because the widget deliberately hides dropped work
   // and a total that included it would not add up against the rows shown.
+  //
+  // Hints sit on the right edge instead of trailing the census, so the eye lands
+  // on state first and the keystrokes stay out of the way until wanted. They are
+  // dropped rather than truncated when the terminal is too narrow to hold both.
+  const label =
+    theme.fg("accent", "◆ ") + theme.fg("text", theme.bold("Tasks"));
+  const left = `${label}  ${renderTaskSummary(taskCounts(tracked), theme)}`;
+  const hint = theme.fg("dim", `/tasks${toggleHint}`);
   const header =
-    theme.fg("accent", "◆ ") +
-    theme.fg("text", theme.bold("Tasks")) +
-    "  " +
-    renderTaskSummary(taskCounts(tracked), theme) +
-    theme.fg("dim", `  ·  /tasks${toggleHint}`);
+    visibleWidth(left) + visibleWidth(hint) + 3 <= width
+      ? fitNavigationSides(left, hint, width)
+      : left;
   const visible = expanded
     ? actionable
     : actionable.slice(0, TASK_WIDGET_LIMIT);
@@ -235,12 +248,7 @@ export function renderTaskWidget(
   const idWidth = Math.max(...visible.map((i) => `T${i.id}`.length), 3);
   const lines = [truncateToWidth(header, width)];
   for (const [index, item] of visible.entries()) {
-    const color =
-      item.status === "in_progress"
-        ? "warning"
-        : item.status === "blocked"
-          ? "error"
-          : "muted";
+    const color = STATUS_COLOR[item.status];
     const branch = index === visible.length - 1 && hidden === 0 ? "╰─" : "├─";
     lines.push(
       truncateToWidth(
@@ -379,27 +387,36 @@ class TasksScreen implements Component {
   }
 
   render(width: number) {
-    const body = renderTaskRows(this.snapshot.items, this.theme, width - 4);
-    const rows = Math.max(8, (this.tui.terminal.rows || 30) - 8);
+    const theme = this.theme;
+    const counts = taskCounts(this.snapshot.items);
+    const body = renderTaskRows(this.snapshot.items, theme, width - 4);
+    // Title (1) + frame (2) + hint (1): one row more chrome than the old bare
+    // rule, so the body gives one back and the screen keeps its total height.
+    const rows = Math.max(8, (this.tui.terminal.rows || 30) - 9);
     const maxOffset = Math.max(0, body.length - rows);
     this.offset = Math.min(this.offset, maxOffset);
     const visible = body.slice(this.offset, this.offset + rows);
-    const lines = [
-      truncateToWidth(
-        `${this.theme.fg("accent", this.theme.bold("Session tasks"))}  ${renderTaskSummary(taskCounts(this.snapshot.items), this.theme)}`,
+    // Framed like /subagents, /ps, and /workflows rather than a bare rule: a
+    // full-screen view of a list is the same object in each of them, and it
+    // should not look like a different control here.
+    return [
+      screenTitleLine(theme, "Session tasks", "", width),
+      ...panelFrame(theme, {
+        label: renderTaskSummary(counts, theme),
+        rows: visible.map((line) => ` ${line}`),
         width,
-      ),
-      this.theme.fg("border", "─".repeat(Math.max(0, width))),
-      ...visible.map((line) => truncateToWidth(`  ${line}`, width)),
-    ];
-    while (lines.length < rows + 2) lines.push("");
-    lines.push(
-      truncateToWidth(
-        this.theme.fg("dim", "j/k or ↑/↓ scroll · pgup/pgdn page · esc close"),
+        height: rows + 2,
+      }),
+      hintLine(
+        theme,
+        [
+          ["j/k or ↑/↓", "scroll"],
+          ["pgup/pgdn", "page"],
+          ["esc", "close"],
+        ],
         width,
       ),
-    );
-    return lines;
+    ];
   }
 
   invalidate() {}

package/extensions/ui-customization/footer.ts

@@ -28,6 +28,9 @@ const ESCAPE_PATTERN = /\u001b(?:[()][0-2A-Z]|[ -/]*[@-~])/g;
 
 const RESET = "\x1b[0m";
 const POWERLINE_ARROW = "\ue0b0"; //  — decorative; text remains readable without Nerd Font
+const MODEL_ICON = "\uec10"; // Codicon: sparkle
+const CONTEXT_ICON = "\uebe4"; // Codicon: pie-chart
+const DIRECTORY_ICON = "\uea83"; // Codicon: folder
 
 /** Higher = keep longer when the line is too narrow. */
 const PRIORITY: Record<FooterItem, number> = {
@@ -177,11 +180,11 @@ export function buildSegmentCatalog(
     : modelInfo.modelId;
 
   return {
-    cwd: { text: formatDirectory(cwd), tone: "text" },
-    model: { text: modelText, tone: "muted" },
+    cwd: { text: `${DIRECTORY_ICON} ${formatDirectory(cwd)}`, tone: "text" },
+    model: { text: `${MODEL_ICON} ${modelText}`, tone: "muted" },
     thinking: { text: modelInfo.thinking, tone: "muted" },
     context: {
-      text: contextText,
+      text: contextText ? `${CONTEXT_ICON} ${contextText}` : "",
       tone: contextTone(modelInfo.contextPercent),
     },
     cache: {
@@ -199,7 +202,7 @@ export function buildSegmentCatalog(
           : `~${Math.round(modelInfo.tokensPerSecond)} tok/s`,
       tone: "muted",
     },
-    git: { text: gitInfo.branch ?? "", tone: "muted" },
+    git: { text: gitInfo.branch ? `⎇ ${gitInfo.branch}` : "", tone: "muted" },
     pr: {
       text: gitInfo.pullRequest
         ? formatPullRequest(gitInfo.pullRequest.number, gitInfo.pullRequest.url)

package/extensions/user-input-fold/index.ts

@@ -0,0 +1,185 @@
+/**
+ * Fold very long user messages in the transcript display.
+ *
+ * A pasted log, stack trace, or whole file can wipe out several screens of
+ * chat. When a finalized user message exceeds the fold thresholds, the
+ * display keeps a short preview of the prose and of each fenced code block
+ * and closes with a marker line stating how much was folded.
+ *
+ * A fold that would hide nothing (or almost nothing) is skipped and the
+ * message rendered in full: hiding a handful of lines costs a marker row
+ * while saving almost no screen space, and char-heavy messages with few
+ * long lines do not shrink on screen when logical lines are removed —
+ * folding must hide at least MIN_FOLDED_LINES lines to earn its keep.
+ *
+ * This is display-only. The transformer runs through Pi's
+ * `registerMarkdownTransformer` hook, which changes only what the TUI
+ * renders: the session file and the model context keep the full message
+ * untouched, so the model always receives the complete paste. The pure
+ * `foldUserMessage` helper never mutates its input and has no side effects.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/** Fold a user message longer than this many lines. */
+const MAX_LINES = 20;
+/** Fold a user message longer than this many characters. */
+const MAX_CHARS = 1_200;
+/** Prose lines kept when a message is folded. */
+const PROSE_PREVIEW_LINES = 12;
+/** Content lines kept per fenced code block when a message is folded. */
+const BLOCK_PREVIEW_LINES = 4;
+/** Character budget for the prose part of a folded message. */
+const PROSE_PREVIEW_CHARS = 1_200;
+/** Total rendered lines before the fold marker, across prose and code blocks. */
+const MAX_PREVIEW_LINES = 20;
+/** Only fold when at least this many lines would be hidden. */
+const MIN_FOLDED_LINES = 8;
+
+type Segment =
+  | { kind: "prose"; lines: string[] }
+  | { kind: "code"; open: string; content: string[]; close: string };
+
+const FENCE_OPEN = /^ {0,3}`{3,}/;
+const FENCE_CLOSE = /^ {0,3}`{3,}[ \t]*$/;
+
+function countLines(markdown: string) {
+  const parts = markdown.split("\n");
+  // A trailing newline ends the last line; it does not open a new one.
+  return parts.at(-1) === "" ? parts.length - 1 : parts.length;
+}
+
+function splitLines(markdown: string) {
+  const lines = markdown.split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+
+function parseSegments(lines: string[]): Segment[] {
+  const segments: Segment[] = [];
+  let prose: string[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (!FENCE_OPEN.test(lines[i])) {
+      prose.push(lines[i]);
+      i += 1;
+      continue;
+    }
+    if (prose.length > 0) {
+      segments.push({ kind: "prose", lines: prose });
+      prose = [];
+    }
+    const open = lines[i];
+    const content: string[] = [];
+    let close: string | undefined;
+    let j = i + 1;
+    while (j < lines.length && close === undefined) {
+      if (FENCE_CLOSE.test(lines[j])) close = lines[j];
+      else content.push(lines[j]);
+      j += 1;
+    }
+    if (close === undefined) {
+      // Unterminated fence: fold the whole message conservatively as text.
+      return [{ kind: "prose", lines }];
+    }
+    segments.push({ kind: "code", open, content, close });
+    i = j;
+  }
+  if (prose.length > 0) segments.push({ kind: "prose", lines: prose });
+  return segments;
+}
+
+/**
+ * Return the Markdown Pi should render instead of a long user message.
+ * Messages at or below both thresholds — and messages whose fold would
+ * hide fewer than MIN_FOLDED_LINES lines — are returned unchanged. Pure:
+ * the input string is never modified, and the model still sees the original.
+ */
+export function foldUserMessage(markdown: string): string {
+  const totalLines = countLines(markdown);
+  if (totalLines <= MAX_LINES && markdown.length <= MAX_CHARS) return markdown;
+
+  const preview: string[] = [];
+  let proseLinesLeft = PROSE_PREVIEW_LINES;
+  let proseCharsLeft = PROSE_PREVIEW_CHARS;
+  let linesShown = 0;
+
+  for (const segment of parseSegments(splitLines(markdown))) {
+    const remainingLines = MAX_PREVIEW_LINES - preview.length;
+    if (remainingLines <= 0) break;
+    if (segment.kind === "code") {
+      if (segment.content.length === 0) {
+        if (remainingLines < 2) break;
+        preview.push(segment.open, segment.close);
+        linesShown += 2;
+        continue;
+      }
+      // A partial block needs opening/closing fences plus an ellipsis. If that
+      // cannot fit, stop before the block instead of emitting broken Markdown.
+      if (remainingLines < 3) break;
+      let shown = Math.min(
+        segment.content.length,
+        BLOCK_PREVIEW_LINES,
+        remainingLines - 2,
+      );
+      const truncated = () => shown < segment.content.length;
+      while (truncated() && shown + 3 > remainingLines) shown -= 1;
+      preview.push(segment.open, ...segment.content.slice(0, shown));
+      if (truncated()) preview.push("…");
+      preview.push(segment.close);
+      linesShown += 2 + shown;
+      continue;
+    }
+    for (const line of segment.lines) {
+      if (proseLinesLeft <= 0 || preview.length >= MAX_PREVIEW_LINES) break;
+      const cost = line.length + (preview.length > 0 ? 1 : 0);
+      if (preview.length > 0 && cost > proseCharsLeft) break;
+      if (preview.length === 0 && line.length > proseCharsLeft) {
+        // A single giant first line is the only case that cuts mid-line.
+        preview.push(`${line.slice(0, proseCharsLeft)}…`);
+        proseLinesLeft = 0;
+        proseCharsLeft = 0;
+        break;
+      }
+      preview.push(line);
+      linesShown += 1;
+      proseLinesLeft -= 1;
+      proseCharsLeft -= cost;
+    }
+  }
+
+  const foldedLines = totalLines - linesShown;
+  if (foldedLines < MIN_FOLDED_LINES) {
+    // Folding must earn its keep. Hiding fewer lines than MIN_FOLDED_LINES
+    // costs a marker row, hides content, and saves almost nothing on screen
+    // (char-heavy messages with few long lines wrap regardless), so render
+    // the message in full instead.
+    return markdown;
+  }
+  const noun = foldedLines === 1 ? "line" : "lines";
+  preview.push(
+    `… folded ${foldedLines} ${noun} · full content was sent to the model`,
+  );
+  return preview.join("\n");
+}
+
+/**
+ * The registered transformer: fold only finalized user messages and leave
+ * assistant text, thinking blocks, and streaming updates untouched.
+ */
+export function transformUserMarkdown(
+  markdown: string,
+  context: { messageType: string; isStreaming: boolean },
+): string {
+  if (context.messageType !== "user" || context.isStreaming) return markdown;
+  try {
+    return foldUserMessage(markdown);
+  } catch {
+    // Display-only: a folding bug must never break rendering.
+    return markdown;
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerMarkdownTransformer(transformUserMarkdown);
+}

package/extensions/workflows/artifacts.ts

@@ -11,6 +11,7 @@ import {
 } from "./journal.ts";
 import {
   safeStringify,
+  toSerializable,
   truncateUtf8,
   writeFileAtomic,
 } from "./serialization.ts";
@@ -100,6 +101,40 @@ function writeRunFile(runDir: string, name: string, content: string) {
   writeFileAtomic(path.join(runDir, name), content);
 }
 
+/** Persist one successful child result before any handoff/context projection. */
+export function persistWorkflowAgentResult(
+  runDir: string,
+  index: number,
+  result: { output: string; structured?: unknown },
+) {
+  const artifact = path.join(
+    "agent-results",
+    `agent-${String(index).padStart(4, "0")}.json`,
+  );
+  writeRunFile(
+    runDir,
+    artifact,
+    JSON.stringify(
+      toSerializable(
+        {
+          output: result.output,
+          ...(result.structured !== undefined
+            ? { structured: result.structured }
+            : {}),
+        },
+        {
+          maxDepth: 32,
+          maxNodes: 100_000,
+          maxStringBytes: 2 * 1024 * 1024,
+        },
+      ),
+      null,
+      2,
+    ),
+  );
+  return artifact;
+}
+
 export function persistWorkflowJson(
   runDir: string,
   details: WorkflowDetails,

package/extensions/workflows/controller.ts

@@ -83,6 +83,7 @@ export class RunController {
   private readonly abortController = new AbortController();
   private readonly semaphore: Semaphore;
   private readonly maxAgentCalls: number;
+  private readonly concurrency: number;
   private readonly tasks = new Set<Promise<unknown>>();
   private callCount = 0;
   private sealed = false;
@@ -95,9 +96,11 @@ export class RunController {
     concurrency = DEFAULT_WORKFLOW_CONCURRENCY,
     maxAgentCalls = DEFAULT_WORKFLOW_MAX_AGENT_CALLS,
   ) {
-    this.semaphore = new Semaphore(
-      Math.max(1, Math.min(MAX_WORKFLOW_CONCURRENCY, Math.floor(concurrency))),
+    this.concurrency = Math.max(
+      1,
+      Math.min(MAX_WORKFLOW_CONCURRENCY, Math.floor(concurrency)),
     );
+    this.semaphore = new Semaphore(this.concurrency);
     this.maxAgentCalls = Math.max(
       1,
       Math.min(MAX_WORKFLOW_AGENT_CALLS, Math.floor(maxAgentCalls)),
@@ -121,6 +124,15 @@ export class RunController {
     return this.callCount;
   }
 
+  capacity() {
+    return {
+      concurrency: this.concurrency,
+      maxAgentCalls: this.maxAgentCalls,
+      callsUsed: this.callCount,
+      callsRemaining: Math.max(0, this.maxAgentCalls - this.callCount),
+    };
+  }
+
   schedule<T>(
     task: (signal: AbortSignal) => Promise<T>,
     invocationSignal?: AbortSignal,

package/extensions/workflows/coordinator.ts

@@ -0,0 +1,64 @@
+export interface WorkflowLaunchPolicyInput {
+  wait?: boolean;
+  background?: boolean;
+}
+
+export interface WorkflowLaunchPolicy {
+  wait: boolean;
+  detached: boolean;
+}
+
+/** Resolve legacy/background and host capability without silently changing semantics. */
+export function resolveWorkflowLaunchPolicy(
+  input: WorkflowLaunchPolicyInput,
+  canDeliverLater: boolean,
+): WorkflowLaunchPolicy {
+  if (
+    input.wait !== undefined &&
+    input.background !== undefined &&
+    input.wait === input.background
+  ) {
+    throw new Error(
+      "wait and background conflict: background is the deprecated inverse of wait",
+    );
+  }
+  const wait =
+    input.wait ??
+    (input.background !== undefined ? !input.background : !canDeliverLater);
+  if (!wait && !canDeliverLater) {
+    throw new Error(
+      "This host cannot deliver a workflow result later; use wait: true",
+    );
+  }
+  return { wait, detached: !wait };
+}
+
+/**
+ * Arbitrate an inline wait against caller cancellation without transferring
+ * ownership of the workflow run to the wait signal.
+ */
+export async function waitForWorkflowCompletion(
+  completion: Promise<unknown>,
+  signal?: AbortSignal,
+): Promise<"terminal" | "aborted"> {
+  if (!signal) {
+    await completion.catch(() => {});
+    return "terminal";
+  }
+  if (signal.aborted) return "aborted";
+
+  let onAbort: (() => void) | undefined;
+  const aborted = new Promise<"aborted">((resolve) => {
+    onAbort = () => resolve("aborted");
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  const terminal = completion.then(
+    () => "terminal" as const,
+    () => "terminal" as const,
+  );
+  try {
+    return await Promise.race([terminal, aborted]);
+  } finally {
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}