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

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

@@ -36,9 +36,9 @@ import { type FileSlashCommand } from "../extensibility/slash-commands";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
+import type { IrcMessage } from "../irc/bus";
 import { type MnemopiSessionState } from "../mnemopi/state";
 import type { PlanModeState } from "../plan-mode/state";
-import { type AgentRegistry } from "../registry/agent-registry";
 import { type SecretObfuscator } from "../secrets/obfuscator";
 import { type ConfiguredThinkingLevel } from "../thinking";
 import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
@@ -54,10 +54,10 @@ import { YieldQueue } from "./yield-queue";
 export type AgentSessionEvent = AgentEvent | {
     type: "auto_compaction_start";
     reason: "threshold" | "overflow" | "idle" | "incomplete";
-    action: "context-full" | "handoff" | "shake";
+    action: "context-full" | "handoff" | "shake" | "snapcompact";
 } | {
     type: "auto_compaction_end";
-    action: "context-full" | "handoff" | "shake";
+    action: "context-full" | "handoff" | "shake" | "snapcompact";
     result: CompactionResult | undefined;
     aborted: boolean;
     willRetry: boolean;
@@ -214,8 +214,6 @@ export interface AgentSessionConfig {
     asyncJobManager?: AsyncJobManager;
     /** Agent identity (registry id like "Main" or "Alice") used for IRC routing. */
     agentId?: string;
-    /** Shared agent registry (for forwarding IRC observations to the main session UI). */
-    agentRegistry?: AgentRegistry;
     /**
      * Override the provider-facing session ID for all API requests from this session.
      * When absent, `sessionManager.getSessionId()` is used. Needed when benchmark or
@@ -380,6 +378,16 @@ export declare class AgentSession {
      * Multiple listeners can be added. Returns unsubscribe function for this listener.
      */
     subscribe(listener: AgentSessionEventListener): () => void;
+    /**
+     * Synchronously mark the session as disposing so new work is rejected
+     * immediately: Python/eval starts throw, queued asides are dropped, and the
+     * aside provider is detached. Idempotent; `dispose()` runs it first.
+     *
+     * Wrappers that await other teardown before delegating to `dispose()` MUST
+     * call this before their first await — otherwise work started in that async
+     * gap slips past the disposal guards.
+     */
+    beginDispose(): void;
     /**
      * Remove all listeners, flush pending writes, and disconnect from agent.
      * Call this when completely done with the session.
@@ -483,6 +491,13 @@ export declare class AgentSession {
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
     buildDisplaySessionContext(): SessionContext;
+    /**
+     * Full-history transcript for TUI display: every path entry in
+     * chronological order with compactions rendered inline at the point they
+     * fired (instead of replacing prior history). Display-only — NEVER feed
+     * the result to `agent.replaceMessages` or a provider.
+     */
+    buildTranscriptSessionContext(): SessionContext;
     /** Convert session messages using the same pre-LLM pipeline as the active session. */
     convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
     /** Apply session-level stream hooks to a direct side request. */
@@ -910,27 +925,23 @@ export declare class AgentSession {
     /** Whether there are pending Python messages waiting to be flushed */
     get hasPendingPythonMessages(): boolean;
     /**
-     * Generate an ephemeral reply to a background message (e.g. an IRC ping from
-     * another agent) using this session's current model + system prompt + history.
+     * Deliver an IRC message into this session (recipient side; called by the
+     * IrcBus). Emits the `irc_message` session event for UI cards and injects
+     * the rendered message into the model's context as an `irc:incoming`
+     * custom message:
      *
-     * The incoming message is queued for injection into the recipient's persisted
-     * history immediately so timeouts/abort still preserve delivery. The reply is
-     * computed via a side-channel `streamSimple` call (analogous to `/btw`) so it
-     * never blocks on the recipient's in-flight tool calls. When a reply is
-     * generated, it is queued separately. Injection happens immediately when the
-     * session is idle, otherwise it is deferred until streaming ends.
-     */
-    respondAsBackground(args: {
-        from: string;
-        message: string;
-        awaitReply?: boolean;
-        signal?: AbortSignal;
-    }): Promise<{
-        replyText: string | null;
-    }>;
+     * - mid-turn → queued on the aside channel and folded in at the next step
+     *   boundary (non-interrupting, like async-result deliveries) → "injected";
+     * - idle → starts a real turn with the message so the recipient wakes
+     *   → "woken".
+     *
+     * Never blocks on the recipient's turn: the wake turn is fire-and-forget.
+     */
+    deliverIrcMessage(msg: IrcMessage): Promise<"injected" | "woken">;
     /**
      * Emit an IRC relay observation event on this session for UI rendering only.
-     * Does not persist the record to history. Public so other sessions can forward.
+     * Does not persist the record to history. Called by the IrcBus to surface
+     * agent↔agent traffic on the main session.
      */
     emitIrcRelayObservation(record: CustomMessage): void;
     /**
@@ -939,7 +950,7 @@ export declare class AgentSession {
      * does not block on, or interfere with, any in-flight main turn.  The
      * session's history and persisted state are NOT modified by this call.
      *
-     * Used by `respondAsBackground` (IRC) and `BtwController` (`/btw`) to share
+     * Used by `BtwController` (`/btw`) and `OmfgController` (`/omfg`) to share
      * the snapshot + stream pipeline.  The snapshot includes any in-flight
      * streaming assistant text so the model sees the half-finished response
      * rather than missing context.
@@ -1045,12 +1056,6 @@ export declare class AgentSession {
      * Includes user messages, assistant text, thinking blocks, tool calls, and tool results.
      */
     formatSessionAsText(): string;
-    /**
-     * Format the conversation as compact context for subagents.
-     * Includes only user messages and assistant text responses.
-     * Excludes: system prompt, tool definitions, tool calls/results, thinking blocks.
-     */
-    formatCompactContext(): string;
     /**
      * Check if extensions have handlers for a specific event type.
      */

package/dist/types/session/messages.d.ts

@@ -7,7 +7,7 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { type BranchSummaryMessage, type CompactionSummaryMessage } from "@oh-my-pi/pi-agent-core/compaction/messages";
 import type { AssistantMessage, ImageContent, Message, MessageAttribution, TextContent } from "@oh-my-pi/pi-ai";
-export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, } from "@oh-my-pi/pi-agent-core/compaction/messages";
+export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchSummaryMessage, createCompactionSummaryMessage, createCustomMessage, } from "@oh-my-pi/pi-agent-core/compaction/messages";
 import type { OutputMeta } from "../tools/output-meta";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
@@ -33,7 +33,7 @@ export interface SkillPromptDetails {
  *
  *  Consumers: `AgentSession.#handleAgentEvent` (stamper) writes this value;
  *  `EventController.#handleMessageEnd`, `AssistantMessageComponent`,
- *  `ui-helpers.addMessageToChat` (renderers), `SessionObserverOverlay
+ *  `ui-helpers.addMessageToChat` (renderers), `AgentHubOverlayComponent
  *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
  *  (fallback error emission) read it via `isSilentAbort`. */
 export declare const SILENT_ABORT_MARKER = "__omp.silent_abort__";
@@ -175,8 +175,6 @@ export declare function bashExecutionToText(msg: BashExecutionMessage): string;
  */
 export declare function pythonExecutionToText(msg: PythonExecutionMessage): string;
 export declare function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: AssistantMessage): AssistantMessage;
-/** Convert CustomMessageEntry to AgentMessage format */
-export declare function createCustomMessage(customType: string, content: string | (TextContent | ImageContent)[], display: boolean, details: unknown | undefined, timestamp: string, attribution?: MessageAttribution): CustomMessage;
 /**
  * Transform AgentMessages (including custom types) to LLM-compatible Messages.
  *

package/dist/types/session/session-history-format.d.ts

@@ -0,0 +1,12 @@
+export interface HistoryFormatOptions {
+    /** Optional H1 prepended to the transcript. */
+    title?: string;
+}
+/**
+ * Format a session's message array as a concise markdown transcript.
+ *
+ * `messages` is the session's in-memory message array (or the read-only
+ * equivalent loaded from a session file) — the same shapes
+ * `session-dump-format.ts` consumes.
+ */
+export declare function formatSessionHistoryMarkdown(messages: unknown[], opts?: HistoryFormatOptions): string;

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. When `async.enabled` is on, spawns run as AsyncJobManager jobs; when
+ * disabled, the tool blocks until every spawn finishes.
  */
 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 subagents to complete delegated tasks";
     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. */