@tt-a1i/openpi 0.4.0 → 0.6.0

package/extensions/background-terminals/src/output.ts

@@ -13,13 +13,17 @@
  */
 
 import type { OutputView } from "./domain.ts";
+import { TerminalTextSanitizer } from "../../shared/terminal-text.ts";
 
 export class OutputBuffer {
   private chunks: string[] = [];
+  private modelSafeChunks: string[] = [];
   /** Bytes currently retained across `chunks`. */
   private retainedBytes = 0;
+  private modelSafeRetainedBytes = 0;
   /** Cached join of `chunks`; invalidated on push so 1Hz UI ticks are cheap. */
   private cachedText: string | undefined = "";
+  private cachedModelSafeText: string | undefined = "";
   /** Bumped on every push; lets the UI cache derived line layouts. */
   version = 0;
   totalBytes = 0;
@@ -28,6 +32,7 @@ export class OutputBuffer {
 
   private readonly maxRetainedBytes: number;
   private readonly spill?: (chunk: string) => unknown;
+  private readonly modelSanitizer = new TerminalTextSanitizer();
 
   constructor(maxRetainedBytes: number, spill?: (chunk: string) => unknown) {
     this.maxRetainedBytes = maxRetainedBytes;
@@ -36,6 +41,7 @@ export class OutputBuffer {
 
   push(chunk: string) {
     if (chunk.length === 0) return true;
+    this.retainModelSafeText(this.modelSanitizer.push(chunk));
     let bytes = Buffer.byteLength(chunk, "utf8");
     this.totalBytes += bytes;
     const spillAccepted = this.spill?.(chunk) !== false;
@@ -74,11 +80,38 @@ export class OutputBuffer {
 
   view(): OutputView {
     this.cachedText ??= this.chunks.join("");
+    this.cachedModelSafeText ??= this.modelSafeChunks.join("");
     return {
       text: this.cachedText,
+      modelSafeText: this.cachedModelSafeText,
       totalBytes: this.totalBytes,
       truncatedBytes: this.truncatedBytes,
       spillPath: this.spillPath,
     };
   }
+
+  private retainModelSafeText(text: string) {
+    if (text.length === 0) return;
+    let bytes = Buffer.byteLength(text, "utf8");
+    if (bytes > this.maxRetainedBytes) {
+      this.modelSafeChunks = [];
+      this.modelSafeRetainedBytes = 0;
+      const raw = Buffer.from(text, "utf8");
+      let start = raw.length - this.maxRetainedBytes;
+      while (start < raw.length && (raw[start] & 0xc0) === 0x80) start++;
+      text = raw.subarray(start).toString("utf8");
+      bytes = raw.length - start;
+    }
+    this.modelSafeChunks.push(text);
+    this.modelSafeRetainedBytes += bytes;
+    while (
+      this.modelSafeRetainedBytes > this.maxRetainedBytes &&
+      this.modelSafeChunks.length > 1
+    ) {
+      const evicted = this.modelSafeChunks.shift();
+      if (evicted === undefined) break;
+      this.modelSafeRetainedBytes -= Buffer.byteLength(evicted, "utf8");
+    }
+    this.cachedModelSafeText = undefined;
+  }
 }

package/extensions/background-terminals/src/prompt.ts

@@ -6,6 +6,7 @@ import {
   formatSize,
   truncateTail,
 } from "@earendil-works/pi-coding-agent";
+import { sanitizeTerminalText } from "../../shared/terminal-text.ts";
 import {
   formatDuration,
   formatElapsed,
@@ -139,7 +140,7 @@ function outputSection(
   maxLines: number,
 ) {
   if (view.totalBytes === 0) return `${label}: (empty)`;
-  const truncation = truncateTail(view.text, {
+  const truncation = truncateTail(view.modelSafeText, {
     maxBytes: Math.min(maxBytes, DEFAULT_MAX_BYTES),
     maxLines: Math.min(maxLines, DEFAULT_MAX_LINES),
   });
@@ -186,12 +187,15 @@ export function buildTerminalBatchResultMessage(
   messages: readonly string[],
   omitted = 0,
 ) {
-  if (messages.length === 1 && omitted === 0) return messages[0]!;
-  const summaries = messages.map(
+  const sanitizedMessages = messages.map(sanitizeTerminalText);
+  if (sanitizedMessages.length === 1 && omitted === 0) {
+    return sanitizedMessages[0]!;
+  }
+  const summaries = sanitizedMessages.map(
     (message) => message.split("\n", 1)[0] || "Background terminal result",
   );
   const header = [
-    `${messages.length} background terminal result${messages.length === 1 ? "" : "s"}:`,
+    `${sanitizedMessages.length} background terminal result${sanitizedMessages.length === 1 ? "" : "s"}:`,
     ...summaries.map((summary) => `- ${summary}`),
     omitted > 0
       ? `- ${omitted} older result${omitted === 1 ? "" : "s"} omitted from this bounded batch; use bg_list/bg_status for retained details.`
@@ -206,7 +210,7 @@ export function buildTerminalBatchResultMessage(
     `${header}${logsHeader}${truncationMarker}`,
     "utf8",
   );
-  const logs = truncateTail(messages.join("\n\n"), {
+  const logs = truncateTail(sanitizedMessages.join("\n\n"), {
     maxBytes: Math.max(1, RESULT_BATCH_MAX - fixedBytes),
     maxLines: DEFAULT_MAX_LINES,
   });
@@ -220,6 +224,10 @@ export function buildKillReport(results: ReadonlyArray<KillResult>) {
       if (entry.killed) {
         return `Killed ${entry.id} "${entry.title}" (${entry.exit}).`;
       }
+      if (entry.terminationFailed) {
+        const detail = entry.errorText ? ` ${entry.errorText}.` : "";
+        return `Could not confirm process-tree termination for ${entry.id} "${entry.title}" (${entry.exit}).${detail}`;
+      }
       if (entry.wasRunning) {
         // The natural exit won the race with the kill signal.
         return `${entry.id} "${entry.title}" exited on its own before the kill landed (${entry.exit}).`;

package/extensions/background-terminals/src/result-delivery.ts

@@ -1,43 +1,66 @@
+import type { ConsumableResultDeliveryQueue } from "../../shared/result-delivery.ts";
+import {
+  type CompletionOwner,
+  createCompletionInbox,
+} from "../../shared/completion-inbox.ts";
+
 /**
- * Deferred one-shot delivery map (same semantics as subagents'): a settled
- * terminal's result is held here until it is either drained into a follow-up
- * message or consumed by a tool call (bg_kill / bg_status) that already
- * returned the settlement itself. Keyed by id, so double delivery is
- * structurally impossible — whoever drains first wins.
+ * Deferred one-shot delivery adapter (same semantics as subagents'): a
+ * settled terminal's result is held in the shared inbox until it is either
+ * drained into a follow-up message or consumed by a tool call (bg_kill /
+ * bg_status) that already returned the settlement itself. Stable ids make
+ * double delivery structurally impossible — whoever claims first wins.
  */
-export function createDeferredResultDelivery<T extends { id: string }>() {
-  const pending = new Map<string, T>();
+export function createDeferredResultDelivery<T extends { id: string }>(
+  options: { readonly owner?: () => CompletionOwner | undefined } = {},
+) {
+  const inbox = createCompletionInbox<T>();
+  const owner = options.owner ?? (() => ({ sessionId: "test", epoch: 0 }));
 
-  return {
+  const queue = {
     defer(result: T) {
-      pending.set(result.id, result);
-      return pending.size;
+      const currentOwner = owner();
+      inbox.defer(
+        {
+          deliveryId: `background:${result.id}`,
+          owner: currentOwner ?? { sessionId: "unowned", epoch: 0 },
+          producer: "background",
+          producerId: result.id,
+          terminalRef: { kind: "terminal-snapshot", id: result.id },
+          wake: "producer-policy",
+          payload: result,
+        },
+        currentOwner,
+      );
+      return inbox.size();
     },
     consume(ids: Iterable<string>) {
-      for (const id of ids) pending.delete(id);
+      inbox.consume("background", ids);
     },
     drain(maxResults = Number.POSITIVE_INFINITY) {
-      const results: T[] = [];
-      for (const [id, result] of pending) {
-        if (results.length >= maxResults) break;
-        results.push(result);
-        pending.delete(id);
-      }
-      return results;
+      return inbox
+        .claim(owner(), maxResults)
+        .map((envelope) => envelope.payload);
     },
     restore(results: readonly T[]) {
-      const current = [...pending.values()];
-      pending.clear();
-      for (const result of results) pending.set(result.id, result);
-      for (const result of current) pending.set(result.id, result);
+      inbox.retryClaimed(
+        "background",
+        results.map((result) => result.id),
+        owner(),
+      );
+    },
+    acknowledge(results: readonly T[]) {
+      inbox.acknowledge(results.map((result) => `background:${result.id}`));
     },
     size() {
-      return pending.size;
+      return inbox.size();
     },
     clear() {
-      pending.clear();
+      inbox.clear();
     },
+    inspectDeadLetters: inbox.inspectDeadLetters,
   };
+  return queue satisfies ConsumableResultDeliveryQueue<T>;
 }
 
 /**

package/extensions/clear-context/index.ts

@@ -0,0 +1,83 @@
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, type EditorComponent } from "@earendil-works/pi-tui";
+import {
+  BelowEditorNavigationEditor,
+  BelowEditorStripState,
+} from "../shared/below-editor-navigation.ts";
+import {
+  registerEditorLayer,
+  removeEditorLayer,
+} from "../shared/editor-layers.ts";
+
+export function shouldClearContext(
+  data: string,
+  editorText: string,
+  isIdle: boolean,
+) {
+  return isIdle && editorText.length === 0 && matchesKey(data, Key.ctrl("c"));
+}
+
+export class ClearContextEditor extends BelowEditorNavigationEditor {
+  private readonly isIdle: () => boolean;
+
+  constructor(
+    base: EditorComponent,
+    keybindings: KeybindingsManager,
+    isIdle: () => boolean,
+  ) {
+    super(
+      base,
+      keybindings,
+      new BelowEditorStripState(),
+      () => false,
+      () => undefined,
+      () => undefined,
+    );
+    this.isIdle = isIdle;
+  }
+
+  override handleInput(data: string) {
+    if (shouldClearContext(data, this.getText(), this.isIdle())) {
+      // Route through Pi's built-in /new command so session replacement keeps
+      // Pi's persistence, cleanup, and transcript lifecycle as the source of truth.
+      this.setText("/new");
+      this.onSubmit?.("/new");
+      return;
+    }
+
+    super.handleInput(data);
+  }
+}
+
+function installClearContextShortcut(pi: ExtensionAPI, ctx: ExtensionContext) {
+  if (ctx.mode !== "tui") return () => {};
+
+  registerEditorLayer(pi, ctx, {
+    id: "clear-context",
+    order: 100,
+    wrap: (base, _tui, _theme, keybindings) =>
+      new ClearContextEditor(base, keybindings, () => ctx.isIdle()),
+  });
+
+  return () => removeEditorLayer(pi, "clear-context");
+}
+
+export default function clearContext(pi: ExtensionAPI) {
+  let removeShortcut = () => {};
+
+  pi.on("session_start", (_event, ctx) => {
+    removeShortcut();
+    removeShortcut = installClearContextShortcut(pi, ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    removeShortcut();
+    removeShortcut = () => {};
+  });
+}
+
+export { installClearContextShortcut };

package/extensions/context-pivot/index.ts

@@ -11,6 +11,9 @@ import {
 
 export const MIN_CONTEXT_PIVOT_TOKENS = 30_000;
 const STATUS_KEY = "context-pivot";
+const NOTHING_TO_COMPACT_ERROR = "Nothing to compact (session too small)";
+const NO_DISCARDABLE_HISTORY_MESSAGE =
+  "Context pivot could not run: this session has no discardable history to compact. Continue in the current session, or use /sessions to choose another session; to begin cleanly, start a new Session in Pi.";
 
 interface PendingPivot {
   brief: string;
@@ -57,6 +60,13 @@ export function buildPivotSummary(brief: string): string {
   ].join("\n");
 }
 
+function formatContextPivotError(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message === NOTHING_TO_COMPACT_ERROR
+    ? NO_DISCARDABLE_HISTORY_MESSAGE
+    : `Context pivot failed: ${message}`;
+}
+
 function impossibleKeptId(entries: readonly SessionEntry[]) {
   return `${entries.at(-1)?.id ?? "context-pivot"}-context-pivot-cut`;
 }
@@ -73,7 +83,7 @@ function validateBrief(brief: string, ctx: ExtensionContext) {
   }
   if (tokens < MIN_CONTEXT_PIVOT_TOKENS) {
     throw new Error(
-      `Context is only ${Math.round(tokens).toLocaleString()} tokens; use context_pivot once context reaches at least ${MIN_CONTEXT_PIVOT_TOKENS.toLocaleString()} tokens, or /handoff for a genuinely new session.`,
+      `Context is only ${Math.round(tokens).toLocaleString()} tokens; use context_pivot once context reaches at least ${MIN_CONTEXT_PIVOT_TOKENS.toLocaleString()} tokens, or use /sessions to browse or switch an existing session; start a new Session in Pi when a clean session is needed.`,
     );
   }
 }
@@ -127,7 +137,7 @@ export default function contextPivot(pi: ExtensionAPI) {
     name: "context_pivot",
     label: "Context Pivot",
     description:
-      "Deliberately replace a long, noisy active context with a concise brief for the next phase while staying in the same Pi session. Use once context is at least 30k tokens and the work is moving between phases such as research → implementation or implementation → review; below 30k it is rejected. Use /handoff instead for a genuinely new session.",
+      "Deliberately replace a long, noisy active context with a concise brief for the next phase while staying in the same Pi session. Use once context is at least 30k tokens and the work is moving between phases such as research → implementation or implementation → review; below 30k it is rejected. Use /sessions to browse or switch an existing session; start a new Session in Pi when a genuinely new session is needed.",
     promptSnippet:
       "Compress a long current session into a clean brief before changing phase",
     promptGuidelines: [
@@ -176,11 +186,11 @@ export default function contextPivot(pi: ExtensionAPI) {
           onError: (error) => {
             if (pivotGeneration === generation) pending = undefined;
             clear();
+            const message = formatContextPivotError(error);
             if (ctx.hasUI) {
-              ctx.ui.notify(
-                `Context pivot failed: ${error instanceof Error ? error.message : String(error)}`,
-                "error",
-              );
+              ctx.ui.notify(message, "error");
+            } else {
+              console.error(message);
             }
           },
         });

package/extensions/cron/index.ts

@@ -17,6 +17,9 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import {
   advanceDeliveredJobs,
+  CRON_DELIVERY_MAX_BYTES,
+  CRON_DELIVERY_MAX_JOBS,
+  CRON_MAX_JOBS,
   type CronJob,
   dueJobs,
   formatInterval,
@@ -41,6 +44,48 @@ const SYSTEM_RUNTIME: CronRuntime = {
   },
 };
 
+function deliveryMessage(due: readonly CronJob[]) {
+  const jobs = due.map((job) => ({
+    id: job.id,
+    prompt: job.prompt,
+    recurring: job.intervalMs !== undefined,
+  }));
+  return due.length === 1
+    ? {
+        customType: "cron-fire",
+        content: `[cron ${jobs[0]!.id} · ${jobs[0]!.recurring ? "recurring" : "once"}]\n${jobs[0]!.prompt}`,
+        display: true,
+        details: jobs[0]!,
+      }
+    : {
+        customType: "cron-fire",
+        content: `${due.length} scheduled prompts are due:\n\n${jobs
+          .map(
+            (job) =>
+              `[cron ${job.id} · ${job.recurring ? "recurring" : "once"}]\n${job.prompt}`,
+          )
+          .join("\n\n")}`,
+        display: true,
+        details: { count: jobs.length, jobs },
+      };
+}
+
+function dueDeliveryBatch(due: readonly CronJob[]) {
+  const selected: CronJob[] = [];
+  for (const job of due.slice(0, CRON_DELIVERY_MAX_JOBS)) {
+    const candidate = [...selected, job];
+    const message = deliveryMessage(candidate);
+    if (
+      new TextEncoder().encode(message.content).byteLength >
+      CRON_DELIVERY_MAX_BYTES
+    ) {
+      break;
+    }
+    selected.push(job);
+  }
+  return selected;
+}
+
 export default function cron(
   pi: ExtensionAPI,
   runtime: CronRuntime = SYSTEM_RUNTIME,
@@ -58,30 +103,7 @@ export default function cron(
   const fire = (due: readonly CronJob[]) => {
     if (due.length === 0) return true;
     try {
-      const jobs = due.map((job) => ({
-        id: job.id,
-        prompt: job.prompt,
-        recurring: job.intervalMs !== undefined,
-      }));
-      const message =
-        due.length === 1
-          ? {
-              customType: "cron-fire",
-              content: `[cron ${jobs[0]!.id} · ${jobs[0]!.recurring ? "recurring" : "once"}]\n${jobs[0]!.prompt}`,
-              display: true,
-              details: jobs[0],
-            }
-          : {
-              customType: "cron-fire",
-              content: `${due.length} scheduled prompts are due:\n\n${jobs
-                .map(
-                  (job) =>
-                    `[cron ${job.id} · ${job.recurring ? "recurring" : "once"}]\n${job.prompt}`,
-                )
-                .join("\n\n")}`,
-              display: true,
-              details: { count: jobs.length, jobs },
-            };
+      const message = deliveryMessage(due);
       pi.sendMessage<
         | { id: number; prompt: string; recurring: boolean }
         | {
@@ -109,9 +131,11 @@ export default function cron(
     const now = runtime.now();
     const due = dueJobs(jobs, now);
     if (due.length === 0) return;
+    const batch = dueDeliveryBatch(due);
+    if (batch.length === 0) return;
     const deliveredIds = new Set<number>();
-    if (fire(due)) {
-      for (const job of due) deliveredIds.add(job.id);
+    if (fire(batch)) {
+      for (const job of batch) deliveredIds.add(job.id);
     }
     jobs = advanceDeliveredJobs(jobs, deliveredIds, runtime.now());
     if (jobs.length === 0) stopTicker();
@@ -170,12 +194,29 @@ export default function cron(
         return;
       }
 
+      if (jobs.length >= CRON_MAX_JOBS) {
+        ctx.ui.notify(
+          `A session can have at most ${CRON_MAX_JOBS} scheduled prompts. Remove one before adding another.`,
+          "warning",
+        );
+        return;
+      }
+
       const intervalMs = parsed.intervalMs!;
+      const now = runtime.now();
+      const nextRunAt = now + intervalMs;
+      if (!Number.isSafeInteger(now) || !Number.isSafeInteger(nextRunAt)) {
+        ctx.ui.notify(
+          "Scheduled time is too far in the future. Use a shorter duration.",
+          "warning",
+        );
+        return;
+      }
       const job: CronJob = {
         id: nextId++,
         prompt: parsed.prompt!,
         ...(parsed.oneShot ? {} : { intervalMs }),
-        nextRunAt: runtime.now() + intervalMs,
+        nextRunAt,
       };
       jobs.push(job);
       startTicker();

package/extensions/cron/schedule.ts

@@ -22,6 +22,9 @@ const UNITS: Record<string, number> = {
 
 export const MIN_INTERVAL_MS = 30_000;
 export const CRON_PROMPT_MAX_CHARS = 2_000;
+export const CRON_MAX_JOBS = 64;
+export const CRON_DELIVERY_MAX_JOBS = 16;
+export const CRON_DELIVERY_MAX_BYTES = 48 * 1024;
 
 /**
  * Parse a duration like `30s`, `5m`, `2h`. Deliberately a small duration
@@ -33,7 +36,8 @@ export function parseDuration(text: string): number | undefined {
   if (!match) return undefined;
   const value = Number(match[1]);
   if (!Number.isFinite(value) || value <= 0) return undefined;
-  return value * UNITS[match[2].toLowerCase()];
+  const durationMs = value * UNITS[match[2].toLowerCase()];
+  return Number.isSafeInteger(durationMs) ? durationMs : undefined;
 }
 
 export interface ParsedCronCommand {
@@ -81,8 +85,14 @@ export function parseCronCommand(raw: string): ParsedCronCommand {
       error: `Minimum interval is ${MIN_INTERVAL_MS / 1000}s (the scheduler polls about that often).`,
     };
   }
-  const prompt = schedule[3].trim().slice(0, CRON_PROMPT_MAX_CHARS);
+  const prompt = schedule[3].trim();
   if (!prompt) return { action: "help", error: "Provide a prompt to run." };
+  if (prompt.length > CRON_PROMPT_MAX_CHARS) {
+    return {
+      action: "help",
+      error: `Prompt is too long. Maximum is ${CRON_PROMPT_MAX_CHARS} characters.`,
+    };
+  }
   return {
     action: "add",
     intervalMs,