@bermudi/pi-delegate 0.1.18 → 0.1.20

package/render-branches.ts

@@ -54,6 +54,7 @@ export interface RenderState {
 
 /** Shared inputs for the partial and final render branches. */
 export interface BranchCtx {
+  pauseState?: import("./pause.ts").PauseState;
   progress: TaskProgress[];
   taskResults: (TaskResult | { error: string })[];
   total: number;
@@ -98,7 +99,11 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
   // Keep the live and final summaries in the same order so the header remains
   // easy to scan as a partial result resolves into its final form.
   const headerParts: string[] = [];
-  if (running > 0) headerParts.push(`${running} running`);
+  const paused = progress.filter(
+    (p) => p.status === "running" && p.paused,
+  ).length;
+  if (running > paused) headerParts.push(`${running - paused} running`);
+  if (paused > 0) headerParts.push(`${paused} paused`);
   headerParts.push(`${finished}/${total} finished`);
   if (failed > 0) headerParts.push(`${failed} failed`);
   headerParts.push(
@@ -111,7 +116,9 @@ export function renderPartialBranch(ctx: BranchCtx, h: RenderHelpers): void {
   const stateLabel =
     ctx.ticketStatus === "cancelling"
       ? `${theme.fg("error", "■ cancelling")} · `
-      : "";
+      : ctx.pauseState && ctx.pauseState !== "running"
+        ? `${theme.fg("warning", `Ⅱ ${ctx.pauseState}`)} · `
+        : "";
   const expandHint = toolExpandHint();
   const detailHint =
     !expanded && running > 0 && expandHint
@@ -362,7 +369,11 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
   if (ticketId && ticketIsLive) {
     // Background ticket — frame it as in-progress, not a finished result.
     const ticketParts = [`${finalized}/${total} finished`];
-    if (running > 0) ticketParts.push(`${running} active`);
+    const paused = progress.filter(
+      (p) => p.status === "running" && p.paused,
+    ).length;
+    if (running > paused) ticketParts.push(`${running - paused} active`);
+    if (paused > 0) ticketParts.push(`${paused} paused`);
     if (pending > 0) ticketParts.push(`${pending} queued`);
     if (failed > 0) ticketParts.push(`${failed} failed`);
     if (cancelled > 0) ticketParts.push(`${cancelled} cancelled`);
@@ -373,7 +384,9 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
     const stateLabel =
       ticketStatus === "cancelling"
         ? ` ${theme.fg("error", "cancelling")}`
-        : "";
+        : ctx.pauseState && ctx.pauseState !== "running"
+          ? ` ${theme.fg("warning", ctx.pauseState)}`
+          : "";
     lines.push(
       `${glyph}${stateLabel} ${theme.fg("muted", `${ticketLabel}${ticketParts.join(" · ")}`)}${detailHint}`,
       "",
@@ -523,7 +536,8 @@ export function renderFinalBranch(ctx: BranchCtx, h: RenderHelpers): void {
       const integration = r.integration;
       const tone =
         integration.status === "applied_unverified" ||
-        integration.status === "no_changes"
+        integration.status === "no_changes" ||
+        integration.status === "retained"
           ? "warning"
           : "error";
       lines.push(

package/render-result.ts

@@ -202,6 +202,7 @@ export function renderDelegateResult(
     lines,
     ticketId,
     ticketStatus,
+    pauseState: details.pauseState,
     elapsedMs: details.elapsedMs,
   };
 
@@ -213,6 +214,12 @@ export function renderDelegateResult(
       lines.push(truncLine(theme.fg("warning", `⚠ ${warning}`), w), "");
     }
   }
+  if (details?.serializedNotice) {
+    const notice = sanitizeTerminalLine(details.serializedNotice);
+    if (notice) {
+      lines.push(truncLine(theme.fg("dim", `⏳ ${notice}`), w), "");
+    }
+  }
   if (details?.overlapWarning) {
     const warning = sanitizeTerminalLine(details.overlapWarning);
     if (warning) {

package/runner.ts

@@ -3,6 +3,7 @@ import type {
   AgentSession,
   AgentSessionEvent,
 } from "@earendil-works/pi-coding-agent";
+import { AssistantPreview } from "./assistant-preview.ts";
 import {
   getGitChangedFiles,
   extractAttributedFromActivities,
@@ -127,6 +128,10 @@ export async function runAgentSession(
   deadlineAt?: number,
   /** Dispatch-scoped delegate.json snapshot for the stall timeout. */
   delegateConfig?: import("./config.ts").DelegateConfig,
+  pause?: {
+    controller: import("./pause.ts").PauseController;
+    index: number;
+  },
 ): Promise<{
   output: string;
   error?: string;
@@ -176,6 +181,8 @@ export async function runAgentSession(
   let recoveryBarrier: QuiescenceBarrier | undefined;
   let abandonmentSafety: Promise<void> | undefined;
   let unsubscribeFull: (() => void) | undefined;
+  let unsubscribePause: (() => void) | undefined;
+  let pausedAtTurnBoundary = false;
   let unsubscribeRecovery: (() => void) | undefined;
   const safeLog = (message: string, error?: unknown): void => {
     try {
@@ -187,11 +194,18 @@ export async function runAgentSession(
   const removeFullListener = (): void => {
     const remove = unsubscribeFull;
     unsubscribeFull = undefined;
+    const removePause = unsubscribePause;
+    unsubscribePause = undefined;
     try {
       remove?.();
     } catch (error) {
       safeLog("[delegate] full AgentSession listener cleanup failed", error);
     }
+    try {
+      removePause?.();
+    } catch (error) {
+      safeLog("[delegate] turn-pause listener cleanup failed", error);
+    }
   };
   const removeRecoveryListener = (): void => {
     const remove = unsubscribeRecovery;
@@ -206,6 +220,7 @@ export async function runAgentSession(
     }
   };
   const activities: ToolActivity[] = [];
+  const assistantPreview = new AssistantPreview();
   const pendingById = new Map<string, ToolActivity>();
   let notifyCancellationRequested!: () => void;
   const cancellationRequested = new Promise<void>((resolve) => {
@@ -377,6 +392,8 @@ export async function runAgentSession(
     try {
       const cancellationSource = currentCancellationSource();
       onProgress({
+        assistantPreview: assistantPreview.text,
+        activity: phase,
         tokens: delta,
         toolUses,
         durationMs: Date.now() - startTime,
@@ -415,7 +432,13 @@ export async function runAgentSession(
   };
   const armStallWatchdog = (graceMs = 0) => {
     clearStallWatchdog();
-    if (!stallTimeoutMs || stalled || signal?.aborted || deadlineExceeded)
+    if (
+      !stallTimeoutMs ||
+      stalled ||
+      signal?.aborted ||
+      deadlineExceeded ||
+      pausedAtTurnBoundary
+    )
       return;
 
     const grace = Number.isFinite(graceMs) && graceMs > 0 ? graceMs : 0;
@@ -625,6 +648,35 @@ export async function runAgentSession(
   // result, isError) — AgentSession forwards the underlying agent events
   // verbatim. Retry and compaction events are handled below; queue/bookkeeping
   // events and thinking changes are intentionally ignored.
+  // AgentSession subscribers are notifications, not an awaited barrier.
+  // Pi core explicitly awaits Agent subscribers before proceeding from
+  // turn_start to the next model request, including retries/continuations.
+  // Never gate turn_end: a final turn should be allowed to finish the task.
+  if (pause) {
+    unsubscribePause = session.agent.subscribe(async (event, turnSignal) => {
+      if (event.type !== "turn_start" || pause.controller.state === "running")
+        return;
+      pausedAtTurnBoundary = true;
+      clearStallWatchdog();
+      try {
+        await pause.controller.checkpoint(
+          pause.index,
+          turnSignal && signal
+            ? AbortSignal.any([turnSignal, signal])
+            : (turnSignal ?? signal),
+        );
+        if (turnSignal?.aborted || signal?.aborted) {
+          throw new Error(
+            "Paused turn cancelled before the next model request",
+          );
+        }
+      } finally {
+        pausedAtTurnBoundary = false;
+        noteActivity("resuming at turn boundary");
+      }
+    });
+  }
+
   unsubscribeFull = session.subscribe((event: AgentSessionEvent) => {
     barrier.noteEvent();
     recoveryBarrier?.noteEvent();
@@ -678,12 +730,14 @@ export async function runAgentSession(
       case "message_start":
       case "message_update":
         if (event.message?.role === "assistant") {
+          assistantPreview.update(extractOutput([event.message]));
           rememberPartialAssistant(event.message);
         }
         noteActivity("streaming model output");
         break;
       case "message_end":
         if (event.message.role === "assistant") {
+          assistantPreview.finish(extractOutput([event.message]));
           assistantMessagesForAttempt.push(event.message);
           // Keep a text-bearing partial if the host follows a provider
           // exception with an empty synthetic failure message. A real

package/runtime.ts

@@ -0,0 +1,36 @@
+import { SessionPool, defaultSessionPool } from "./pool.ts";
+import { TicketRegistry, ticketRegistry } from "./tickets.ts";
+
+/**
+ * Injectable runtime context for one delegate extension lifetime.
+ *
+ * A runtime bundles a {@link SessionPool} and a {@link TicketRegistry} so
+ * tests and nested callers can create fully isolated dispatch/lifecycle
+ * environments without touching the module-level default pool or ticket
+ * registry. Production Pi uses the single default runtime returned by
+ * {@link getDefaultDelegateRuntime}; the public barrel still exposes the
+ * familiar checkout/commit/ticket wrapper functions for compatibility.
+ */
+export interface DelegateRuntime {
+  pool: SessionPool;
+  tickets: TicketRegistry;
+}
+
+/** Create a fresh, isolated runtime with its own pool and ticket registry. */
+export function createDelegateRuntime(): DelegateRuntime {
+  return {
+    pool: new SessionPool(),
+    tickets: new TicketRegistry(),
+  };
+}
+
+const defaultRuntime: DelegateRuntime = {
+  pool: defaultSessionPool,
+  tickets: ticketRegistry,
+};
+
+/** The runtime used by the one-argument Pi extension entry point and the
+ *  default-runtime compatibility wrappers exported from the barrel. */
+export function getDefaultDelegateRuntime(): DelegateRuntime {
+  return defaultRuntime;
+}

package/schema.ts

@@ -42,7 +42,7 @@ export const delegateTaskSchema = Type.Object({
   agent: Type.Optional(
     Type.String({
       description:
-        "default mirrors the parent's tools; scout/coder/reviewer specialists. Ad-hoc tasks get * tools even when the parent is narrower.",
+        "Use built-ins first: default=general; scout/coder/reviewer specialize. Omit only for inline; it gets * even if parent is narrower.",
     }),
   ),
   cwd: Type.Optional(
@@ -65,19 +65,20 @@ export const delegateTaskSchema = Type.Object({
   ),
   model: Type.Optional(
     Type.String({
-      description: "Model override; omit to inherit parent.",
+      description:
+        "Override only if requested or required; else keep its default.",
     }),
   ),
   tools: Type.Optional(
     Type.Array(Type.String(), {
       description:
-        "Names/presets: *=read/write/edit/bash (mutating); ro=read/grep/find/ls (read-only). Ad-hoc defaults to *.",
+        "Override only if requested or required. *=read/write/edit/bash; ro=read/grep/find/ls (read-only).",
     }),
   ),
   thinking: Type.Optional(
     StringEnum(VALID_THINKING_LEVELS, {
       description:
-        "off/minimal/low/medium/high/xhigh/max. Omit for agents — it overrides delegate.json tiers; default inherits.",
+        "off/minimal/low/medium/high/xhigh/max. Omit by default: overrides the agent's configured thinking budget.",
     }),
   ),
   sessionId: Type.Optional(
@@ -101,7 +102,7 @@ export const delegateTaskSchema = Type.Object({
   workspace: Type.Optional(
     StringEnum(["shared", "scratch", "isolated"], {
       description:
-        "shared edits source; scratch discards; isolated orders Git worktree proposals; none confine access.",
+        "shared/scratch/isolated. Override if requested or required. scratch discards; isolated reconciles Git; not a security boundary.",
     }),
   ),
 });
@@ -112,9 +113,9 @@ export const delegateTaskSchema = Type.Object({
 export const delegateArgumentsSchema = Type.Object(
   {
     ticketAction: Type.Optional(
-      StringEnum(["poll", "cancel", "wait"], {
+      StringEnum(["poll", "cancel", "wait", "pause", "resume"], {
         description:
-          "Ticket control: poll=snapshot; wait=block until settled; cancel=abort. Prefer wait; never cancel for time.",
+          "poll=snapshot; wait=await results; pause=stop between turns; resume=continue; cancel=abort. Prefer wait over polling.",
       }),
     ),
     sessionAction: Type.Optional(
@@ -159,7 +160,7 @@ export const delegateArgumentsSchema = Type.Object(
       Type.Array(delegateTaskSchema, {
         minItems: 0,
         description:
-          "Tasks run concurrently; shared workspaces share files. scratch uses a disposable CoW copy. []=full manual.",
+          "Use built-in defaults first. Tasks run concurrently; overlapping shared writers run in task order. []=manual.",
       }),
     ),
   },
@@ -212,7 +213,7 @@ export function validateDelegateOperation(
   const rawParams = params as Record<string, unknown>;
   if ("action" in rawParams) {
     return (
-      "unsupported field 'action'; use 'ticketAction' for poll/cancel/wait " +
+      "unsupported field 'action'; use 'ticketAction' for poll/cancel/wait/pause/resume " +
       "or 'sessionAction' for close/list."
     );
   }
@@ -286,9 +287,21 @@ function validateTicketMode(params: DelegateArguments): string | undefined {
     [...TASK_FIELD_NAMES, "tasks", "sessionAction"] as const
   ).filter((field) => rawParams[field] !== undefined);
   if (incompatibleFields.length) {
-    return `ticket control cannot be combined with field(s) ${incompatibleFields
+    const base = `ticket control cannot be combined with field(s) ${incompatibleFields
       .map((field) => `'${field}'`)
       .join(", ")}; call it separately.`;
+    // Kitchen-sink callers attach default-shaped ticket control to a real
+    // dispatch and then repeat the identical rejected call (observed in the
+    // wild: glm-5.3 sent `ticketAction:"wait"` + tasks + empty ticket six
+    // times in a row). With tasks present and no ticket id, address the
+    // likely intent — dispatch already blocks; async creates the tickets
+    // that ticketAction manages — instead of restating the field rule.
+    const wantsDispatch =
+      Array.isArray(params.tasks) && params.tasks.length > 0 && !params.ticket;
+    if (wantsDispatch) {
+      return `${base} Dispatched tasks run to completion before returning — omit ticketAction entirely; only async:true produces a ticket to wait on.`;
+    }
+    return base;
   }
   if (params.async === true) {
     return "ticket control cannot include async; call it separately.";
@@ -314,7 +327,7 @@ function validateDispatchOrHelpMode(
   const tasks = params.tasks ?? [];
 
   if (params.ticket !== undefined) {
-    return "ticket requires ticketAction 'poll', 'cancel', or 'wait'.";
+    return "ticket requires ticketAction 'poll', 'cancel', 'wait', 'pause', or 'resume'.";
   }
   if (params.force === true)
     return "force is valid only with ticketAction 'cancel'.";
@@ -327,10 +340,6 @@ function validateDispatchOrHelpMode(
       : undefined; // Intentional help request.
   }
 
-  if (params.async && tasks.some((task) => task.workspace === "isolated")) {
-    return 'workspace "isolated" is synchronous; remove async.';
-  }
-
   // Reject mixed shapes: flat task fields at the top level alongside a
   // nonempty tasks array. The normalize shim only wraps flat fields when
   // there is no tasks array, so a mixed call silently lets tasks win —
@@ -406,12 +415,14 @@ function normalizeToolsField(value: string): unknown {
 
 /** True when `record` carries a top-level ticket-control intent that makes a
  * flat task-field wrap illegitimate: an explicit `ticketAction`, or a bare
- * `ticket` id (which only makes sense with poll/cancel/wait). */
+ * `ticket` id (which only makes sense with ticket controls). */
 function hasTicketControlIntent(record: Record<string, unknown>): boolean {
   return (
     record.ticketAction === "poll" ||
     record.ticketAction === "cancel" ||
     record.ticketAction === "wait" ||
+    record.ticketAction === "pause" ||
+    record.ticketAction === "resume" ||
     record.ticket !== undefined
   );
 }
@@ -450,7 +461,7 @@ function wrapFlatTaskFields(record: Record<string, unknown>): void {
 }
 
 /** Per-entry recovery for one task: stringified (or bare-token) `tools` → a
- * real array, and `agent: ""` → omitted (ad-hoc). Other malformed input is
+ * real array, and `agent: ""` → omitted (inline). Other malformed input is
  * left for schema validation to reject loudly. */
 function normalizeTaskEntry(entry: unknown): unknown {
   if (!entry || typeof entry !== "object") return entry;
@@ -476,7 +487,7 @@ function normalizeTaskEntry(entry: unknown): unknown {
  *   unless ticket- or session-control intent makes the call legitimately
  *   taskless (see `hasTicketControlIntent` / `hasSessionControlIntent`);
  * - `tools` as a JSON string (or bare token) inside a task entry;
- * - `agent: ""` inside a task entry — treated as omitted (ad-hoc);
+ * - `agent: ""` inside a task entry — treated as omitted (inline);
  * All other invalid input is left for normal schema validation to reject
  * loudly.
  *

package/status.ts

@@ -26,7 +26,7 @@
  * there.
  */
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { requestTicketCancel, ticketRegistry } from "./tickets.ts";
+import { getDefaultDelegateRuntime, type DelegateRuntime } from "./runtime.ts";
 import type { AsyncTicket } from "./types.ts";
 
 const STATUS_KEY = "delegate";
@@ -39,10 +39,12 @@ export interface ActiveTicketSummary {
 }
 
 /** Snapshot the live background work from the ticket registry. */
-export function activeTicketSummary(): ActiveTicketSummary {
+export function activeTicketSummary(
+  runtime: DelegateRuntime = getDefaultDelegateRuntime(),
+): ActiveTicketSummary {
   const tickets: AsyncTicket[] = [];
   let activeSubagents = 0;
-  for (const ticket of ticketRegistry.values()) {
+  for (const ticket of runtime.tickets.values()) {
     if (ticket.status !== "running" && ticket.status !== "cancelling") continue;
     tickets.push(ticket);
     activeSubagents += ticket.progress.filter(
@@ -60,8 +62,22 @@ function plural(n: number, noun: string): string {
 export function buildStatusText(
   summary: ActiveTicketSummary,
 ): string | undefined {
+  const text = buildStatusSummary(summary);
+  return text === undefined ? undefined : `${text} · /subagents`;
+}
+
+function buildStatusSummary(summary: ActiveTicketSummary): string | undefined {
   const { tickets, activeSubagents } = summary;
   if (tickets.length === 0) return undefined;
+  const held = tickets.filter(
+    (ticket) =>
+      ticket.status === "running" &&
+      ticket.pause &&
+      ticket.pause.state !== "running",
+  );
+  if (held.length) {
+    return `Ⅱ ${held.map((ticket) => `${ticket.id} ${ticket.pause!.state}`).join(" · ")}${tickets.length > held.length ? ` · ${tickets.length - held.length} other ticket(s)` : ""}`;
+  }
   // Wind-down window: tasks have settled but the ticket has not flipped to a
   // terminal status yet. "settling" is more honest than "0 subagents".
   if (activeSubagents === 0) {
@@ -88,10 +104,13 @@ const settledWarnedTicketIds = new Set<string>();
  *  Called on every ticket lifecycle mutation (create, progress, complete,
  *  cancel); event-driven only — no timers, so the text never goes stale
  *  (counts are the only content). */
-export function syncDelegateStatus(ctx?: ExtensionContext): void {
+export function syncDelegateStatus(
+  ctx?: ExtensionContext,
+  runtime?: DelegateRuntime,
+): void {
   if (ctx) lastCtx = ctx;
 
-  const summary = activeTicketSummary();
+  const summary = activeTicketSummary(runtime);
   const text = buildStatusText(summary);
 
   if (settledWarnedTicketIds.size) {
@@ -127,9 +146,12 @@ export function clearDelegateStatusContext(): void {
 /** Warn once per ticket at the first agent_settled with that ticket active —
  *  the "looks idle but isn't" moment. The persistent footer status carries
  *  the information from then on, so later settles stay quiet. */
-export function notifyActiveTicketsOnSettled(ctx: ExtensionContext): void {
+export function notifyActiveTicketsOnSettled(
+  ctx: ExtensionContext,
+  runtime?: DelegateRuntime,
+): void {
   lastCtx = ctx;
-  const summary = activeTicketSummary();
+  const summary = activeTicketSummary(runtime);
   const fresh = summary.tickets.filter(
     (t) => !settledWarnedTicketIds.has(t.id),
   );
@@ -167,9 +189,10 @@ export function notifyActiveTicketsOnSettled(ctx: ExtensionContext): void {
 export async function guardSessionReplacement(
   ctx: ExtensionContext,
   action: "switch" | "fork",
+  runtime?: DelegateRuntime,
 ): Promise<{ cancel: true } | undefined> {
   lastCtx = ctx;
-  const summary = activeTicketSummary();
+  const summary = activeTicketSummary(runtime);
   if (!summary.tickets.length || !ctx.hasUI) return undefined;
 
   const ids = summary.tickets.map((t) => t.id).join(", ");
@@ -194,9 +217,11 @@ export async function guardSessionReplacement(
  *  extension) is still handled at delivery time via leaf affinity. */
 export async function guardTreeNavigation(
   ctx: ExtensionContext,
+  runtime?: DelegateRuntime,
 ): Promise<{ cancel: true } | undefined> {
   lastCtx = ctx;
-  const summary = activeTicketSummary();
+  const rt = runtime ?? getDefaultDelegateRuntime();
+  const summary = activeTicketSummary(rt);
   if (!summary.tickets.length || !ctx.hasUI) return undefined;
 
   const ids = summary.tickets.map((t) => t.id).join(", ");
@@ -220,8 +245,10 @@ export async function guardTreeNavigation(
 
   if (choice === hold) return undefined;
   if (choice === cancel) {
-    for (const ticket of summary.tickets) requestTicketCancel(ticket);
-    syncDelegateStatus(ctx);
+    for (const ticket of summary.tickets) {
+      rt.tickets.requestTicketCancel(ticket);
+    }
+    syncDelegateStatus(ctx, rt);
     return undefined;
   }
   return { cancel: true };

package/task-resolution.ts

@@ -12,8 +12,7 @@ import {
   availableToolNames,
   resolveToolGroups,
 } from "./tools.ts";
-import { configFor } from "./pool.ts";
-import { isSessionBusy } from "./tickets.ts";
+import { getDefaultDelegateRuntime, type DelegateRuntime } from "./runtime.ts";
 import {
   isResumeFromQuarantined,
   isSessionIdQuarantined,
@@ -115,6 +114,7 @@ export function validateTasks(
   tasks: DispatchableTask[],
   agents: Map<string, AgentConfig>,
   parentModelId: string | undefined,
+  runtime: DelegateRuntime = getDefaultDelegateRuntime(),
 ): DelegateToolResult | null {
   const unknown: string[] = [];
   for (const task of tasks) {
@@ -203,7 +203,7 @@ export function validateTasks(
   // Disallow sessionIds already claimed by a running async ticket.
   const busyConflicts: string[] = [];
   for (const sid of sessionIds) {
-    const owner = isSessionBusy(sid);
+    const owner = runtime.tickets.isSessionBusy(sid);
     if (owner) busyConflicts.push(`${sid} (ticket ${owner})`);
   }
   if (busyConflicts.length) {
@@ -247,6 +247,7 @@ export function resolveTasks(
   agents: Map<string, AgentConfig>,
   parentDefaults: ParentAgentDefaults,
   dispatchConfig: DelegateConfig = getDelegateConfigSnapshot(),
+  runtime: DelegateRuntime = getDefaultDelegateRuntime(),
 ): ResolveTasksResult {
   // Build parent transcript lazily — only computed once if any task uses with-parent-transcript
   let parentTranscript: string | null = null;
@@ -302,10 +303,12 @@ export function resolveTasks(
         : undefined;
 
     // Build system prompt. Explicit task prompts and named agent prompts
-    // win; ad-hoc subagents inherit the parent's base prompt when Pi exposes
+    // win; inline subagents inherit the parent's base prompt when Pi exposes
     // it. The assembled parent project-context section was stripped above;
     // the child ResourceLoader supplies context for this task's cwd.
-    const pooledConfig = t.sessionId ? configFor(t.sessionId) : undefined;
+    const pooledConfig = t.sessionId
+      ? runtime.pool.configFor(t.sessionId)
+      : undefined;
     const isPoolHit = pooledConfig !== undefined;
     const parentNativeTools = parentDefaults.tools.filter((name) =>
       Object.hasOwn(TOOL_FACTORIES, name),
@@ -625,12 +628,12 @@ export function resolveTasks(
       // display code treats "" and absent alike (`t.prompt || …`).
       prompt: prompt ?? "",
       // Keep the built-in selector visible in progress/results. Omitted-agent
-      // inline tasks retain the established `ad-hoc` label and config namespace
-      // — except resumes: a continued transcript is not a fresh ad-hoc spawn,
-      // so it carries the resumed-transcript identity instead.
+      // tasks use the `inline` label and config namespace — except resumes: a
+      // continued transcript is not a fresh inline spawn, so it carries the
+      // resumed-transcript identity instead.
       agentName:
         agent?.name ??
-        (resumeFromDisplay ? `resume:${resumeFromDisplay}` : "ad-hoc"),
+        (resumeFromDisplay ? `resume:${resumeFromDisplay}` : "inline"),
       resumeFromDisplay,
       warnings,
       reuseIntent: {

package/test-harness.ts

@@ -0,0 +1,81 @@
+import {
+  createTestSession,
+  type TestSession,
+  type TestSessionOptions,
+} from "@marcfargas/pi-test-harness";
+import type {
+  AgentSession,
+  AgentToolResult,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import type { DelegateDetails, TaskResult } from "./types.ts";
+import { resolve } from "node:path";
+
+export const DELEGATE_EXTENSION = resolve(import.meta.dirname, "./delegate.ts");
+
+export { type TestSession };
+
+export function createDelegateTestSession(
+  options: TestSessionOptions = {},
+): Promise<TestSession> {
+  return createTestSession({
+    ...options,
+    extensions: [...(options.extensions ?? []), DELEGATE_EXTENSION],
+  });
+}
+
+export interface TestToolDefinition {
+  name: string;
+  label: string;
+  description: string;
+  promptSnippet?: string;
+  promptGuidelines?: string[];
+  parameters: unknown;
+  prepareArguments?: (args: unknown) => unknown;
+  execute(...args: unknown[]): Promise<AgentToolResult<DelegateDetails>>;
+  renderCall: (...args: unknown[]) => Component;
+  renderResult: (...args: unknown[]) => Component;
+}
+
+export function getToolDef(ts: TestSession, name: string): TestToolDefinition {
+  const tool = (ts.session as AgentSession).extensionRunner.getToolDefinition(
+    name,
+  );
+  if (!tool) throw new Error(`${name} tool not found`);
+  return tool as unknown as TestToolDefinition;
+}
+
+export function getDelegateTool(ts: TestSession): TestToolDefinition {
+  return getToolDef(ts, "delegate");
+}
+
+export function getExecContext(ts: TestSession): ExtensionContext {
+  return (ts.session as AgentSession).extensionRunner.createContext();
+}
+
+export function firstText(result: { content: readonly unknown[] }): string {
+  const content = result.content[0];
+  if (
+    !content ||
+    typeof content !== "object" ||
+    !("type" in content) ||
+    content.type !== "text" ||
+    !("text" in content) ||
+    typeof content.text !== "string"
+  ) {
+    throw new Error("Expected first tool result content item to be text");
+  }
+  return content.text;
+}
+
+export function taskResultAt(
+  results: readonly (TaskResult | { error: string })[],
+  index: number,
+): TaskResult {
+  const result = results[index];
+  if (!result || !("agent" in result)) {
+    throw new Error(`Expected task result at index ${index}`);
+  }
+  return result;
+}