@oh-my-pi/pi-coding-agent 15.10.12 → 15.11.0

package/dist/types/session/session-manager.d.ts

@@ -214,14 +214,31 @@ export declare function migrateSessionEntries(entries: FileEntry[]): void;
 /** Exported for compaction.test.ts */
 export declare function parseSessionEntries(content: string): FileEntry[];
 export declare function getLatestCompactionEntry(entries: SessionEntry[]): CompactionEntry | null;
+export interface BuildSessionContextOptions {
+    /**
+     * Build the full-history display transcript instead of the LLM context:
+     * every path entry in chronological order, with each compaction emitted
+     * inline as a `compactionSummary` message at the position it fired rather
+     * than replacing the history before it. Display-only — never send the
+     * result to a provider.
+     */
+    transcript?: boolean;
+}
 /**
  * Build the session context from entries using tree traversal.
  * If leafId is provided, walks from that entry to root.
  * Handles compaction and branch summaries along the path.
  */
-export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>): SessionContext;
+export declare function buildSessionContext(entries: SessionEntry[], leafId?: string | null, byId?: Map<string, SessionEntry>, options?: BuildSessionContextOptions): SessionContext;
 /** Exported for testing */
 export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
+/**
+ * Read-only message view of a session file: load entries, migrate to the
+ * current version, resolve blob refs, and build the context along the
+ * persisted leaf path (last entry). Does NOT create a writer or take the
+ * session lock — safe to call against a file another session is writing.
+ */
+export declare function loadSessionMessagesReadOnly(filePath: string): Promise<AgentMessage[]>;
 declare class RecentSessionInfo {
     #private;
     readonly path: string;
@@ -507,10 +524,11 @@ export declare class SessionManager {
      */
     getBranch(fromId?: string): SessionEntry[];
     /**
-     * Build the session context (what gets sent to the LLM).
+     * Build the session context (what gets sent to the LLM), or — with
+     * `{ transcript: true }` — the full-history display transcript.
      * Uses tree traversal from current leaf.
      */
-    buildSessionContext(): SessionContext;
+    buildSessionContext(options?: BuildSessionContextOptions): SessionContext;
     /** Strip stale OpenAI Responses assistant replay metadata from loaded in-memory entries. */
     sanitizeLoadedOpenAIResponsesReplayMetadata(): boolean;
     /**

package/dist/types/session/streaming-output.d.ts

@@ -159,6 +159,29 @@ export declare function formatMiddleElisionMarker(elidedLines: number, elidedByt
  * budget is empty or the content already fits.
  */
 export declare function truncateMiddle(content: string, options?: TruncationOptions): TruncationResult;
+/** Options for {@link enforceInlineByteCap}. */
+export interface InlineByteCapOptions {
+    /** Inline byte budget. Defaults to {@link DEFAULT_MAX_BYTES}. */
+    maxBytes?: number;
+    /** What the text is, for the elision marker (e.g. "bash output"). */
+    label: string;
+    /**
+     * Persist the full text as a session artifact. When an artifact id is
+     * returned, a `[raw output: artifact://<id>]` footer is appended so the
+     * elided bytes stay recoverable.
+     */
+    saveArtifact?: (full: string) => string | undefined | Promise<string | undefined>;
+}
+/**
+ * Final-defense inline size guard for tool results.
+ *
+ * No-op when `text` fits within `maxBytes` (the common path). Otherwise keeps
+ * ~60% of the budget from the head and ~25% from the tail — cut on line
+ * boundaries, never splitting a multi-byte UTF-8 sequence — with an elision
+ * marker between. The remaining ~15% is slack for the marker and the optional
+ * `[raw output: artifact://<id>]` footer, so the result stays under `maxBytes`.
+ */
+export declare function enforceInlineByteCap(text: string, options: InlineByteCapOptions): Promise<string>;
 export declare class TailBuffer {
     #private;
     readonly maxBytes: number;

package/dist/types/task/executor.d.ts

@@ -22,6 +22,16 @@ import type { ContextFileEntry } from "../tools";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type AgentDefinition, type AgentProgress, type ReviewFinding, type SingleResult } from "./types";
+/**
+ * Soft per-agent request budgets (assistant requests per run). When a subagent
+ * crosses its budget it receives ONE steering notice asking it to wrap up; at
+ * 1.5x the budget the run is aborted gracefully so partial output is salvaged.
+ * The `default` key applies to agents without an explicit entry and can be
+ * overridden via the `task.softRequestBudget` setting (0 disables the guard).
+ */
+export declare const SOFT_REQUEST_BUDGET: Record<string, number>;
+/** Steering notice injected once when a subagent crosses its soft request budget. */
+export declare function buildBudgetNotice(requests: number): string;
 /** Options for subagent execution */
 export interface ExecutorOptions {
     cwd: string;
@@ -29,6 +39,7 @@ export interface ExecutorOptions {
     agent: AgentDefinition;
     task: string;
     assignment?: string;
+    /** Shared background from the task call (`task.batch`), rendered into the subagent's system prompt. */
     context?: string;
     /**
      * The session's active overall plan, handed off so subagents spawned during
@@ -66,8 +77,6 @@ export interface ExecutorOptions {
     sessionFile?: string | null;
     persistArtifacts?: boolean;
     artifactsDir?: string;
-    /** Path to parent conversation context file */
-    contextFile?: string;
     eventBus?: EventBus;
     contextFiles?: ContextFileEntry[];
     skills?: Skill[];

package/dist/types/task/index.d.ts

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolSession } from "..";
 import type { Theme } from "../modes/theme/theme";
-import { type AgentDefinition, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
+import { type AgentDefinition, type SingleResult, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
 import { renderResult, renderCall as renderTaskCall } from "./render";
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
@@ -12,11 +12,18 @@ export type { AgentDefinition, AgentProgress, SingleResult, SubagentEventPayload
 export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
 export declare const READ_ONLY_TOOL_NAMES: ReadonlySet<string>;
 export declare function isReadOnlyAgent(agent: AgentDefinition): boolean;
+/**
+ * Preview text for a child result. Falls back to "(no output)" — annotated
+ * with the request count when the child actually did work, so the parent can
+ * tell a no-op child from one that burned requests before being cancelled.
+ */
+export declare function formatResultOutputFallback(result: Pick<SingleResult, "output" | "stderr" | "requests">): string;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *
- * Requires async initialization to discover available agents.
- * Use `TaskTool.create(session)` to instantiate.
+ * Each call spawns one subagent — or, with `task.batch`, one per `tasks[]`
+ * item. Spawning is non-blocking: the call registers AsyncJobManager jobs and
+ * returns immediately; each result is delivered when that agent yields.
  */
 export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetails, Theme> {
     #private;
@@ -25,7 +32,7 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
     readonly approval: "exec";
     readonly formatApprovalDetails: (args: unknown) => string[];
     readonly label = "Task";
-    readonly summary = "Spawn a subagent to complete a parallel task";
+    readonly summary = "Spawn a subagent to complete a task in the background";
     readonly strict = true;
     readonly loadMode = "discoverable";
     readonly renderResult: typeof renderResult;

package/dist/types/task/output-manager.d.ts

@@ -17,11 +17,4 @@ export declare class AgentOutputManager {
      * @returns Unique ID ("Anna" first, then "Anna-2", "Anna-3", …)
      */
     allocate(id: string): Promise<string>;
-    /**
-     * Allocate unique IDs for a batch of tasks.
-     *
-     * @param ids Array of requested IDs
-     * @returns Array of unique IDs in same order
-     */
-    allocateBatch(ids: string[]): Promise<string[]>;
 }

package/dist/types/task/repair-args.d.ts

@@ -2,7 +2,7 @@
  * Repair double-encoded JSON string arguments for the task tool.
  *
  * Models occasionally JSON-escape a string value twice when emitting a
- * `task` tool call, so a `context`/`assignment` that should read
+ * `task` tool call, so an `assignment` that should read
  *
  *     # Role
  *     You are a judge … "describe this" … return —
@@ -24,7 +24,7 @@
  * string.
  *
  * This is deliberately scoped to the task tool's natural-language fields
- * (`context`, `assignment`, `description`). It is NOT applied to code-bearing
+ * (`assignment`, `description`). It is NOT applied to code-bearing
  * tools (write/edit/bash/search), where a backslash or quote is load-bearing
  * and a false-positive unescape would silently corrupt a file or command.
  */
@@ -43,10 +43,11 @@ import type { TaskParams } from "./types";
  */
 export declare function repairDoubleEncodedJsonString(value: string): string;
 /**
- * Repair double-encoded prose in task-tool params (`context` and each task's
- * `assignment`/`description`). Returns the same reference when nothing changed
- * so callers can cheaply skip work. Defensive against partially-streamed args
- * (missing/undefined fields, partial task arrays) so it is safe on the render
- * path as well as on execution.
+ * Repair double-encoded prose in task-tool params (`assignment`,
+ * `description`, shared `context`, and each batch task item's prose fields).
+ * Returns the same reference when nothing changed so callers can cheaply skip
+ * work. Defensive against partially-streamed args (missing/undefined fields,
+ * partial task arrays) so it is safe on the render path as well as on
+ * execution.
  */
 export declare function repairTaskParams(params: TaskParams): TaskParams;

package/dist/types/task/types.d.ts

@@ -2,7 +2,6 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import * as z from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
-import { type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
@@ -43,85 +42,86 @@ export interface SubagentLifecyclePayload {
     parentToolCallId?: string;
     index: number;
 }
-/** Single task item for parallel execution (default shape with context enabled). */
 export declare const taskItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    description: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
     assignment: z.ZodString;
 }, z.core.$strip>;
-export type TaskItem = z.infer<typeof taskItemSchema>;
+/** Single task item. Fields are optional defensively: args stream in token by token. */
+export interface TaskItem {
+    /** Stable agent id; default = generated AdjectiveNoun. */
+    id?: string;
+    /** UI label, not seen by the subagent. */
+    description?: string;
+    /** The work; required by the schema. */
+    assignment?: string;
+    /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
+    isolated?: boolean;
+}
 export declare const taskSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    assignment: z.ZodString;
+    isolated: z.ZodOptional<z.ZodBoolean>;
     agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const taskSchemaNoIsolation: z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
 }, z.core.$strip>;
 declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    assignment: z.ZodString;
+    isolated: z.ZodOptional<z.ZodBoolean>;
     agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    assignment: z.ZodString;
     agent: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
+    context: z.ZodString;
     tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
         assignment: z.ZodString;
+        isolated: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     agent: z.ZodString;
+    context: z.ZodString;
     tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
         assignment: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
-/** Active task tool parameter schema for the current simple-mode / isolation flags */
+/** Active task tool parameter schema for the current isolation / batch flags */
 export type TaskToolSchemaInstance = DynamicTaskSchema;
 export declare function getTaskSchema(options: {
     isolationEnabled: boolean;
-    simpleMode: TaskSimpleMode;
+    batchEnabled: boolean;
 }): DynamicTaskSchema;
+/**
+ * Runtime params union over both wire shapes. The model sees exactly one shape
+ * (`{ agent, context, tasks[] }` when `task.batch` is on, `{ agent, ...item }`
+ * otherwise); runtime stays permissive so internal callers and stale
+ * transcripts using the flat form keep working under either setting.
+ */
 export interface TaskParams {
-    agent: string;
+    /** Agent type; required. */
+    agent?: string;
+    /** Stable agent id (flat form); default = generated AdjectiveNoun. */
+    id?: string;
+    /** UI label (flat form), not seen by the subagent. */
+    description?: string;
+    /** The work (flat form). */
+    assignment?: string;
+    /** Batch form (`task.batch`): one subagent per item. */
+    tasks?: TaskItem[];
+    /** Batch form: shared background prepended to every assignment; required by the batch schema. */
     context?: string;
-    schema?: string;
-    tasks: TaskItem[];
+    /** Run in an isolated worktree (flat form; per-item in batch form). */
     isolated?: boolean;
 }
 /** A code review finding reported by the reviewer agent */
@@ -183,6 +183,8 @@ export interface AgentProgress {
     }>;
     recentOutput: string[];
     toolCount: number;
+    /** Count of assistant requests (assistant message_end events) across the run. Drives the soft request budget guard. */
+    requests: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;
     /**
@@ -252,6 +254,8 @@ export interface SingleResult {
     durationMs: number;
     /** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
     tokens: number;
+    /** Count of assistant requests (assistant message_end events) across the run. */
+    requests: number;
     /** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
     contextTokens?: number;
     /** Model's context window in tokens, when known. */

package/dist/types/tools/browser/tab-worker.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLElement } from "linkedom";
-import type { ElementHandle } from "puppeteer-core";
+import type { ElementHandle, ImageFormat } from "puppeteer-core";
 import type { Transport } from "./tab-protocol";
 declare global {
     interface Element extends HTMLElement {
@@ -23,6 +23,8 @@ export interface InflightOp {
 }
 /** Human-readable label for a screenshot op, used in op tracking + timeout errors. */
 export declare function describeScreenshot(opts?: ScreenshotOptions): string;
+/** Map an explicit save path's extension to a puppeteer capture format (default png). */
+export declare function imageFormatForPath(filePath: string): ImageFormat;
 /** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
 export declare function describeInflight(inflight: Map<number, InflightOp>): string;
 export declare class WorkerCore {

package/dist/types/tools/find.d.ts

@@ -14,17 +14,6 @@ declare const findSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, z.core.$strict>;
 export type FindToolInput = z.infer<typeof findSchema>;
-/**
- * Group find matches into a multi-level directory tree so the model doesn't pay
- * repeated tokens for shared path prefixes. Single-child directory chains fold
- * into one header (`# a/b/c/`), so a common prefix — including an absolute root
- * for out-of-cwd results — collapses to a single line. Each level adds one `#`;
- * files are listed bare under the deepest directory header that owns them.
- *
- * Order follows the input (mtime-desc for native glob): a directory appears when
- * its first member is emitted, and a node's own files precede its subdirectories.
- */
-export declare function formatFindGroupedOutput(paths: readonly string[]): string;
 export interface FindToolDetails {
     truncation?: TruncationResult;
     resultLimitReached?: number;

package/dist/types/tools/grouped-file-output.d.ts

@@ -1,51 +1,3 @@
-interface PathTreeNode {
-    /** Direct file leaves, in first-seen order. */
-    files: Array<{
-        name: string;
-        key: string;
-    }>;
-    /** Dedup set for `files` (a glob can surface the same path twice on retry). */
-    fileNames: Set<string>;
-    /** Child directories, in first-seen order. */
-    subdirs: Array<{
-        name: string;
-        node: PathTreeNode;
-    }>;
-    /** Dedup index for `subdirs`. */
-    dirIndex: Map<string, PathTreeNode>;
-}
-export interface PathTreeInput {
-    /** Path string; absolute, cwd-relative, or url-like. Backslashes are normalized. */
-    path: string;
-    /** Whether the leaf itself is a directory (trailing-slash match from find). */
-    isDir: boolean;
-    /** Opaque key carried onto file events for section lookup. Defaults to `path`. */
-    key?: string;
-}
-/** One node emitted while walking the tree: a folded directory or a file leaf. */
-export interface GroupedTreeEvent {
-    kind: "dir" | "file";
-    /** 0-based nesting depth (root children are depth 0). */
-    depth: number;
-    /** Folded chain for dirs (e.g. `a/b/c`, no trailing slash); basename for files. */
-    name: string;
-    /** File key for `kind === "file"`; empty string for directories. */
-    key: string;
-}
-/**
- * Build a directory tree from a flat list of paths. URL-like entries are kept
- * whole as root-level file leaves (they have no meaningful directory structure).
- * Absolute paths carry a leading empty segment so they share a common `/` root
- * and fold like any other prefix.
- */
-export declare function buildPathTree(entries: Iterable<PathTreeInput>): PathTreeNode;
-/**
- * Depth-first walk yielding directory and file events. Directories collapse their
- * single-child chains (`a` → `a/b` → `a/b/c`) so a shared prefix becomes one
- * header. Each node's direct files are emitted before its subdirectories, keeping
- * a file unambiguously attached to the header above it.
- */
-export declare function walkPathTree(node: PathTreeNode, depth?: number): Generator<GroupedTreeEvent>;
 /**
  * One file's contribution to a grouped file output. The header itself is generated
  * by `formatGroupedFiles` (one `#` per nesting level); use `headerSuffix` to tack
@@ -116,4 +68,3 @@ export declare function classifyGroupedLines(lines: readonly string[], headerBas
  * indices lets callers slice parallel arrays (raw lines, styled lines, contexts).
  */
 export declare function groupLineIndicesByBlank(rawLines: readonly string[]): number[][];
-export {};

package/dist/types/tools/index.d.ts

@@ -13,7 +13,7 @@ import type { LocalProtocolOptions } from "../internal-urls";
 import type { MCPManager } from "../mcp";
 import type { MnemopiSessionState } from "../mnemopi/state";
 import type { PlanModeState } from "../plan-mode/state";
-import { type AgentRegistry } from "../registry/agent-registry";
+import type { AgentRegistry } from "../registry/agent-registry";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
 import type { CustomMessage } from "../session/messages";
@@ -220,8 +220,6 @@ export interface ToolSession {
     recordEvalSubagentUsage?: (output: number) => void;
     /** Bridge to the connected client (e.g. ACP editor host). Tools should route fs/terminal/permission requests through this when available. */
     getClientBridge?: () => ClientBridge | undefined;
-    /** Get compact conversation context for subagents (excludes tool results, system prompts) */
-    getCompactContext?: () => string;
     /** Get cached todo phases for this session. */
     getTodoPhases?: () => TodoPhase[];
     /** Replace cached todo phases for this session. */

package/dist/types/tools/irc.d.ts

@@ -1,58 +1,62 @@
 /**
- * IRC tool — agent-to-agent messaging.
+ * IRC tool — agent-to-agent messaging over the process-global IrcBus.
  *
- * Lets any live agent send a short prose message to any other live agent in
- * this process and (optionally) get a prose reply.
- *
- * Routing happens via the global AgentRegistry. Replies are produced by an
- * ephemeral side-channel call (`AgentSession.respondAsBackground`) that
- * mirrors `/btw`: the recipient's current model, system prompt, and message
- * history are used to compute a reply without persisting it through the
- * normal stream path. After the reply is generated, both the incoming
- * message and the auto-reply are queued for injection into the recipient's
- * persisted history (deferred until the recipient is idle), so the model
- * sees the exchange on its next turn.
- *
- * This avoids the deadlock that arises when the recipient is blocked on a
- * long-running tool call: the side-channel call does not depend on the
- * recipient's main agent loop being free.
+ * `send` is fire-and-forget: the bus routes the message to the recipient
+ * (waking idle agents with a real turn, reviving parked ones via the
+ * lifecycle manager, injecting a non-interrupting aside into busy ones) and
+ * returns delivery receipts immediately. Replies are real turns by the
+ * recipient, observed with `wait` (or the `await: true` send sugar). `inbox`
+ * drains pending messages; `list` shows every addressable peer.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "@oh-my-pi/pi-tui";
 import * as z from "zod/v4";
+import type { Settings } from "../config/settings";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type IrcDeliveryReceipt, type IrcMessage } from "../irc/bus";
+import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
+/**
+ * IRC availability: there must be someone to chat with. True for every
+ * subagent (it always has a parent, and possibly siblings) and for any
+ * session that can still spawn subagents through the task tool. Only a
+ * top-level session with task spawning unavailable has no peers — no irc.
+ */
+export declare function isIrcEnabled(settings: Settings, taskDepth: number): boolean;
 declare const ircSchema: z.ZodObject<{
     op: z.ZodEnum<{
+        inbox: "inbox";
         list: "list";
         send: "send";
+        wait: "wait";
     }>;
     to: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
-    awaitReply: z.ZodOptional<z.ZodBoolean>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    await: z.ZodOptional<z.ZodBoolean>;
+    from: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    peek: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type IrcParams = z.infer<typeof ircSchema>;
-interface IrcReply {
-    from: string;
-    text: string;
+interface IrcPeerInfo {
+    id: string;
+    displayName: string;
+    kind: string;
+    status: string;
+    parentId?: string;
+    unread: number;
+    lastActivity: number;
 }
 export interface IrcDetails {
-    op: "send" | "list";
+    op: "send" | "wait" | "inbox" | "list";
     from?: string;
     to?: string;
-    delivered?: string[];
-    replies?: IrcReply[];
-    failed?: Array<{
-        id: string;
-        error: string;
-    }>;
-    notFound?: string[];
-    peers?: Array<{
-        id: string;
-        displayName: string;
-        kind: string;
-        status: string;
-        parentId?: string;
-    }>;
-    channels?: string[];
+    receipts?: IrcDeliveryReceipt[];
+    /** Message consumed by `wait` / `send await:true`; null when the wait timed out. */
+    waited?: IrcMessage | null;
+    inbox?: IrcMessage[];
+    peers?: IrcPeerInfo[];
 }
 export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
     #private;
@@ -60,16 +64,22 @@ export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails>
     readonly name = "irc";
     readonly approval: "read";
     readonly label = "IRC";
-    readonly summary = "Send and receive messages between agents over IRC-like channels";
+    readonly summary = "Send and receive messages between agents";
     readonly description: string;
     readonly parameters: z.ZodObject<{
         op: z.ZodEnum<{
+            inbox: "inbox";
             list: "list";
             send: "send";
+            wait: "wait";
         }>;
         to: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;
-        awaitReply: z.ZodOptional<z.ZodBoolean>;
+        replyTo: z.ZodOptional<z.ZodString>;
+        await: z.ZodOptional<z.ZodBoolean>;
+        from: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        peek: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
@@ -77,4 +87,32 @@ export declare class IrcTool implements AgentTool<typeof ircSchema, IrcDetails>
     static createIf(session: ToolSession): IrcTool | null;
     execute(_toolCallId: string, params: IrcParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<IrcDetails>, _context?: AgentToolContext): Promise<AgentToolResult<IrcDetails>>;
 }
+type IrcRenderArgs = Partial<IrcParams>;
+/**
+ * Display-only transcript card for live IRC traffic: `irc:incoming` DMs
+ * delivered to this session and `irc:relay` observations of agent↔agent
+ * traffic. Shares the tool renderer's glyph + quote-border conventions so
+ * cards and `irc` tool output look identical in the transcript.
+ */
+export declare function createIrcMessageCard(card: {
+    kind: "incoming" | "relay";
+    from?: string;
+    to?: string;
+    body?: string;
+    replyTo?: string;
+    timestamp?: number;
+}, getExpanded: () => boolean, uiTheme: Theme): Component;
+export declare const ircToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: IrcRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: IrcDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: IrcRenderArgs): Component;
+};
 export {};

package/dist/types/tools/job.d.ts

@@ -27,6 +27,13 @@ export interface JobToolDetails {
         status: CancelStatus;
     }[];
 }
+/**
+ * A poll snapshot where every watched job is still running and nothing was
+ * cancelled — pure "still waiting" noise once a newer poll exists. The TUI
+ * keeps such a block un-finalized (displaceable) so a follow-up `job` call
+ * replaces it instead of stacking another waiting frame in the transcript.
+ */
+export declare function isWaitingPollDetails(details: unknown): boolean;
 export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
     #private;
     private readonly session;
@@ -43,7 +50,6 @@ export declare class JobTool implements AgentTool<typeof jobSchema, JobToolDetai
     readonly strict = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): JobTool | null;
     execute(_toolCallId: string, params: JobParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<JobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<JobToolDetails>>;
 }
 interface JobRenderArgs {

package/examples/extensions/with-deps/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "pi-extension-with-deps",
 	"version": "1.0.0",
+	"homepage": "https://omp.sh",
 	"type": "module",
 	"omp": {
 		"extensions": [