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

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

@@ -2,6 +2,15 @@ import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 export declare const DEFAULT_MAX_LINES = 3000;
 export declare const DEFAULT_MAX_BYTES: number;
 export declare const DEFAULT_MAX_COLUMN = 512;
+/**
+ * Default artifact-on-disk cap for {@link OutputSink}.
+ *
+ * `0` means unbounded: by default, `artifact://<id>` references preserve the
+ * complete raw stream instead of a capped head/tail sample.
+ */
+export declare const ARTIFACT_DEFAULT_MAX_BYTES = 0;
+/** Default head budget; the remainder becomes the rolling tail window. */
+export declare const ARTIFACT_DEFAULT_HEAD_BYTES: number;
 export interface OutputSummary {
     output: string;
     truncated: boolean;
@@ -41,6 +50,20 @@ export interface OutputSinkOptions {
     onChunk?: (chunk: string) => void;
     /** Minimum ms between onChunk calls. 0 = every chunk (default). */
     chunkThrottleMs?: number;
+    /**
+     * Optional cap on bytes written to the artifact-on-disk file. When the cap
+     * is hit, the head window is preserved verbatim and subsequent output feeds
+     * a rolling tail window; on close, the sink writes a single
+     * `[ARTIFACT TRUNCATED: …]` notice between them. Default
+     * {@link ARTIFACT_DEFAULT_MAX_BYTES} (unbounded).
+     */
+    artifactMaxBytes?: number;
+    /**
+     * Bytes reserved for the head window of the capped artifact file. The
+     * tail window receives `artifactMaxBytes - artifactHeadBytes`. Default
+     * {@link ARTIFACT_DEFAULT_HEAD_BYTES}; clamped to `[0, artifactMaxBytes]`.
+     */
+    artifactHeadBytes?: number;
 }
 export interface TruncationResult {
     content: string;
@@ -136,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/slash-commands/acp-builtins.d.ts

@@ -1,6 +1,22 @@
 import type { AvailableCommand } from "@agentclientprotocol/sdk";
 import type { AcpBuiltinSlashCommandResult, SlashCommandRuntime } from "./types";
 export type { AcpBuiltinSlashCommandResult } from "./types";
+/**
+ * All names (primary + aliases) that are reserved by ACP builtins. Used to
+ * filter out extension commands that would shadow a builtin or its alias at
+ * dispatch time (e.g. `models` is an alias for `/model`, so an extension
+ * registering `models` would appear in the palette but execute the builtin).
+ */
+export declare const ACP_BUILTIN_RESERVED_NAMES: ReadonlySet<string>;
+/**
+ * Whether an extension command named `name` would be captured by ACP builtin
+ * dispatch before reaching the extension handler. Beyond exact name/alias
+ * collisions, `parseSlashCommand` treats `:` as a name/args separator, so a
+ * colon-namespaced name whose prefix is a handled builtin (e.g. `model:foo`)
+ * executes the `/model` builtin with `foo` as args. Such names must not be
+ * advertised to ACP clients.
+ */
+export declare function isAcpBuiltinShadowedName(name: string): boolean;
 /**
  * Commands advertised to ACP clients. Entries without a text-mode `handle`
  * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -2,6 +2,7 @@ import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, Slash
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+export declare const BUILTIN_SLASH_COMMAND_RESERVED_NAMES: ReadonlySet<string>;
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;
 /**

package/dist/types/slash-commands/types.d.ts

@@ -12,6 +12,7 @@ export interface SubcommandDef {
 /** Declarative builtin slash command metadata used by autocomplete and help UI. */
 export interface BuiltinSlashCommand {
     name: string;
+    aliases?: string[];
     description: string;
     /** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
     subcommands?: SubcommandDef[];
@@ -79,7 +80,6 @@ export interface TuiSlashCommandRuntime {
 }
 /** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
 export interface SlashCommandSpec extends BuiltinSlashCommand {
-    aliases?: string[];
     /** When false, the dispatcher refuses to handle invocations that include arguments. */
     allowArgs?: boolean;
     /**

package/dist/types/system-prompt.d.ts

@@ -10,6 +10,8 @@ interface AlwaysApplyRule {
     content: string;
     path: string;
 }
+/** Discover TITLE_SYSTEM.md file for automatic session-title prompt overrides */
+export declare function discoverTitleSystemPromptFile(cwd?: string): string | undefined;
 /** Resolve input as file path or literal string */
 export declare function resolvePromptInput(input: string | undefined, description: string): Promise<string | undefined>;
 export interface LoadContextFilesOptions {

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
@@ -42,6 +53,7 @@ export interface ExecutorOptions {
     description?: string;
     index: number;
     id: string;
+    parentToolCallId?: string;
     modelOverride?: string | string[];
     /**
      * Active model selector of the parent session, used as an auth-aware fallback
@@ -65,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,22 +1,29 @@
 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";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
 export { AgentOutputManager } from "./output-manager";
-export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
+export type { AgentDefinition, AgentProgress, SingleResult, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
 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;
@@ -39,5 +46,5 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
      * Create a TaskTool instance with async agent discovery.
      */
     static create(session: ToolSession): Promise<TaskTool>;
-    execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
+    execute(toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
 }

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

@@ -1,7 +1,7 @@
 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 TaskSimpleMode } from "./simple-mode";
+import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
@@ -21,10 +21,16 @@ export interface SubagentProgressPayload {
     agent: string;
     agentSource: AgentSource;
     task: string;
+    parentToolCallId?: string;
     assignment?: string;
     progress: AgentProgress;
     sessionFile?: string;
 }
+/** Payload emitted on TASK_SUBAGENT_EVENT_CHANNEL */
+export interface SubagentEventPayload {
+    id: string;
+    event: AgentSessionEvent;
+}
 /** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
 export interface SubagentLifecyclePayload {
     id: string;
@@ -33,87 +39,89 @@ export interface SubagentLifecyclePayload {
     description?: string;
     status: "started" | "completed" | "failed" | "aborted";
     sessionFile?: string;
+    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 */
@@ -175,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;
     /**
@@ -244,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/thinking.d.ts

@@ -24,6 +24,10 @@ export declare function getThinkingLevelMetadata(level: ThinkingLevel): Thinking
  * Converts an agent-local selector into the effort sent to providers.
  */
 export declare function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined;
+/**
+ * True when a selector explicitly requests provider-side reasoning disablement.
+ */
+export declare function shouldDisableReasoning(level: ThinkingLevel | undefined): boolean;
 /**
  * Resolves a selector against the current model while preserving explicit "off".
  */

package/dist/types/tiny/title-client.d.ts

@@ -18,6 +18,16 @@ export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
     onProgress?: (event: TinyTitleProgressEvent) => void;
 }
+/**
+ * Per-request controls for {@link TinyTitleClient.generate}.
+ *
+ * Carries the optional abort signal and title-system-prompt override used by
+ * callers that customize automatic session-title generation.
+ */
+export interface TinyTitleGenerateOptions {
+    signal?: AbortSignal;
+    systemPrompt?: string;
+}
 /**
  * Hidden subcommand on the main CLI that boots the tiny-model worker in the
  * spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
@@ -56,6 +66,7 @@ export declare class TinyTitleClient {
     constructor(spawnWorker?: () => WorkerHandle);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
+    generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
     complete(modelKey: string, prompt: string, options?: {
         maxTokens?: number;
         signal?: AbortSignal;

package/dist/types/tiny/title-protocol.d.ts

@@ -24,6 +24,7 @@ export type TinyTitleWorkerInbound = {
     id: string;
     modelKey: TinyTitleLocalModelKey;
     message: string;
+    systemPrompt?: string;
 } | {
     type: "complete";
     id: string;

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. */
@@ -279,6 +277,12 @@ export interface ToolSession {
     /** Per-session ledger of post-edit LSP diagnostics already surfaced to the
      *  model for each file. Lazily initialized by `getDiagnosticsLedger`. */
     diagnosticsLedger?: import("../lsp/diagnostics-ledger").DiagnosticsLedger;
+    /** Per-session ledger of consecutive byte-identical no-op edits, keyed by
+     *  canonical file path. The hashline executor escalates a soft no-op hint
+     *  to a thrown error once the same payload no-ops `NOOP_HARD_LIMIT` times,
+     *  breaking subagent loops that ignore the textual hint (issue #2081).
+     *  Lazily initialized by `getNoopLoopGuard`. */
+    noopLoopGuard?: import("../edit/hashline/noop-loop-guard").NoopLoopGuard;
     /** Queue a hidden message to be injected at the next agent turn. */
     queueDeferredMessage?(message: CustomMessage): void;
     /** Queue late LSP diagnostics (arrived after an edit/write returned) to be shown