@oh-my-pi/pi-coding-agent 15.8.3 → 15.9.1

package/dist/types/session/redis-session-storage.d.ts

@@ -1,4 +1,4 @@
-import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+import { IndexedSessionStorage } from "./indexed-session-storage";
 /**
  * Minimal subset of the `bun:redis` `RedisClient` surface used by
  * {@link RedisSessionStorage}. Keeping the contract narrow (and accepting any
@@ -7,6 +7,8 @@ import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from ".
  */
 export interface RedisSessionStorageClient {
     get(key: string): Promise<string | null>;
+    getrange(key: string, start: number, end: number): Promise<string>;
+    strlen(key: string): Promise<number>;
     set(key: string, value: string): Promise<unknown>;
     append(key: string, value: string): Promise<number>;
     del(...keys: string[]): Promise<number>;
@@ -26,7 +28,7 @@ export interface RedisSessionStorageOptions {
      */
     prefix?: string;
     /**
-     * Maximum number of keys returned per SCAN batch when warming the mirror.
+     * Maximum number of keys returned per SCAN batch when warming the metadata index.
      * Default 500.
      */
     scanCount?: number;
@@ -34,91 +36,16 @@ export interface RedisSessionStorageOptions {
 /**
  * Redis-backed implementation of {@link SessionStorage}. Each session JSONL
  * file maps to a Redis STRING key, with per-key metadata (mtime) tracked in a
- * single sibling HASH. An in-memory mirror is loaded on construction so the
- * interface's synchronous methods (`existsSync`, `statSync`, `listFilesSync`,
- * `readTextSync`, `writeTextSync`) keep their contracts — Bun's Redis client
- * is async only, and the persist hot path (`writer.writeLineSync`) cannot
- * wait on a network round-trip.
- *
- * Trade-offs vs `FileSessionStorage`:
- * - Mirror state is process-local. Two processes writing the same session key
- *   will diverge until one of them reloads via {@link refresh}. This matches
- *   `FileSessionStorage`'s existing single-writer assumption.
- * - `writeLineSync` updates the mirror synchronously and queues an async
- *   `APPEND`. The promise is awaited by `flush()` / `close()` / {@link drain}.
- *   A SIGKILL landing between the sync mirror update and the network round
- *   trip loses the last line; the file-backed implementation survives that
- *   window because bytes are handed to the kernel page cache before
- *   returning.
- * - Blobs (image data) and tool artifact files still live on disk via
- *   `BlobStore` / `ArtifactManager`. Those are out of scope for this storage.
+ * single sibling HASH. This process keeps only a metadata index (`size`,
+ * `mtimeMs`) in memory so synchronous `existsSync` / `statSync` /
+ * `listFilesSync` calls remain available without mirroring full content.
  */
-export declare class RedisSessionStorage implements SessionStorage {
-    #private;
-    private constructor();
+export declare class RedisSessionStorage extends IndexedSessionStorage {
     /**
-     * Warm the in-memory mirror with every existing session key under the
-     * configured prefix and return the ready-to-use storage. Must be awaited
-     * before passing the storage into `SessionManager.create()` so synchronous
-     * lookups (session resume, recent sessions, EPERM-backup recovery) see
-     * the existing keyspace.
+     * Warm the metadata index with every existing session key under the configured
+     * prefix and return the ready-to-use storage. Must be awaited before passing
+     * the storage into `SessionManager.create()` so synchronous lookups (session
+     * resume, recent sessions, EPERM-backup recovery) see the existing keyspace.
      */
     static create(options: RedisSessionStorageOptions): Promise<RedisSessionStorage>;
-    /**
-     * Re-scan Redis and replace the mirror's contents. Call this from a
-     * different process that took over a session keyspace, or after an
-     * out-of-band write made by another agent.
-     */
-    refresh(): Promise<void>;
-    /**
-     * Resolve once every pending background write (issued via `writeTextSync`
-     * or `writer.writeLineSync`) has been acknowledged by Redis. Throws if any
-     * background write failed since the last drain.
-     *
-     * Call this on graceful shutdown to avoid losing the last unflushed line.
-     * The session-manager's own `flush()` / `close()` already drain through
-     * the writer chain — this method exists for callers (test harnesses,
-     * subprocess-style consumers) that bypass the writer.
-     */
-    drain(): Promise<void>;
-    ensureDirSync(_dir: string): void;
-    existsSync(path: string): boolean;
-    writeTextSync(path: string, content: string): void;
-    readTextSync(path: string): string;
-    statSync(path: string): SessionStorageStat;
-    listFilesSync(dir: string, pattern: string): string[];
-    exists(path: string): Promise<boolean>;
-    readText(path: string): Promise<string>;
-    readTextPrefix(path: string, maxBytes: number): Promise<string>;
-    writeText(path: string, content: string): Promise<void>;
-    rename(src: string, dst: string): Promise<void>;
-    unlink(path: string): Promise<void>;
-    deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
-    openWriter(path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    }): SessionStorageWriter;
-    _writerClosed(writer: RedisSessionStorageWriter): void;
-    /** Mirror-only mutation, no Redis call. Used by writers to update local state synchronously. */
-    _mirrorAppend(path: string, line: string): void;
-    /** Mirror-only mutation, no Redis call. Used by writers opened with `flags: "w"` to truncate. */
-    _mirrorTruncate(path: string): void;
-    _remoteTruncate(path: string): Promise<void>;
-    _remoteAppend(path: string, line: string): Promise<void>;
-    /** Record a writer's pending promise on the storage-level tail so `drain()` waits for it. */
-    _attachPending(promise: Promise<void>): void;
-}
-declare class RedisSessionStorageWriter implements SessionStorageWriter {
-    #private;
-    constructor(storage: RedisSessionStorage, path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    });
-    writeLineSync(line: string): void;
-    writeLine(line: string): Promise<void>;
-    flush(): Promise<void>;
-    fsync(): Promise<void>;
-    close(): Promise<void>;
-    getError(): Error | undefined;
 }
-export {};

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

@@ -169,8 +169,24 @@ export interface SessionContext {
     /** Mode-specific data from the last mode_change entry */
     modeData?: Record<string, unknown>;
 }
+export declare const EPHEMERAL_MODEL_CHANGE_ROLE = "fallback";
 /** Lists session model strings to try when restoring, in fallback order. */
 export declare function getRestorableSessionModels(models: Readonly<Record<string, string>>, lastModelChangeRole: string | undefined): string[];
+/**
+ * Coarse lifecycle status of a session, derived from its last persisted message.
+ *
+ * - `complete` — the last assistant turn ended with no unanswered tool calls, i.e.
+ *   the agent yielded control back to the user.
+ * - `interrupted` — work was cut off mid-flight: a trailing assistant turn with
+ *   pending tool calls, a trailing tool result the agent never continued from, or
+ *   a length-truncated turn.
+ * - `aborted` — the last assistant turn was cancelled by the user.
+ * - `error` — the last assistant turn ended in an error.
+ * - `pending` — a trailing user message with no assistant reply persisted after it.
+ * - `unknown` — status could not be determined (empty/header-only session, or the
+ *   final message was larger than the tail window that was read).
+ */
+export type SessionStatus = "complete" | "interrupted" | "aborted" | "error" | "pending" | "unknown";
 export interface SessionInfo {
     path: string;
     id: string;
@@ -186,6 +202,11 @@ export interface SessionInfo {
     size: number;
     firstMessage: string;
     allMessagesText: string;
+    /**
+     * Coarse lifecycle status from the session's last persisted message. Optional:
+     * synthesized {@link SessionInfo}s (cross-project stubs, tests) leave it unset.
+     */
+    status?: SessionStatus;
 }
 export type ReadonlySessionManager = Pick<SessionManager, "getCwd" | "getSessionDir" | "getSessionId" | "getSessionFile" | "getSessionName" | "getArtifactsDir" | "getArtifactManager" | "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "getLeafId" | "getLeafEntry" | "getEntry" | "getLabel" | "getBranch" | "getHeader" | "getEntries" | "getTree" | "getUsageStatistics" | "putBlob">;
 /** Exported for testing */

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

@@ -22,12 +22,12 @@ export interface SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(path: string, content: string): void;
-    readTextSync(path: string): string;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
-    readTextPrefix(path: string, maxBytes: number): Promise<string>;
+    /** Read the requested UTF-8 byte windows from the head and tail of the file. */
+    readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
     writeText(path: string, content: string): Promise<void>;
     rename(path: string, nextPath: string): Promise<void>;
     unlink(path: string): Promise<void>;
@@ -41,12 +41,11 @@ export declare class FileSessionStorage implements SessionStorage {
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(fpath: string, content: string): void;
-    readTextSync(fpath: string): string;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
-    readTextPrefix(path: string, maxBytes: number): Promise<string>;
+    readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
     writeText(path: string, content: string): Promise<void>;
     rename(path: string, nextPath: string): Promise<void>;
     unlink(path: string): Promise<void>;
@@ -70,13 +69,12 @@ export declare class MemorySessionStorage implements SessionStorage {
      * creates the entry. External callers should go through `openWriter()`
      * rather than touching the mirror directly.
      */
-    appendChunkSync(path: string, chunk: string): void;
-    readTextSync(path: string): string;
+    appendSync(path: string, chunk: string): void;
     statSync(path: string): SessionStorageStat;
     listFilesSync(dir: string, pattern: string): string[];
     exists(path: string): Promise<boolean>;
     readText(path: string): Promise<string>;
-    readTextPrefix(path: string, maxBytes: number): Promise<string>;
+    readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
     writeText(path: string, content: string): Promise<void>;
     rename(path: string, nextPath: string): Promise<void>;
     unlink(path: string): Promise<void>;

package/dist/types/session/sql-session-storage.d.ts

@@ -1,16 +1,16 @@
-import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+import { IndexedSessionStorage, type SessionStorageBackend } from "./indexed-session-storage";
 /**
  * Supported `bun:sql` adapter dialects. `Bun.SQL` reports this string on
  * `client.options.adapter`; we detect it once at construction and pick the
- * correct DDL / upsert / concat syntax for the underlying engine.
+ * correct DDL / upsert / concat / byte-slice syntax for the underlying engine.
  */
 export type SqlSessionStorageAdapter = "postgres" | "mysql" | "sqlite";
 /**
  * Minimal subset of the `Bun.SQL` instance surface used by
- * {@link SqlSessionStorage}. The real client exposes a callable
- * tagged-template too; we only ever call `unsafe()` so the contract here is
- * narrow — making it trivial to swap in a test double or wrap a pooled
- * client.
+ * {@link SqlSessionStorage}. Bun's SQL client exposes a tagged-template API too,
+ * but this implementation intentionally uses `unsafe(query, values)` because
+ * the table identifier is validated and then inlined while values remain bound
+ * parameters.
  */
 export interface SqlSessionStorageClient {
     unsafe(query: string, values?: unknown[]): Promise<unknown[]>;
@@ -50,92 +50,23 @@ export interface SqlSessionStorageOptions {
 }
 /**
  * SQL-backed implementation of {@link SessionStorage} using `bun:sql`. Each
- * session JSONL file maps to a row keyed by `path`; one table stores
- * everything.
+ * session JSONL file maps to a row keyed by `path`; one table stores the file
+ * contents while this process keeps only a metadata index (`size`, `mtimeMs`) in
+ * memory for synchronous `existsSync` / `statSync` / `listFilesSync` calls.
  *
  * Works against PostgreSQL, MySQL/MariaDB, and SQLite by selecting the
- * dialect-correct DDL, upsert, and string-concat syntax at construction.
- *
- * Trade-offs vs `FileSessionStorage`:
- * - An in-memory mirror is loaded on construction so the interface's
- *   synchronous methods (`existsSync`, `statSync`, `listFilesSync`, …) keep
- *   their contracts; `bun:sql` is async only. Mirror state is process-local,
- *   matching `FileSessionStorage`'s existing single-writer assumption — peer
- *   processes need {@link refresh} to pick up out-of-band writes.
- * - `writeLineSync` updates the mirror synchronously and queues an async
- *   upsert that appends the line to the existing row (or inserts it as the
- *   first chunk). The promise is awaited by `flush()` / `close()` /
- *   {@link drain}. A SIGKILL between the sync mirror update and the network
- *   round-trip loses the last line.
- * - Blobs (image data) and tool artifact files still live on disk via
- *   `BlobStore` / `ArtifactManager`. Those are out of scope for this storage.
+ * dialect-correct DDL, upsert, string-concat, byte-length, and byte-slice syntax
+ * at construction.
  */
-export declare class SqlSessionStorage implements SessionStorage {
+export declare class SqlSessionStorage extends IndexedSessionStorage {
     #private;
-    private constructor();
+    constructor(backend: SessionStorageBackend, adapter: SqlSessionStorageAdapter, table: string);
     /**
-     * Apply the dialect-correct DDL (unless `createTable: false` is set) and
-     * warm the in-memory mirror with every existing row. Must be awaited
-     * before passing the storage into `SessionManager.create()`.
+     * Apply the dialect-correct DDL (unless `createTable: false` is set) and warm
+     * the metadata index with every existing row. Must be awaited before passing
+     * the storage into `SessionManager.create()`.
      */
     static create(options: SqlSessionStorageOptions): Promise<SqlSessionStorage>;
     get adapter(): SqlSessionStorageAdapter;
     get table(): string;
-    /**
-     * Re-load the mirror from the database. Call this from a different
-     * process that took over the table, or after an out-of-band write made
-     * by another agent.
-     */
-    refresh(): Promise<void>;
-    /**
-     * Resolve once every pending background write (issued via `writeTextSync`
-     * or `writer.writeLineSync`) has been acknowledged by the database.
-     * Throws if any background write failed since the last drain. Call on
-     * graceful shutdown to avoid losing the last unflushed line.
-     */
-    drain(): Promise<void>;
-    ensureDirSync(_dir: string): void;
-    existsSync(path: string): boolean;
-    writeTextSync(path: string, content: string): void;
-    readTextSync(path: string): string;
-    statSync(path: string): SessionStorageStat;
-    listFilesSync(dir: string, pattern: string): string[];
-    exists(path: string): Promise<boolean>;
-    readText(path: string): Promise<string>;
-    readTextPrefix(path: string, maxBytes: number): Promise<string>;
-    writeText(path: string, content: string): Promise<void>;
-    rename(src: string, dst: string): Promise<void>;
-    unlink(path: string): Promise<void>;
-    deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
-    openWriter(path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    }): SessionStorageWriter;
-    _writerClosed(writer: SqlSessionStorageWriter): void;
-    _mirrorAppend(path: string, line: string): {
-        content: string;
-        mtimeMs: number;
-    };
-    _mirrorTruncate(path: string): void;
-    _remoteTruncate(path: string): Promise<void>;
-    /**
-     * Append a chunk to the row at `path`, inserting if the row doesn't
-     * exist yet. Single round-trip via the dialect-specific `upsertAppend`.
-     */
-    _remoteAppend(path: string, line: string, mtimeMs: number): Promise<void>;
-    _attachPending(promise: Promise<void>): void;
-}
-declare class SqlSessionStorageWriter implements SessionStorageWriter {
-    #private;
-    constructor(storage: SqlSessionStorage, path: string, options?: {
-        flags?: "a" | "w";
-        onError?: (err: Error) => void;
-    });
-    writeLineSync(line: string): void;
-    writeLine(line: string): Promise<void>;
-    flush(): Promise<void>;
-    fsync(): Promise<void>;
-    close(): Promise<void>;
-    getError(): Error | undefined;
 }
-export {};

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

@@ -27,7 +27,11 @@ export interface ParsedSlashCommand {
 /**
  * Result returned by a slash-command handler.
  *
- * - `void` / `undefined` — command was handled and consumed; no further input.
+ * - `undefined` (and the implicit `void` return) — command was handled and
+ *   consumed; no further input. Handlers may simply omit a `return` rather than
+ *   building `{ consumed: true }`; `void` is accepted in the handler signatures
+ *   below so the contract typechecks under TypeScript 5.x (which does not
+ *   coerce `() => void` to `() => T | undefined`) as well as 6.x / tsgo.
  * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
  * - `{ prompt: string }` — command handled, pass `prompt` through as the new
  *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
@@ -97,14 +101,23 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
     /**
      * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
      * and, via the TUI adapter, when no `handleTui` override is provided.
+     *
+     * Expressed as a union of two function types — one returning a
+     * `SlashCommandResult`, one returning `void` — so handlers that simply
+     * `return` (or omit the return) typecheck under TypeScript 5.x as well as
+     * 6.x / tsgo. TS 5.x does not coerce a `() => void` value into a
+     * `() => T | undefined` slot, so the two return shapes must be siblings
+     * rather than a `T | void` union inside one function type (which Biome's
+     * `noConfusingVoidType` also rejects).
      */
-    handle?: (command: ParsedSlashCommand, runtime: SlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+    handle?: ((command: ParsedSlashCommand, runtime: SlashCommandRuntime) => SlashCommandResult | Promise<SlashCommandResult>) | ((command: ParsedSlashCommand, runtime: SlashCommandRuntime) => void | Promise<void>);
     /**
      * TUI-only handler that supersedes `handle` when both are present. Use for
      * selectors, wizards, dashboards, and anything else that requires
-     * `InteractiveModeContext`.
+     * `InteractiveModeContext`. See `handle` for the rationale behind the
+     * function-type union shape.
      */
-    handleTui?: (command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => Promise<SlashCommandResult> | SlashCommandResult;
+    handleTui?: ((command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => SlashCommandResult | Promise<SlashCommandResult>) | ((command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => void | Promise<void>);
 }
 /** Result returned by `executeAcpBuiltinSlashCommand`. */
 export type AcpBuiltinSlashCommandResult = false | {

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

@@ -26,6 +26,15 @@ export interface ExecutorOptions {
     task: string;
     assignment?: string;
     context?: string;
+    /**
+     * The session's active overall plan, handed off so subagents spawned during
+     * plan execution share the same plan context as the main agent. Omitted when
+     * the session did not start with a plan (or while plan mode is still active).
+     */
+    planReference?: {
+        path: string;
+        content: string;
+    };
     description?: string;
     index: number;
     id: string;

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 TaskToolDetails, type TaskToolSchemaInstance } from "./types";
+import { type AgentDefinition, type TaskToolDetails, type TaskToolSchemaInstance } from "./types";
 import "../tools/review";
 import { renderResult, renderCall as renderTaskCall } from "./render";
 export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
@@ -10,6 +10,8 @@ export { discoverAgents, getAgent } from "./discovery";
 export { AgentOutputManager } from "./output-manager";
 export type { AgentDefinition, AgentProgress, SingleResult, 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;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *

package/dist/types/telemetry-export.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Whether {@link initTelemetryExport} registered a real provider. The CLI uses
+ * this to decide whether to switch on the agent loop's telemetry config — there
+ * is no point emitting spans into a no-op tracer.
+ */
+export declare function isTelemetryExportEnabled(): boolean;
+/**
+ * Register the global TracerProvider + OTLP exporter when an OTLP endpoint is
+ * configured via env. Idempotent, and a no-op when no endpoint is set (or when
+ * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
+ * startup.
+ */
+export declare function initTelemetryExport(): void;
+/**
+ * Flush any buffered spans to the exporter. No-op when export is disabled.
+ * Hosts embedding the agent can call this at natural boundaries (e.g. the end
+ * of a turn) so traces surface promptly rather than on the batch interval.
+ */
+export declare function flushTelemetryExport(): Promise<void>;

package/dist/types/tiny/compiled-runtime.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Walk a conditional `exports` target (string, array of fallbacks, or a
+ * condition object) and return the first relative path that matches a runtime
+ * condition in declaration order. Returns `null` when nothing applies (e.g.
+ * `import`-only targets).
+ */
+export declare function selectConditionalTarget(target: unknown): string | null;
+/**
+ * Split a bare specifier into its package name and optional subpath, handling
+ * scoped packages (`@scope/name/sub` → `@scope/name` + `sub`).
+ */
+export declare function splitBareSpecifier(specifier: string): {
+    packageName: string;
+    subpath: string | undefined;
+};
+/**
+ * Resolve a bare specifier against an installed `node_modules` directory,
+ * honoring `exports` (CommonJS conditions), then `main`, then `index.js`.
+ * Returns an absolute file path, or `null` when the package/entry is absent.
+ */
+export declare function resolveRuntimeModule(runtimeNodeModules: string, specifier: string): string | null;
+interface ResolverOptions {
+    /** Absolute path to the runtime cache's `node_modules`. */
+    runtimeNodeModules: string;
+    /** Bare specifier → absolute file path overrides (e.g. `sharp` → no-op stub). */
+    stubs?: Record<string, string>;
+}
+/**
+ * Patch `node:module`'s resolver (idempotently) so bare specifiers that the
+ * stock compiled-binary resolver cannot find fall back to the runtime cache.
+ * Stock resolution is tried first, so this never changes behavior for modules
+ * that already resolve (the worker's own bundled imports, node builtins).
+ */
+export declare function installRuntimeModuleResolver({ runtimeNodeModules, stubs }: ResolverOptions): void;
+export {};

package/dist/types/tiny/text.d.ts

@@ -16,4 +16,21 @@ export declare function stripCodeBlocks(message: string): string;
 /** Prepare a raw user message for titling: drop code blocks, then bound length. */
 export declare function prepareTitleInput(message: string): string;
 export declare function formatTitleUserMessage(message: string): string;
+/**
+ * True when a first user message is too low-signal to title (greeting, ack,
+ * bare number, or empty once code/punctuation/emoji are stripped).
+ *
+ * Deterministic pre-filter: the default tiny title model (~350M local) cannot
+ * reliably follow a "respond with none" instruction and tends to hallucinate a
+ * title for trivial input, so we never ask it — the caller defers titling to
+ * the next message instead.
+ */
+export declare function isLowSignalTitleInput(message: string): boolean;
+/**
+ * Sentinel a capable title model may emit when a message carries no concrete
+ * task. Treated as "no title yet" so the caller can defer titling. Backstop for
+ * the deterministic {@link isLowSignalTitleInput} filter; kept in sync with the
+ * `none` instruction in `prompts/system/title-system.md`.
+ */
+export declare const NO_TITLE_SENTINEL = "none";
 export declare function normalizeGeneratedTitle(value: string | null | undefined): string | null;

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

@@ -100,6 +100,7 @@ interface AskRenderArgs {
     }>;
 }
 export declare const askToolRenderer: {
+    mergeCallAndResult: boolean;
     renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{

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

@@ -20,7 +20,7 @@ import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-disc
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
 import { type CheckpointState } from "./checkpoint";
-import { type TodoPhase } from "./todo-write";
+import { type TodoPhase } from "./todo";
 export * from "../edit";
 export * from "../exa";
 export type * from "../exa/types";
@@ -56,7 +56,7 @@ export * from "./review";
 export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./ssh";
-export * from "./todo-write";
+export * from "./todo";
 export * from "./tts";
 export * from "./write";
 export * from "./yield";
@@ -147,6 +147,8 @@ export interface ToolSession {
     settings: Settings;
     /** Plan mode state (if active) */
     getPlanModeState?: () => PlanModeState | undefined;
+    /** Path of the session's active plan reference (e.g. `local://<title>.md`); defaults to `local://PLAN.md`. */
+    getPlanReferencePath?: () => string;
     /** Goal mode state (if active or paused) */
     getGoalModeState?: () => GoalModeState | undefined;
     /** Goal runtime for the active agent session. */

package/dist/types/tools/path-utils.d.ts

@@ -9,7 +9,7 @@ export interface LineRange {
     startLine: number;
     endLine: number | undefined;
 }
-/** Parse a single `N`, `N-M`, `N-`, or `N+K` chunk. Throws via {@link ToolError} on invalid bounds. */
+/** Parse a single `N`, `N-M`, `N-`, `N+K`, or `..`-aliased (`N..M`, `N..`) chunk. Throws via {@link ToolError} on invalid bounds. */
 export declare function parseLineRangeChunk(sel: string): LineRange | null;
 /**
  * Parse a comma-separated list of line ranges (e.g. `5-16,960-973`). Returns

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

@@ -8,7 +8,7 @@ import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 declare const searchSchema: z.ZodObject<{
     pattern: z.ZodString;
-    paths: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     i: z.ZodOptional<z.ZodBoolean>;
     gitignore: z.ZodOptional<z.ZodBoolean>;
     skip: z.ZodOptional<z.ZodNumber>;
@@ -63,7 +63,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
     readonly description: string;
     readonly parameters: z.ZodObject<{
         pattern: z.ZodString;
-        paths: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
         i: z.ZodOptional<z.ZodBoolean>;
         gitignore: z.ZodOptional<z.ZodBoolean>;
         skip: z.ZodOptional<z.ZodNumber>;

package/dist/types/tools/{todo-write.d.ts → todo.d.ts}

@@ -25,12 +25,12 @@ export interface TodoCompletionTransition {
     phase: string;
     content: string;
 }
-export interface TodoWriteToolDetails {
+export interface TodoToolDetails {
     phases: TodoPhase[];
     storage: "session" | "memory";
     completedTasks?: TodoCompletionTransition[];
 }
-declare const todoWriteSchema: z.ZodObject<{
+declare const todoSchema: z.ZodObject<{
     ops: z.ZodArray<z.ZodObject<{
         op: z.ZodEnum<{
             append: "append";
@@ -51,7 +51,7 @@ declare const todoWriteSchema: z.ZodObject<{
         text: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type TodoWriteParams = z.infer<typeof todoWriteSchema>;
+type TodoParams = z.infer<typeof todoSchema>;
 export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
 export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[];
 /**
@@ -62,7 +62,7 @@ export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]):
  * the caller can render a `+N more` hint. When every task in `tasks` is
  * closed (completed or abandoned), returns the trailing `maxVisible` tasks
  * with `hiddenOpenCount = 0`, so the panel keeps useful context until the
- * active-phase pointer advances on the next `todo_write`.
+ * active-phase pointer advances on the next `todo`.
  *
  * Task identity and order are preserved — this is a slice, never a sort.
  */
@@ -84,8 +84,8 @@ export declare function selectStickyTodoWindow(tasks: TodoItem[], maxVisible?: n
  * the contained side.
  */
 export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
-/** Apply an array of `todo_write`-style ops to existing phases. Used by /todo slash command. */
-export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoWriteParams["ops"]): {
+/** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
+export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams["ops"]): {
     phases: TodoPhase[];
     errors: string[];
 };
@@ -96,11 +96,11 @@ export declare function markdownToPhases(md: string): {
     phases: TodoPhase[];
     errors: string[];
 };
-export declare class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
+export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
     private readonly session;
-    readonly name = "todo_write";
+    readonly name = "todo";
     readonly approval: "read";
-    readonly label = "Todo Write";
+    readonly label = "Todo";
     readonly summary = "Write a structured todo list to track progress within a session";
     readonly description: string;
     readonly parameters: z.ZodObject<{
@@ -128,9 +128,9 @@ export declare class TodoWriteTool implements AgentTool<typeof todoWriteSchema,
     readonly strict = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    execute(_toolCallId: string, params: TodoWriteParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TodoWriteToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TodoWriteToolDetails>>;
+    execute(_toolCallId: string, params: TodoParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TodoToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TodoToolDetails>>;
 }
-type TodoWriteRenderArgs = {
+type TodoRenderArgs = {
     ops?: Array<{
         op?: string;
         task?: string;
@@ -142,18 +142,18 @@ type TodoWriteRenderArgs = {
 export declare function phaseRomanNumeral(oneBasedIndex: number): string;
 /** Display-only phase header: `I. Foundation`. State and prompts never see this. */
 export declare function formatPhaseDisplayName(name: string, oneBasedIndex: number): string;
-export declare const TODO_WRITE_STRIKE_HOLD_FRAMES = 2;
-export declare const TODO_WRITE_STRIKE_REVEAL_FRAMES = 12;
-export declare const TODO_WRITE_STRIKE_TOTAL_FRAMES: number;
-export declare const todoWriteToolRenderer: {
-    renderCall(args: TodoWriteRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+export declare const TODO_STRIKE_HOLD_FRAMES = 2;
+export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
+export declare const TODO_STRIKE_TOTAL_FRAMES: number;
+export declare const todoToolRenderer: {
+    renderCall(args: TodoRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
-        details?: TodoWriteToolDetails;
-    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoWriteRenderArgs): Component;
+        details?: TodoToolDetails;
+    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoRenderArgs): Component;
     mergeCallAndResult: boolean;
 };
 export {};