@bermudi/pi-delegate 0.1.19 → 0.1.20

package/README.md

@@ -151,7 +151,7 @@ Async tickets keep running after the parent's turn settles, and pi renders an
 idle session — so delegate adds three signals:
 
 - **Footer status** — while any ticket is active, the footer shows
-  `⏳ 2 subagents · t5042v19`, updated live as subagents start and finish.
+  `⏳ 2 subagents · t5042v19 · /subagents`, updated live as subagents start and finish.
 - **Settle warning** — the first time a turn settles with a ticket still
   active, a warning notification names the ticket and reminds you that
   quitting aborts it. Once per ticket; the footer carries it from there.
@@ -164,6 +164,54 @@ the mitigation there; on quit, delegate also prints a trace line to the
 terminal naming the aborted tickets and agents, and on `/reload` it shows a
 warning notification.
 
+### Live subagent browser
+
+Press **Ctrl+Shift+B** from the editor, or run **`/subagents`**, to open a live
+browser without sending a model request. It shows both sync tasks and async
+tickets, including retained completed work. Your draft is left untouched.
+
+| Key | Action |
+| --- | --- |
+| ↑ / ↓ | Select an agent |
+| Tab / ← / → | Switch between tool activity and assistant responses |
+| PgUp / PgDn | Scroll the selected view |
+| Home / End | Jump to oldest retained text / follow live output |
+| p | Pause or resume the selected agent's **whole async ticket** |
+| Esc | Close and return to your draft |
+
+The view shows running commands, tool results, edited file paths, queue
+dependencies, errors, token counts and activity age. Pause controls use the
+same cooperative boundary described below; they do not freeze subprocesses.
+Down in the editor keeps its normal behavior rather than intercepting menus
+or replacing a custom editor.
+
+This is a bounded live preview, not a transcript archive: assistant text keeps
+the current attempt's last 32K characters (no thinking blocks); tool activity
+shows up to 100 recent calls with output tails. The browser retains the last
+20 completed sync calls. Async results remain available until the existing
+ticket cleanup removes them (eligible after 30 minutes). Nothing is recovered
+from transcripts after a restart. A refresh timer runs only while the browser
+is open and is cleared on close or shutdown. This feature requires Pi's TUI,
+not print/JSON/RPC mode.
+
+### Pause and resume
+
+Pause an async ticket with `delegate({ ticketAction: "pause", ticket: "<id>" })`;
+continue it with `ticketAction: "resume"`. Both return immediately.
+
+Each current model response and its tool calls finish, then the agent waits
+before its next model request. Queued tasks do not start. **Pausing** means
+work is reaching that boundary; **paused** means it has reached it. A task
+that finishes naturally may complete instead. Resume keeps the same live
+conversations, including scratch workspaces.
+
+Pause is not cancellation, rollback, or a process freeze. Background commands
+can keep running, and files may be unfinished. In-progress isolated preparation
+or application finishes before pausing. Sessions, concurrency slots and
+workspace reservations remain held. Inactivity checks stop while parked, but
+explicit wall-clock deadlines keep counting. Wait does not resume work; cancel
+still works. Pauses do not survive Pi exit or reload.
+
 ### Stall detection and cancellation
 
 `stallTimeoutMs` is an inactivity watchdog, not a hard execution deadline. When
@@ -231,7 +279,7 @@ over an installed extension.
 - **Resumed subagent** — A subagent rehydrated from a previous session `.jsonl`
   via `resumeFrom`. It can also be pooled by providing a `sessionId`.
 - **Async ticket** — A background execution handle returned when top-level
-  `async: true` is used. Poll, wait, or cancel tickets with top-level
+  `async: true` is used. Poll, wait, pause, resume, or cancel tickets with top-level
   `ticketAction: "poll"`, `ticketAction: "wait"` (blocks until the ticket settles;
   optional `timeoutMs`), or `ticketAction: "cancel"`.
 - **Skill** — A `SKILL.md` instruction bundle injected into the subagent system

package/assistant-preview.ts

@@ -0,0 +1,31 @@
+/** Human-facing, bounded text preview. Never includes thinking blocks or reads
+ * transcripts from disk. Updates replace the current response, not append
+ * streaming snapshots; completed responses remain available for scrollback. */
+export class AssistantPreview {
+  private completed = "";
+  private current = "";
+  static readonly limit = 32_768;
+
+  update(text: string): void {
+    // Empty synthetic provider failures must not erase a streamed response.
+    if (text) this.current = text.slice(-AssistantPreview.limit);
+  }
+
+  finish(text: string): void {
+    this.update(text);
+    if (this.current) {
+      this.completed = [this.completed, this.current]
+        .filter(Boolean)
+        .join("\n\n")
+        .slice(-AssistantPreview.limit);
+      this.current = "";
+    }
+  }
+
+  get text(): string {
+    return [this.completed, this.current]
+      .filter(Boolean)
+      .join("\n\n")
+      .slice(-AssistantPreview.limit);
+  }
+}

package/browser-state.ts

@@ -0,0 +1,250 @@
+import type { DelegateRuntime } from "./runtime.ts";
+import type {
+  AsyncTicket,
+  DelegateDetails,
+  TaskProgress,
+  ToolActivity,
+} from "./types.ts";
+
+interface SyncDetails {
+  tasks: { prompt?: string }[];
+  progress: TaskProgress[];
+  results: { output?: string; error?: string }[];
+  serializedNotice?: string;
+  dispatchWarning?: string;
+}
+
+/** Finished sync calls must not pin entire tool arguments/results after the
+ * parent compacts. Keep only primitive display arguments and bounded text. */
+function compactProgress(p: TaskProgress): TaskProgress {
+  let budget = 65_536;
+  const activities: ToolActivity[] = [];
+  const take = (text: string): string => {
+    const limit = Math.min(4096, budget);
+    if (limit <= 0) return "";
+    const value = text.length > limit ? `…${text.slice(-limit)}` : text;
+    budget -= value.length;
+    return value;
+  };
+  for (const tool of p.activities.slice(-100).reverse()) {
+    if (budget <= 0) break;
+    const args: Record<string, unknown> = {};
+    for (const key of [
+      "path",
+      "file_path",
+      "command",
+      "pattern",
+      "query",
+      "url",
+      "task",
+      "prompt",
+      "offset",
+      "limit",
+    ]) {
+      const value = tool.args[key];
+      if (typeof value === "string" && budget > 0) args[key] = take(value);
+      else if (typeof value === "number") args[key] = value;
+    }
+    const output = tool.result
+      ? tool.result.content
+          .filter((part) => part.type === "text")
+          .slice(-20)
+          .map((part) => part.text?.slice(-4096) ?? "")
+          .join("\n")
+      : (tool.liveOutput ?? "");
+    const text = budget > 0 ? take(output) : "";
+    activities.push({
+      id: tool.id,
+      name: tool.name,
+      args,
+      startTime: tool.startTime,
+      endTime: tool.endTime,
+      result: tool.result
+        ? { isError: tool.result.isError, content: [{ type: "text", text }] }
+        : undefined,
+      liveOutput: tool.result ? undefined : text,
+    });
+  }
+  return {
+    ...p,
+    assistantPreview: p.assistantPreview?.slice(-32_768),
+    error: p.error?.slice(0, 4096),
+    activities: activities.reverse(),
+    warnings: [
+      ...(p.warnings ?? []).slice(0, 10).map((s) => s.slice(0, 4096)),
+      ...(activities.length < p.activities.length
+        ? ["Earlier tool activity omitted from retained sync preview."]
+        : []),
+    ],
+  };
+}
+
+function compactDetails(details: SyncDetails): SyncDetails {
+  return {
+    tasks: details.tasks.map((task) => ({
+      prompt: task.prompt?.slice(0, 4096),
+    })),
+    progress: details.progress.map(compactProgress),
+    results: details.results.map((result) => ({
+      output: result.output?.slice(-32_768),
+      error: result.error?.slice(0, 4096),
+    })),
+    serializedNotice: details.serializedNotice?.slice(0, 4096),
+    dispatchWarning: details.dispatchWarning?.slice(0, 4096),
+  };
+}
+
+interface SyncRun {
+  details: SyncDetails;
+  finished: boolean;
+  created: number;
+  error?: string;
+}
+
+/** UI-only history. Active sync runs are never evicted; retain the last twenty
+ * finished calls. Async history stays owned by the existing ticket registry. */
+export class BrowserHistory {
+  readonly runs = new Map<string, SyncRun>();
+  generation = 0;
+
+  reset(): void {
+    this.generation++;
+    this.runs.clear();
+  }
+
+  update(
+    id: string,
+    details: DelegateDetails | undefined,
+    finished: boolean,
+    generation = this.generation,
+  ): void {
+    if (generation !== this.generation) return;
+    if (!details?.progress.length) {
+      if (finished)
+        this.fail(
+          id,
+          "Dispatch ended before tasks could start; see the delegate result.",
+        );
+      return;
+    }
+    const created = this.runs.get(id)?.created ?? Date.now();
+    this.runs.delete(id);
+    this.runs.set(id, {
+      details: finished ? compactDetails(details) : details,
+      finished,
+      created,
+    });
+    this.prune();
+  }
+
+  fail(id: string, error: unknown, generation = this.generation): void {
+    if (generation !== this.generation) return;
+    const run = this.runs.get(id);
+    if (!run) return;
+    run.finished = true;
+    run.details = compactDetails(run.details);
+    run.error = (error instanceof Error ? error.message : String(error)).slice(
+      0,
+      4096,
+    );
+    this.runs.delete(id);
+    this.runs.set(id, run);
+    this.prune();
+  }
+
+  private prune(): void {
+    const finished = [...this.runs].filter(([, run]) => run.finished);
+    for (const [id] of finished.slice(0, -20)) this.runs.delete(id);
+  }
+}
+
+export interface BrowserRow {
+  key: string;
+  batch: string;
+  created: number;
+  progress: TaskProgress;
+  siblings: TaskProgress[];
+  prompt: string;
+  output?: string;
+  error?: string;
+  ticket?: AsyncTicket;
+  finished: boolean;
+  notice?: string;
+}
+
+export function browserRows(
+  runtime: DelegateRuntime,
+  history: BrowserHistory,
+): BrowserRow[] {
+  const rows: BrowserRow[] = [];
+  for (const ticket of runtime.tickets.values()) {
+    for (const progress of ticket.progress) {
+      const result = ticket.results[progress.index];
+      rows.push({
+        key: `${ticket.id}:${progress.index}`,
+        batch: ticket.id,
+        created: ticket.created,
+        progress,
+        siblings: ticket.progress,
+        prompt: ticket.tasks[progress.index]?.prompt ?? progress.task,
+        output: result?.output,
+        error: result?.error ?? ticket.error,
+        ticket,
+        finished: ticket.status !== "running" && ticket.status !== "cancelling",
+        notice: [ticket.serializedNotice, ticket.dispatchWarning]
+          .filter(Boolean)
+          .join("\n"),
+      });
+    }
+  }
+  for (const [id, run] of history.runs) {
+    for (const progress of run.details.progress) {
+      const result = run.details.results[progress.index];
+      rows.push({
+        key: `sync:${id}:${progress.index}`,
+        batch: `sync ${id.slice(-8)}`,
+        created: run.created,
+        progress,
+        siblings: run.details.progress,
+        prompt: run.details.tasks[progress.index]?.prompt ?? progress.task,
+        output: result?.output,
+        error: result?.error ?? run.error,
+        finished: run.finished,
+        notice: [run.details.serializedNotice, run.details.dispatchWarning]
+          .filter(Boolean)
+          .join("\n"),
+      });
+    }
+  }
+  return rows.sort(
+    (a, b) =>
+      Number(a.finished) - Number(b.finished) ||
+      b.created - a.created ||
+      a.batch.localeCompare(b.batch) ||
+      a.progress.index - b.progress.index,
+  );
+}
+
+export function browserRowStatus(row: BrowserRow): string {
+  const p = row.progress;
+  if (p.incomplete) return "incomplete — worker may still be active";
+  if (p.status === "done") return "done";
+  if (p.status === "failed") return "failed";
+  if (row.ticket?.status === "cancelling") return "cancelling";
+  if (row.finished)
+    return row.error ? "failed" : (row.ticket?.status ?? "finished");
+  if (p.paused) return "paused";
+  if (p.status === "pending") {
+    if (row.ticket?.pause && row.ticket.pause.state !== "running")
+      return "queued — ticket paused";
+    const before =
+      p.waitingFor === undefined ? undefined : row.siblings[p.waitingFor];
+    if (before && before.status !== "done" && before.status !== "failed")
+      return `queued — waiting for ${before.id ?? `task ${before.index + 1}`}`;
+    return "queued — waiting for preparation or capacity";
+  }
+  const phase = p.activity ?? "starting";
+  return row.ticket?.pause?.state === "pausing"
+    ? `${phase} — pausing after turn`
+    : phase;
+}

package/browser.ts

@@ -0,0 +1,334 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  matchesKey,
+  SelectList,
+  truncateToWidth,
+  wrapTextWithAnsi,
+  type Component,
+} from "@earendil-works/pi-tui";
+import {
+  BrowserHistory,
+  browserRows,
+  browserRowStatus,
+  type BrowserRow,
+} from "./browser-state.ts";
+import type { DelegateRuntime } from "./runtime.ts";
+import { fmtDuration, fmtTokens, formatToolCallShort } from "./format.ts";
+import { sanitizeTerminalLine, sanitizeTerminalText } from "./utils.ts";
+
+function displayTail(text: string, limit: number): string {
+  return text.length > limit
+    ? `[Earlier text omitted]\n${text.slice(-limit)}`
+    : text;
+}
+
+/** Bounded display, not a second transcript store. Full final output and tool
+ * evidence continue to belong to the task/ticket. Never render terminal escapes
+ * from model output, command output, prompts, IDs or errors. */
+export function browserDetailText(row: BrowserRow, responses: boolean): string {
+  if (responses) {
+    const text = row.output || row.progress.assistantPreview;
+    return sanitizeTerminalText(
+      displayTail(
+        text || "No assistant text yet. Tool-only turns may have no text.",
+        32_768,
+      ),
+    );
+  }
+  const context = [
+    row.error || row.progress.error
+      ? `ERROR: ${row.error ?? row.progress.error}`
+      : "",
+    row.notice ?? "",
+    ...(row.progress.warnings ?? []),
+    row.ticket?.pause?.state !== undefined &&
+    row.ticket.pause.state !== "running"
+      ? "Pause is cooperative: current turns finish; subprocesses are not frozen. Deadlines still count."
+      : "",
+  ]
+    .filter(Boolean)
+    .map((line) => line.slice(0, 4096))
+    .join("\n")
+    .slice(0, 8192);
+  const lines: string[] = [];
+  const activities = row.progress.activities.slice(-100);
+  if (row.progress.activities.length > activities.length)
+    lines.push("[Earlier tool calls omitted]");
+  for (const tool of activities) {
+    const call =
+      tool.name === "bash" && typeof tool.args.command === "string"
+        ? `$ ${tool.args.command.slice(0, 4096)}`
+        : formatToolCallShort(tool.name, tool.args);
+    lines.push(
+      `\n${tool.endTime !== undefined ? (tool.result?.isError ? "FAILED" : "DONE") : "RUNNING"} ${call.slice(0, 4096)}`,
+    );
+    const output = tool.result
+      ? tool.result.content
+          .filter((part) => part.type === "text")
+          .slice(-20)
+          .map((part) => displayTail(part.text ?? "", 4096))
+          .join("\n")
+      : tool.liveOutput;
+    if (output) lines.push(displayTail(output, 4096));
+  }
+  if (!activities.length) lines.push("No tool calls yet.");
+  return sanitizeTerminalText(
+    [context, displayTail(lines.join("\n"), 57_344)].filter(Boolean).join("\n"),
+  );
+}
+
+export class SubagentBrowser implements Component {
+  private selectedKey?: string;
+  private rows: BrowserRow[] = [];
+  private list?: SelectList;
+  private responses = false;
+  private scroll: number | undefined;
+  private pageSize = 8;
+  private maxScroll = 0;
+  private message = "";
+  private controlsVisible = false;
+
+  constructor(
+    private readonly getRows: () => BrowserRow[],
+    private readonly theme: Pick<Theme, "fg">,
+    private readonly height: () => number,
+    private readonly requestRender: () => void,
+    private readonly close: () => void,
+    private readonly pause: (row: BrowserRow) => string,
+  ) {}
+
+  invalidate(): void {}
+
+  handleInput(data: string): void {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+      this.close();
+      return;
+    }
+    if (
+      matchesKey(data, "tab") ||
+      matchesKey(data, "left") ||
+      matchesKey(data, "right")
+    ) {
+      this.responses = !this.responses;
+      this.scroll = undefined;
+    } else if (matchesKey(data, "pageUp")) {
+      this.scroll = Math.max(
+        0,
+        (this.scroll ?? this.maxScroll) - this.pageSize,
+      );
+    } else if (matchesKey(data, "pageDown")) {
+      const next = (this.scroll ?? this.maxScroll) + this.pageSize;
+      this.scroll = next >= this.maxScroll ? undefined : next;
+    } else if (matchesKey(data, "home")) {
+      this.scroll = 0;
+    } else if (matchesKey(data, "end")) {
+      this.scroll = undefined;
+    } else if (data === "p") {
+      if (!this.controlsVisible) return;
+      const row = this.getRows().find((r) => r.key === this.selectedKey);
+      if (row) this.message = this.pause(row);
+    } else {
+      this.list?.handleInput(data);
+    }
+    this.requestRender();
+  }
+
+  render(width: number): string[] {
+    const height = Math.max(1, this.height());
+    this.controlsVisible = height >= 14 && width >= 25;
+    if (width <= 0) return [];
+    const w = Math.max(1, width);
+    if (!this.controlsVisible)
+      return [truncateToWidth("Subagents · enlarge terminal · Esc closes", w)];
+    this.rows = this.getRows();
+    if (!this.rows.some((row) => row.key === this.selectedKey)) {
+      this.selectedKey = this.rows[0]?.key;
+      this.scroll = undefined;
+    }
+    const rosterHeight = Math.min(
+      this.rows.length,
+      5,
+      Math.max(1, Math.floor(height / 4)),
+    );
+    this.list = new SelectList(
+      this.rows.map((row) => ({
+        value: row.key,
+        label: sanitizeTerminalLine(
+          `${row.progress.id ?? `task ${row.progress.index + 1}`} · ${row.progress.agent} · ${row.batch}`,
+        ),
+        description: sanitizeTerminalLine(browserRowStatus(row)),
+      })),
+      rosterHeight,
+      {
+        selectedPrefix: (s) => this.theme.fg("accent", s),
+        selectedText: (s) => this.theme.fg("accent", s),
+        description: (s) => this.theme.fg("muted", s),
+        scrollInfo: (s) => this.theme.fg("dim", s),
+        noMatch: (s) => this.theme.fg("muted", s),
+      },
+    );
+    this.list.setSelectedIndex(
+      Math.max(
+        0,
+        this.rows.findIndex((r) => r.key === this.selectedKey),
+      ),
+    );
+    this.list.onSelectionChange = (item) => {
+      this.selectedKey = item.value;
+      this.scroll = undefined;
+      this.message = "";
+    };
+    const row = this.rows.find((r) => r.key === this.selectedKey);
+    const lines = [
+      this.theme.fg("accent", "Subagents · live browser"),
+      ...this.list.render(w),
+    ];
+    if (row) {
+      const p = row.progress;
+      lines.push(
+        sanitizeTerminalLine(
+          `${browserRowStatus(row)} · ${fmtDuration(p.durationMs)} · ${fmtTokens(p.tokens)} tokens · ${p.toolUses} tools · ${p.model ?? ""}`,
+        ),
+        ...(!row.finished && p.lastActivityAt
+          ? [
+              sanitizeTerminalLine(
+                `Last event ${fmtDuration(Math.max(0, Date.now() - p.lastActivityAt))} ago`,
+              ),
+            ]
+          : []),
+        sanitizeTerminalLine(`Task: ${row.prompt.slice(0, 4096)}`),
+        this.theme.fg(
+          "accent",
+          `${this.responses ? "Responses (32K character tail)" : "Tool activity"} · ${this.scroll === undefined ? "following live" : "scrollback"} · Tab switches view`,
+        ),
+      );
+      this.pageSize = Math.max(1, height - lines.length - 3);
+      const detail = browserDetailText(row, this.responses)
+        .split("\n")
+        .flatMap((line) => wrapTextWithAnsi(line, w));
+      this.maxScroll = Math.max(0, detail.length - this.pageSize);
+      const start =
+        this.scroll === undefined
+          ? this.maxScroll
+          : Math.min(this.scroll, this.maxScroll);
+      lines.push(...detail.slice(start, start + this.pageSize));
+      while (lines.length < height - 3) lines.push("");
+      const pauseLabel =
+        row.ticket?.status === "running" && row.ticket.pause
+          ? `p ${row.ticket.pause.state === "running" ? "pause" : "resume"} WHOLE ticket ${row.ticket.id} (${row.siblings.length} tasks)`
+          : "Pause/resume available only for live async tickets";
+      lines.push(
+        this.theme.fg(
+          "muted",
+          sanitizeTerminalLine(this.message || pauseLabel),
+        ),
+      );
+    } else {
+      lines.push(
+        "No subagents yet. This view includes live and retained completed tasks.",
+      );
+    }
+    lines.push(
+      this.theme.fg(
+        "dim",
+        "↑↓ agent · PgUp/PgDn scroll · Home oldest · End live",
+      ),
+      this.theme.fg("dim", "Tab activity/responses · Esc back to draft"),
+    );
+    return lines.slice(0, height).map((line) => truncateToWidth(line, w));
+  }
+}
+
+/** One UI per extension lifetime. Refresh only while visible: closed browsers
+ * own no timer, no terminal listener, and no extra ticket waiter. */
+export function registerSubagentBrowser(
+  pi: ExtensionAPI,
+  runtime: DelegateRuntime,
+): BrowserHistory {
+  const history = new BrowserHistory();
+  let closeCurrent: (() => void) | undefined;
+  let opening = false;
+  const open = async (ctx: ExtensionContext): Promise<void> => {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(
+        "The subagent browser requires Pi's terminal UI.",
+        "warning",
+      );
+      return;
+    }
+    if (opening) return;
+    opening = true;
+    let timer: ReturnType<typeof setInterval> | undefined;
+    try {
+      await ctx.ui.custom<void>(
+        (tui, theme, _keys, done) => {
+          closeCurrent = () => done();
+          timer = setInterval(() => tui.requestRender(), 200);
+          timer.unref?.();
+          return new SubagentBrowser(
+            () => browserRows(runtime, history),
+            theme,
+            () => Math.max(1, Math.floor(tui.terminal.rows * 0.85)),
+            () => tui.requestRender(),
+            () => done(),
+            (row) => {
+              try {
+                const ticket = row.ticket;
+                if (!ticket?.pause || ticket.status !== "running")
+                  return "This task has no live async ticket to pause.";
+                const action =
+                  ticket.pause.state === "running" ? "pause" : "resume";
+                const result = runtime.tickets.handlePause({
+                  ticket: ticket.id,
+                  ticketAction: action,
+                });
+                return result.details.ticketId !== ticket.id
+                  ? result.content
+                      .filter((c) => c.type === "text")
+                      .map((c) => c.text)
+                      .join(" ")
+                  : "";
+              } catch (error) {
+                console.error("[delegate] browser pause/resume failed", error);
+                return `Pause/resume failed: ${error instanceof Error ? error.message : String(error)}`;
+              }
+            },
+          );
+        },
+        {
+          overlay: true,
+          overlayOptions: { width: "95%", maxHeight: "85%", anchor: "center" },
+        },
+      );
+    } catch (error) {
+      console.error("[delegate] subagent browser failed", error);
+      ctx.ui.notify(
+        sanitizeTerminalLine(
+          `Subagent browser failed: ${error instanceof Error ? error.message : String(error)}`,
+        ),
+        "error",
+      );
+    } finally {
+      if (timer !== undefined) clearInterval(timer);
+      closeCurrent = undefined;
+      opening = false;
+    }
+  };
+  pi.registerCommand("subagents", {
+    description: "Browse live subagents and retained results",
+    handler: async (_args, ctx) => open(ctx),
+  });
+  pi.registerShortcut("ctrl+shift+b", {
+    description: "Open live subagent browser",
+    handler: open,
+  });
+  pi.on("session_shutdown", () => {
+    closeCurrent?.();
+    history.reset();
+  });
+  return history;
+}

package/delegate.ts

@@ -21,6 +21,7 @@ export type {
   TaskRunEnv,
 } from "./types.ts";
 export type { DelegateConfig } from "./config.ts";
+export type { PauseState } from "./pause.ts";
 
 export {
   DEFAULT_AGENT_NAME,
@@ -76,6 +77,7 @@ export {
   isSessionBusy,
   handlePoll,
   handleCancel,
+  handlePause,
   handleWait,
   notifyWaiters,
   deliverTicketResults,