@bermudi/pi-delegate 0.1.1 → 0.1.3

package/README.md

@@ -126,8 +126,9 @@ 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 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.

package/agents.ts

@@ -75,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 {
@@ -140,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
@@ -154,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,
@@ -201,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". */
@@ -223,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,
@@ -324,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 {
@@ -338,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.
@@ -347,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);
   }
 }
 
@@ -61,7 +115,17 @@ async function mapConcurrent<T, R>(
       results[i] = await fn(items[i]!, i);
     }
   };
-  await Promise.all(Array.from({ length: limit }, () => worker()));
+  // Promise.all would reject as soon as one task throws while sibling workers
+  // are still unwinding. Wait for every worker first so callers can safely use
+  // this promise as the batch-settled barrier (notably shutdown telemetry).
+  const outcomes = await Promise.allSettled(
+    Array.from({ length: limit }, () => worker()),
+  );
+  const rejection = outcomes.find(
+    (outcome): outcome is PromiseRejectedResult =>
+      outcome.status === "rejected",
+  );
+  if (rejection) throw rejection.reason;
   return results;
 }
 
@@ -101,17 +165,28 @@ export async function mapConcurrentByModel<T, R>(
     group.indices.push(i);
   }
 
-  // Run all groups in parallel, each with its own concurrency limit + global cap
-  await Promise.all(
+  // Run all groups in parallel, each with its own concurrency limit + global cap.
+  // As above, wait for every group before surfacing an unexpected rejection so
+  // a late sibling cannot mutate a ticket after its completion barrier resolves.
+  const outcomes = await Promise.allSettled(
     [...groups.entries()].map(([, group]) => {
       const groupItems = group.indices.map((i) => items[i]!);
       return mapConcurrent(
         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 {
@@ -122,5 +197,10 @@ export async function mapConcurrentByModel<T, R>(
       );
     }),
   );
+  const rejection = outcomes.find(
+    (outcome): outcome is PromiseRejectedResult =>
+      outcome.status === "rejected",
+  );
+  if (rejection) throw rejection.reason;
   return results;
 }

package/config.ts

@@ -8,6 +8,52 @@ import {
   OUTPUT_SPILL_THRESHOLD_CHARS,
 } from "./constants.ts";
 
+export interface TelemetryConfig {
+  /** Whether to record delegate calls to the local SQLite store. Default true. */
+  enabled?: boolean;
+  /** Path to the SQLite database. Defaults to `~/.pi/agent/delegate-usage.db`. */
+  dbPath?: string;
+}
+
+const DEFAULT_TELEMETRY_CONFIG: TelemetryConfig = {
+  enabled: true,
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Validate the user-editable telemetry block at its boundary. An explicitly
+ * malformed block disables telemetry rather than silently turning it on with
+ * the default database path. Missing telemetry is different: it means the
+ * user did not configure the feature, so the default remains enabled.
+ */
+export function normalizeTelemetryConfig(raw: unknown): TelemetryConfig {
+  if (raw === undefined) return { ...DEFAULT_TELEMETRY_CONFIG };
+  if (!isRecord(raw)) return { enabled: false };
+
+  const hasEnabled = Object.prototype.hasOwnProperty.call(raw, "enabled");
+  const hasDbPath = Object.prototype.hasOwnProperty.call(raw, "dbPath");
+  const enabled = raw.enabled;
+  const dbPath = raw.dbPath;
+
+  if (hasEnabled && typeof enabled !== "boolean") {
+    return { enabled: false };
+  }
+  if (hasDbPath && (typeof dbPath !== "string" || dbPath.trim().length === 0)) {
+    return { enabled: false };
+  }
+
+  const normalizedEnabled =
+    typeof enabled === "boolean" ? enabled : DEFAULT_TELEMETRY_CONFIG.enabled;
+  const normalizedDbPath = typeof dbPath === "string" ? dbPath : undefined;
+  return {
+    enabled: normalizedEnabled,
+    ...(normalizedDbPath === undefined ? {} : { dbPath: normalizedDbPath }),
+  };
+}
+
 export interface DelegateConfig {
   agent: {
     /** Global default model for all agent types. */
@@ -41,6 +87,8 @@ export interface DelegateConfig {
   providerExtensions?: {
     [provider: string]: readonly string[];
   };
+  /** Local SQLite telemetry for usage/health analytics. See `telemetry.ts`. */
+  telemetry?: TelemetryConfig;
   /** LLM-facing output bounding: over-threshold final output is spilled to a
    *  temp file with a tail kept in-context. See `spill.ts`. */
   output?: {
@@ -108,6 +156,9 @@ const DEFAULT_DELEGATE_CONFIG: DelegateConfig = {
     wholeTaskBaseDelayMs: 1_000,
   },
   providerExtensions: DEFAULT_PROVIDER_EXTENSIONS,
+  telemetry: {
+    enabled: true,
+  },
   output: {
     spillThresholdChars: OUTPUT_SPILL_THRESHOLD_CHARS,
     spillTailChars: OUTPUT_SPILL_TAIL_CHARS,
@@ -119,6 +170,7 @@ let __delegateConfig: DelegateConfig = {
   ...DEFAULT_DELEGATE_CONFIG,
   agent: { ...DEFAULT_DELEGATE_CONFIG.agent },
   concurrency: { ...DEFAULT_DELEGATE_CONFIG.concurrency },
+  telemetry: { ...DEFAULT_DELEGATE_CONFIG.telemetry },
 };
 let stallTimeoutOverrideForTesting: number | undefined;
 
@@ -140,6 +192,7 @@ export function loadDelegateConfig(): DelegateConfig {
       },
       retry: { ...DEFAULT_DELEGATE_CONFIG.retry, ...(parsed.retry ?? {}) },
       providerExtensions: resolveProviderExtensions(parsed.providerExtensions),
+      telemetry: normalizeTelemetryConfig(parsed.telemetry),
       output: { ...DEFAULT_DELEGATE_CONFIG.output, ...(parsed.output ?? {}) },
     } as DelegateConfig;
   } catch {
@@ -203,6 +256,7 @@ export function _setDelegateConfigForTesting(
       ...(config.retry ?? {}),
     },
     providerExtensions: resolveProviderExtensions(config.providerExtensions),
+    telemetry: normalizeTelemetryConfig(config.telemetry),
     output: {
       ...DEFAULT_DELEGATE_CONFIG.output,
       ...(config.output ?? {}),
@@ -356,3 +410,10 @@ export function resolveModelSpec(options: {
     (v): v is string => typeof v === "string" && v.length > 0,
   );
 }
+
+/** Get the configured telemetry settings. */
+export function getTelemetryConfig(
+  config: DelegateConfig = __delegateConfig,
+): TelemetryConfig {
+  return normalizeTelemetryConfig(config.telemetry);
+}

package/delegate.ts

@@ -3,6 +3,7 @@ export { default } from "./extension.ts";
 export type {
   AgentConfig,
   SessionAction,
+  TicketAction,
   DelegateAction,
   DelegateArguments,
   TaskDef,
@@ -58,6 +59,7 @@ export {
   ticketRegistry,
   sweepTickets,
   cancelTicketForShutdown,
+  requestTicketCancel,
   isSessionBusy,
   handlePoll,
   handleCancel,
@@ -67,6 +69,13 @@ 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 {
   activeTicketSummary,
@@ -76,11 +85,14 @@ export {
   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 {
+  aggregateTaskResults,
   emptyUsage,
   snapshotSessionUsage,
   usageDelta,
@@ -99,6 +111,8 @@ export {
   indent,
   formatFailedTask,
   formatCompletedTask,
+  findTouchedOverlaps,
+  formatTouchedOverlapWarning,
 } from "./format.ts";
 export {
   parseFrontmatter,