@bermudi/pi-delegate 0.1.0 → 0.1.2

package/README.md

@@ -11,13 +11,32 @@ as a standalone repo (full history preserved).
 
 ## Install
 
-Symlink the **bundled** output into Pi's global extensions dir:
+Install a reviewed Git commit or release tag as a Pi package:
 
 ```bash
-ln -s "$PWD/delegate.bundle.ts" ~/.pi/agent/extensions/delegate.ts
+# Replace this with a reviewed commit or release tag; do not use a moving branch.
+pi install git:github.com/bermudi/pi-delegate@<reviewed-commit-or-tag>
 ```
 
-Then `/reload` in Pi.
+Remove any old `delegate.ts` symlink from `~/.pi/agent/extensions/` before
+starting Pi. Pi loads `delegate.ts` from the isolated Git package checkout; do
+not point a running Pi at this repository or at `.build/delegate.bundle.ts`.
+Start a fresh Pi process after updating the installed ref.
+
+## Usage
+
+Use the built-in `default` profile to run a subagent with the live parent's
+model, thinking level, delegatable native tools, and base system prompt:
+
+```ts
+delegate({
+  tasks: [{ agent: "default", prompt: "Investigate the auth module" }],
+});
+```
+
+Parent extension/MCP tools are not copied, and project instructions are rebuilt
+for the task's `cwd`. Omit `agent` when you want an ad-hoc task using delegate's
+normal inline defaults instead.
 
 ### Token accounting
 
@@ -30,6 +49,25 @@ which has no usage slot. The per-call aggregate (`Nk tokens`) is still shown in
 the delegate header for both modes. Use sync delegation when totals must roll
 into the session.
 
+### Background-work visibility
+
+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.
+- **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.
+- **Switch/fork guard** — `/new`, `/resume`, and forking ask for confirmation
+  before killing live subagents (pi lets extensions cancel those paths).
+
+Quitting (Ctrl+C×2 / Ctrl+D / `/quit`) and `/reload` **cannot be intercepted**
+by an extension — pi's `session_shutdown` is advisory. The footer status is
+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.
+
 ### Stall detection and cancellation
 
 `stallTimeoutMs` is an inactivity watchdog, not a hard execution deadline. When
@@ -46,13 +84,15 @@ task result. Set `stallTimeoutMs` to `0` to disable the watchdog.
 
 ```bash
 bun install
-bun run build       # regenerate delegate.bundle.ts
 bun run typecheck
 bun test
+bun run build       # optional disposable bundle smoke test
 ```
 
-The unbundled entry is `delegate.ts`; `extension.ts` holds the tool implementation.
-`delegate.bundle.ts` is generated by `bun run build` — do not edit by hand.
+The package entry point is `delegate.ts`; `extension.ts` holds the tool
+implementation. `.build/delegate.bundle.ts` is generated by `bun run build` and
+is only a verification artifact. Never symlink it into a running Pi or build
+over an installed extension.
 
 ## Glossary
 
@@ -61,6 +101,9 @@ The unbundled entry is `delegate.ts`; `extension.ts` holds the tool implementati
   `systemPrompt`, `thinking`, `cwd`, `context`, `sessionId`, or `resumeFrom`.
   `model` is also accepted but should be rare — subagents inherit the parent
   model by default.
+- **Default subagent** — The reserved built-in `agent: "default"` profile. It
+  mirrors the live parent's model, thinking level, delegatable native tools, and
+  base system prompt while preserving delegate's extension/context isolation.
 - **Custom agent** — A subagent profile defined by the parent, either inline in
   a delegate task (`systemPrompt`, `tools`, and `thinking`) or persisted as a
   Markdown file. The subagent inherits the parent model by default; `model` is a
@@ -83,10 +126,12 @@ The unbundled entry is `delegate.ts`; `extension.ts` holds the tool implementati
 - **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 or cancel tickets with top-level `action: "poll"`
-  or `action: "cancel"`.
+  `async: true` is used. Poll, wait, 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
   prompt. Skills are text instructions only; they do not unlock additional
   tools.
-- **AGENTS.md context** — Project and global guidance files automatically
-  appended to subagent system prompts, separate from named agent definitions.
+- **AGENTS.md context** — Project and ancestor guidance files are automatically
+  appended to subagent system prompts. User-global AGENTS.md files are excluded;
+  they describe the parent harness, not the delegated task.

package/agents.ts

@@ -6,7 +6,11 @@ import type {
   ThinkingLevel,
 } from "@earendil-works/pi-agent-core";
 import { parseFrontmatter as parsePiFrontmatter } from "@earendil-works/pi-coding-agent";
-import { DEFAULT_TOOLS, VALID_THINKING } from "./constants.ts";
+import {
+  DEFAULT_AGENT_NAME,
+  DEFAULT_TOOLS,
+  VALID_THINKING,
+} from "./constants.ts";
 import { resolveToolGroups } from "./tools.ts";
 import type { AgentConfig } from "./types.ts";
 
@@ -71,11 +75,15 @@ export function parseFrontmatter(
 
   // A bare `*` is a YAML alias indicator and is invalid as a scalar, so
   // `tools: *` (the full-agent shorthand) would throw. Quote any value that is
-  // exactly `*` so it parses as the string "*", which resolveFrontmatterTools
-  // then expands via TOOL_GROUPS. (A `*` mid-scalar, e.g. `use * here`, is a
-  // legal plain scalar and needs no quoting.)
+  // exactly `*`, including when it has a trailing YAML comment, so it parses
+  // as the string "*", which resolveFrontmatterTools then expands via
+  // TOOL_GROUPS. (A `*` mid-scalar, e.g. `use * here`, is a legal plain scalar
+  // and needs no quoting.)
   const sanitized = sanitizeYamlScalars(
-    yamlString.replace(/^(\s*[\w-]+):\s*\*(?=\s*$)/gm, '$1: "*"'),
+    yamlString.replace(
+      /^([ \t]*[\w-]+:[ \t]*)\*([ \t]*(?:#[^\r\n]*)?)(?=\r?$)/gm,
+      '$1"*"$2',
+    ),
   );
 
   try {
@@ -136,11 +144,13 @@ const CLAUDE_TOOL_ALIASES: Record<string, string> = {
 
 /** Parse a `tools:` frontmatter value into a resolved tool list.
  *  Omitted or blank → inherit the full agent set (`*`), matching CC/OpenCode/
- *  Devin convention. This is the only caller-owned knob — both inline tasks
- *  and named agents now inherit-all when `tools:` is absent. */
+ *  Devin convention. For Claude imports (`aliasMap` set), an explicit
+ *  allowlist that maps to an empty set means the agent gets no tools, with a
+ *  warning, instead of silently inheriting anything. */
 function resolveFrontmatterTools(
   raw: string | undefined,
   aliasMap?: Record<string, string>,
+  filePath?: string,
 ): string[] {
   if (!raw) return DEFAULT_TOOLS; // omitted/blank → inherit *
   const names = raw
@@ -150,11 +160,25 @@ function resolveFrontmatterTools(
   if (!names.length) return DEFAULT_TOOLS;
   const mapped = aliasMap
     ? names
-        .map((n) => aliasMap[n.toLowerCase()] ?? null)
+        .map((n) => {
+          const lower = n.toLowerCase();
+          // Preserve delegate tool-group shorthands when importing Claude files.
+          if (lower === "*" || lower === "ro") return lower;
+          return aliasMap[lower] ?? null;
+        })
         .filter((n): n is string => n !== null)
     : names;
-  // Empty after aliasing (e.g. a Claude agent listing only WebSearch) → inherit.
-  return mapped.length ? resolveToolGroups(mapped) : DEFAULT_TOOLS;
+  // Empty after aliasing (e.g. a Claude agent listing only WebSearch) must not
+  // silently inherit the full mutating set. An explicit allowlist that maps to
+  // nothing means the agent gets no tools.
+  if (!mapped.length) {
+    const where = filePath ? ` (${filePath})` : "";
+    console.warn(
+      `[delegate] Claude agent allowlist contained no mappable tools${where}; agent will have no tools.`,
+    );
+    return [];
+  }
+  return resolveToolGroups(mapped);
 }
 
 /** Parse and alias a comma-separated Claude tool list into delegate tool names,
@@ -197,15 +221,19 @@ export function loadAgentFile(filePath: string): AgentConfig | null {
   };
 }
 
-/** Variant for `.claude/agents/*.md` files. Two Claude-specific adaptations:
+/** Variant for `.claude/agents/*.md` files. Claude-specific adaptations:
  *  - Maps capitalized tool names (Read/Glob/…) to delegate tools, dropping
  *    unmappable ones (WebSearch, TodoWrite, …). Omitted `tools` inherits `*`.
  *  - Honors `disallowedTools` as a denylist layered on top of the resolved
  *    set (Claude semantics: denylist applies whether or not an allowlist is
  *    set). Since delegate has no runtime denylist, we bake it into `tools` at
- *    import time. A reviewer with `disallowedTools: Write, Edit` and no
- *    `tools` becomes `read, bash, grep, find, ls` — it does NOT silently
- *    inherit full tools.
+ *    import time. `bash` is special: in the delegate tool set it subsumes
+ *    `grep`/`find`/`ls` (a shell can run all of them), so an imported `Bash`
+ *    resolves to `bash` alone. If the denylist then removes `Bash` from an
+ *    inherited (omitted) allowlist, the dedicated read-only search tools it
+ *    was subsuming are restored. If the user explicitly allowlisted `Bash`,
+ *    removing it gives them no extra tools — they never asked for `grep`,
+ *    `find`, or `ls`.
  *  - `model: inherit` (Claude's default) is mapped to "omit" so the agent
  *    inherits the parent model; passing it through verbatim would crash
  *    resolveModel() with "model 'inherit' is not available". */
@@ -219,11 +247,32 @@ export function loadClaudeAgentFile(filePath: string): AgentConfig | null {
   const { data, body } = parseFrontmatter(content, filePath);
   if (!data.name || !data.description) return null;
 
-  let tools = resolveFrontmatterTools(data.tools, CLAUDE_TOOL_ALIASES);
+  // Track whether the user wrote an explicit `tools:` allowlist. Omitted or
+  // blank means "inherit the full default set" (`*`), and only in that case
+  // does denying `bash` restore the search tools it was subsuming.
+  const explicitTools = data.tools != null && data.tools.trim() !== "";
+  let tools = resolveFrontmatterTools(
+    data.tools,
+    CLAUDE_TOOL_ALIASES,
+    filePath,
+  );
   // disallowedTools is a denylist applied after the allowlist resolves.
-  // Empty-after-mapping denylist (e.g. only unmappable names) → no-op.
+  // `bash` subsumes `grep`/`find`/`ls`: if the denylist removes `bash` from an
+  // inherited (omitted) allowlist, restore the dedicated read-only search
+  // tools it was covering, but only the ones not already present and not also
+  // explicitly denied. If `bash` came from an explicit allowlist, do not add
+  // search tools the user never requested.
   const denied = new Set(mapClaudeToolNames(data.disallowedTools));
-  if (denied.size) tools = tools.filter((t) => !denied.has(t));
+  if (denied.size) {
+    const hadBash = tools.includes("bash");
+    tools = tools.filter((t) => !denied.has(t));
+    if (hadBash && !tools.includes("bash") && !explicitTools) {
+      const restored = ["grep", "find", "ls"].filter(
+        (t) => !tools.includes(t) && !denied.has(t),
+      );
+      if (restored.length) tools = tools.concat(restored);
+    }
+  }
 
   return {
     name: data.name,
@@ -294,7 +343,14 @@ export function discoverAgents(cwd: string): Map<string, AgentConfig> {
     }
     for (const e of entries) {
       if (!e.name.endsWith(".md") || e.name.endsWith(".chain.md")) continue;
-      const cfg = loader(path.join(dir, e.name));
+      const filePath = path.join(dir, e.name);
+      const cfg = loader(filePath);
+      if (cfg?.name === DEFAULT_AGENT_NAME) {
+        console.warn(
+          `[delegate] ignoring agent profile '${DEFAULT_AGENT_NAME}' from ${filePath}: the name is reserved for the built-in parent-mirroring profile.`,
+        );
+        continue;
+      }
       if (cfg && !agents.has(cfg.name)) {
         cfg.scope = scope;
         agents.set(cfg.name, cfg);
@@ -313,6 +369,95 @@ export function discoverAgents(cwd: string): Map<string, AgentConfig> {
 export const DEFAULT_SUBAGENT_SYSTEM_PROMPT =
   "You are a helpful coding assistant.";
 
+/** First line of Pi's default generated system prompt. Used to detect an
+ *  inherited fully-assembled parent prompt that contains a stale tool
+ *  inventory. */
+const PI_DEFAULT_PROMPT_PREFIX =
+  "You are an expert coding assistant operating inside pi, a coding agent harness.";
+
+const PI_DEFAULT_PROMPT_INTRO = `${PI_DEFAULT_PROMPT_PREFIX} You help users by reading files, executing commands, editing code, and writing new files.`;
+
+function buildCapabilityProse(tools: string[]): string {
+  const set = new Set(tools);
+  const parts: string[] = [];
+  if (set.has("read")) parts.push("reading files");
+  if (set.has("grep") || set.has("find")) parts.push("searching code");
+  if (set.has("ls")) parts.push("listing directories");
+  if (set.has("bash")) parts.push("executing commands");
+  if (set.has("edit")) parts.push("editing code");
+  if (set.has("write")) parts.push("writing new files");
+  if (parts.length === 0) return "following the provided instructions";
+  if (parts.length === 1) return parts[0]!;
+  if (parts.length === 2) return `${parts[0]} and ${parts[1]}`;
+  return `${parts.slice(0, -1).join(", ")}, and ${parts[parts.length - 1]!}`;
+}
+
+function buildIntro(tools: string[]): string {
+  return `${PI_DEFAULT_PROMPT_PREFIX} You help users by ${buildCapabilityProse(tools)}.`;
+}
+
+const PI_DEFAULT_AVAILABLE_TOOLS_MARKER = "\n\nAvailable tools:\n";
+const PI_DEFAULT_PI_DOCS_MARKER = "\n\nPi documentation";
+const PI_DEFAULT_CWD_PREFIX = "\nCurrent working directory: ";
+
+/**
+ * Strip the default tool inventory, guidelines, and parent working directory
+ * line from an inherited parent prompt before it becomes a child's custom
+ * system prompt.
+ *
+ * Pi's `buildSystemPrompt()` synthesizes an "Available tools" list, tool
+ * guidelines, and a "Current working directory" line when no custom `SYSTEM.md`
+ * is in use. That assembled prompt is what the parent's `getSystemPrompt()`
+ * returns. If we pass it through as the child's custom prompt, the child keeps
+ * the parent's tool advertisement (and cwd) even when its actual tool set is
+ * restricted (e.g. `tools: ["ro"]`) and it is running in a different
+ * directory. AgentSession will append the correct child cwd when it rebuilds
+ * the system prompt, so the inherited parent cwd line is removed here.
+ *
+ * The function detects the default prompt by its stable intro, then removes
+ * only the "Available tools" + "Guidelines" region and the trailing
+ * "Current working directory" line, preserving the rest of the parent base
+ * (and any append/project context/skills that the resource loader added).
+ *
+ * Custom parent `SYSTEM.md` prompts are left untouched: they do not start with
+ * the default intro, so no heuristic stripping occurs.
+ */
+function sanitizeParentToolInventory(
+  prompt: string | undefined,
+  tools: string[] = DEFAULT_TOOLS,
+): string | undefined {
+  if (!prompt) return prompt;
+
+  // Only act on Pi's default generated prompt. Custom prompts may mention tools
+  // intentionally and should not be rewritten by a heuristic.
+  const trimmed = prompt.trimStart();
+  if (!trimmed.startsWith(PI_DEFAULT_PROMPT_INTRO)) return prompt;
+
+  const availableStart = prompt.indexOf(PI_DEFAULT_AVAILABLE_TOOLS_MARKER);
+  if (availableStart < 0) return prompt;
+
+  const piDocsStart = prompt.indexOf(
+    PI_DEFAULT_PI_DOCS_MARKER,
+    availableStart + PI_DEFAULT_AVAILABLE_TOOLS_MARKER.length,
+  );
+  if (piDocsStart < 0) return prompt;
+
+  const intro = buildIntro(tools);
+  const prefix = prompt
+    .slice(0, availableStart)
+    .replace(PI_DEFAULT_PROMPT_INTRO, intro);
+  let base = prefix + prompt.slice(piDocsStart);
+
+  // Remove the inherited parent cwd line; AgentSession adds the correct child
+  // cwd when it assembles the final system prompt.
+  const cwdIndex = base.lastIndexOf(PI_DEFAULT_CWD_PREFIX);
+  if (cwdIndex >= 0) {
+    return base.slice(0, cwdIndex).replace(/\n+$/, "");
+  }
+
+  return base;
+}
+
 function firstNonBlank(
   ...values: Array<string | undefined>
 ): string | undefined {
@@ -327,6 +472,7 @@ export function buildSubagentSystemPrompt(options: {
   agentSystemPrompt?: string;
   parentSystemPrompt?: string;
   pooledSystemPrompt?: string;
+  tools?: string[];
 }): string {
   // Pooled agents already have a frozen prompt baked into their session state.
   // Return it unchanged so repeated sessionId calls do not re-resolve.
@@ -336,11 +482,22 @@ export function buildSubagentSystemPrompt(options: {
   // from this custom prompt + its own resource-loader discovery (skills,
   // AGENTS.md, active-tool snippets). We previously appended skills/AGENTS.md
   // here; that duplicated AgentSession's work.
+  // An inherited parent prompt may be Pi's fully-assembled default prompt,
+  // which carries the parent's "Available tools" list and tool guidelines. A
+  // restricted child (e.g. `tools: ["ro"]`) must not advertise the parent's
+  // mutating tools as callable. Sanitize the parent prompt only; task and agent
+  // prompts are intentionally authored and are left untouched.
+  const resolvedTools = resolveToolGroups(options.tools ?? DEFAULT_TOOLS);
+  const parentSystemPrompt = sanitizeParentToolInventory(
+    options.parentSystemPrompt,
+    resolvedTools,
+  );
+
   const base =
     firstNonBlank(
       options.taskSystemPrompt,
       options.agentSystemPrompt,
-      options.parentSystemPrompt,
+      parentSystemPrompt,
     ) ?? DEFAULT_SUBAGENT_SYSTEM_PROMPT;
 
   return base;

package/concurrency.ts

@@ -10,21 +10,75 @@ import { getMaxConcurrent } from "./config.ts";
 
 let globalConcurrencyLimit = Math.max(1, getMaxConcurrent());
 let globalConcurrencyRunning = 0;
-const globalConcurrencyWaiters: Array<() => void> = [];
 
-function acquireGlobal(): Promise<void> {
+interface GlobalWaiter {
+  /** Resolve with `true` when a slot was acquired, `false` when the signal
+   *  aborted while queued (the caller must not release a slot it never held). */
+  resolve: (acquired: boolean) => void;
+  signal?: AbortSignal;
+  onAbort: () => void;
+}
+
+const globalConcurrencyWaiters: GlobalWaiter[] = [];
+
+/**
+ * Acquire a global concurrency slot.
+ *
+ * Resolves `true` when a slot is held (caller must pair with `releaseGlobal`),
+ * or `false` when `signal` aborted before a slot could be acquired. Waiters are
+ * abort-aware: an abort removes the queued waiter immediately and resolves
+ * `false`, so a cancelled ticket is not stranded in "cancelling" until some
+ * unrelated task happens to release capacity. The caller still invokes its fn
+ * on `false` — the production fn (runResolvedTask) observes the aborted signal
+ * at entry and returns an "Aborted" TaskResult without consuming a slot.
+ */
+function acquireGlobal(signal?: AbortSignal): Promise<boolean> {
+  // Already aborted: never queue (a slot would be wasted on a task that can
+  // only report Aborted) and never increment — nothing to release later.
+  if (signal?.aborted) return Promise.resolve(false);
   if (globalConcurrencyRunning < globalConcurrencyLimit) {
     globalConcurrencyRunning++;
-    return Promise.resolve();
+    return Promise.resolve(true);
   }
-  return new Promise<void>((r) => globalConcurrencyWaiters.push(r));
+  return new Promise<boolean>((resolve) => {
+    const waiter: GlobalWaiter = {
+      resolve,
+      signal,
+      onAbort: () => {
+        // Remove ourselves from the queue without taking a slot. The caller's
+        // fn sees the aborted signal at entry and settles promptly.
+        const index = globalConcurrencyWaiters.indexOf(waiter);
+        if (index === -1) return; // already woken by releaseGlobal
+        globalConcurrencyWaiters.splice(index, 1);
+        waiter.signal?.removeEventListener("abort", waiter.onAbort);
+        resolve(false);
+      },
+    };
+    if (signal) {
+      signal.addEventListener("abort", waiter.onAbort, { once: true });
+    }
+    globalConcurrencyWaiters.push(waiter);
+  });
 }
 
 function releaseGlobal(): void {
   globalConcurrencyRunning--;
+  // Never hand a slot to a waiter whose signal already aborted. The abort
+  // listener normally removes it synchronously during abort() dispatch; this
+  // drain is defensive for any ordering edge.
+  while (
+    globalConcurrencyWaiters.length > 0 &&
+    globalConcurrencyWaiters[0]!.signal?.aborted
+  ) {
+    const w = globalConcurrencyWaiters.shift()!;
+    w.signal?.removeEventListener("abort", w.onAbort);
+    w.resolve(false);
+  }
   if (globalConcurrencyWaiters.length > 0) {
     globalConcurrencyRunning++;
-    globalConcurrencyWaiters.shift()!();
+    const w = globalConcurrencyWaiters.shift()!;
+    w.signal?.removeEventListener("abort", w.onAbort);
+    w.resolve(true);
   }
 }
 
@@ -109,9 +163,18 @@ export async function mapConcurrentByModel<T, R>(
         groupItems,
         group.limit,
         async (_item, localIdx) => {
-          await acquireGlobal();
+          const globalIdx = group.indices[localIdx]!;
+          const acquired = await acquireGlobal(signal);
+          if (!acquired) {
+            // Aborted while queued for a global slot: we hold no slot, so we
+            // must NOT release one. Still invoke fn — runResolvedTask observes
+            // the aborted signal at entry and returns an "Aborted" TaskResult,
+            // keeping the results array dense for the sync dereference path
+            // (the same contract as mapConcurrent's worker loop).
+            results[globalIdx] = await fn(_item, globalIdx);
+            return results[globalIdx];
+          }
           try {
-            const globalIdx = group.indices[localIdx]!;
             results[globalIdx] = await fn(_item, globalIdx);
             return results[globalIdx];
           } finally {

package/constants.ts

@@ -1,3 +1,6 @@
+/** Reserved built-in profile that mirrors the live parent configuration. */
+export const DEFAULT_AGENT_NAME = "default";
+
 /** Full-capability agent set. Inline-task default and the `*` shorthand.
  *  Bash subsumes search, so the dedicated grep/find/ls tools are excluded. */
 export const DEFAULT_TOOLS = ["read", "write", "edit", "bash"];

package/delegate.ts

@@ -3,6 +3,7 @@ export { default } from "./extension.ts";
 export type {
   AgentConfig,
   SessionAction,
+  TicketAction,
   DelegateAction,
   DelegateArguments,
   TaskDef,
@@ -14,12 +15,14 @@ export type {
   TaskResult,
   TaskFailureKind,
   ReuseIntent,
+  ParentAgentDefaults,
   AgentRunConfig,
   TaskRunEnv,
 } from "./types.ts";
 export type { DelegateConfig } from "./config.ts";
 
 export {
+  DEFAULT_AGENT_NAME,
   DEFAULT_TOOLS,
   READONLY_TOOLS,
   MAX_CONCURRENCY,
@@ -56,6 +59,7 @@ export {
   ticketRegistry,
   sweepTickets,
   cancelTicketForShutdown,
+  requestTicketCancel,
   isSessionBusy,
   handlePoll,
   handleCancel,
@@ -65,8 +69,27 @@ export {
   resolveFinalTicketStatus,
   formatCompletedTicket,
 } from "./tickets.ts";
+export type { TicketDelivery } from "./tickets.ts";
+export {
+  recordTreeNavigation,
+  getCurrentLeafId,
+  resetLeafTracking,
+  isCrossLeafTicket,
+} from "./leaf.ts";
 export { runAgentSession } from "./runner.ts";
-export { getHostDeps } from "./host.ts";
+export {
+  activeTicketSummary,
+  buildStatusText,
+  clearDelegateStatusContext,
+  describeActiveTickets,
+  syncDelegateStatus,
+  notifyActiveTicketsOnSettled,
+  guardSessionReplacement,
+  guardTreeNavigation,
+  notifyCrossLeafDelivery,
+} from "./status.ts";
+export type { ActiveTicketSummary } from "./status.ts";
+export { getHostDeps, invalidateHostDepsCache } from "./host.ts";
 export type { HostDeps, HostDepsOptions } from "./host.ts";
 export {
   emptyUsage,
@@ -87,6 +110,8 @@ export {
   indent,
   formatFailedTask,
   formatCompletedTask,
+  findTouchedOverlaps,
+  formatTouchedOverlapWarning,
 } from "./format.ts";
 export {
   parseFrontmatter,