@oh-my-pi/pi-coding-agent 16.1.23 → 16.2.1

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

@@ -48,7 +48,7 @@ import type { ClientBridge } from "./client-bridge";
 import { type CustomMessage } from "./messages";
 import type { BuildSessionContextOptions, SessionContext } from "./session-context";
 import type { BranchSummaryEntry, NewSessionOptions } from "./session-entries";
-import type { SessionManager } from "./session-manager";
+import { type SessionManager } from "./session-manager";
 import type { ShakeMode, ShakeResult } from "./shake-types";
 import { ToolChoiceQueue } from "./tool-choice-queue";
 import { YieldQueue } from "./yield-queue";
@@ -239,6 +239,12 @@ export interface AgentSessionConfig {
     advisorReadOnlyTools?: AgentTool[];
     /** Preloaded watchdog prompt content for the advisor. */
     advisorWatchdogPrompt?: string;
+    /**
+     * Preloaded project context files (AGENTS.md, etc.) rendered as a system-prompt
+     * block for the advisor — the same standing instructions the primary agent
+     * receives, so the reviewer holds the agent to them.
+     */
+    advisorContextPrompt?: string;
     /**
      * Strip tool descriptions from provider-bound tool specs on side requests
      * (handoff). Must match the session-start value used to build the system
@@ -459,6 +465,7 @@ export declare class AgentSession {
     /** True once dispose() has begun; deferred background work (e.g. the deferred
      *  MCP discovery task in sdk.ts) must not touch the session past this point. */
     get isDisposed(): boolean;
+    markMovedFromEmptySessionFile(sessionFile: string): void;
     /**
      * Synchronously mark the session as disposing so new work is rejected
      * immediately: eval starts throw, queued asides are dropped, and the

package/dist/types/session/blob-store.d.ts

@@ -27,6 +27,8 @@ export declare class BlobStore {
     putSync(data: Buffer, options?: BlobPutOptions): BlobPutResult;
     /** Read blob by hash, returns Buffer or null if not found. */
     get(hash: string): Promise<Buffer | null>;
+    /** Synchronous variant of {@link get}. */
+    getSync(hash: string): Buffer | null;
     /** Check if a blob exists. */
     has(hash: string): Promise<boolean>;
 }
@@ -62,3 +64,5 @@ export declare function resolveImageDataUrl(blobStore: BlobStore, data: string):
  * If the blob is missing, logs a warning and returns a placeholder.
  */
 export declare function resolveImageData(blobStore: BlobStore, data: string): Promise<string>;
+/** Synchronous variant of {@link resolveImageData}. */
+export declare function resolveImageDataSync(blobStore: BlobStore, data: string): string;

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

@@ -237,6 +237,14 @@ export declare class SessionManager {
      * @param sessionDir Optional session directory; defaults to the cwd-derived dir.
      */
     static create(cwd: string, sessionDir?: string, storage?: SessionStorage): SessionManager;
+    /**
+     * Create a fresh empty session file in the default session directory for
+     * `cwd`, writing only the session header. The returned path can be passed to
+     * `setSessionFile` / `AgentSession.switchSession` to start a new empty
+     * session in that directory. Used by `/move` to switch projects without
+     * dragging the current conversation along.
+     */
+    static createEmptySessionFile(cwd: string, storage?: SessionStorage): string;
     /**
      * Fork a session into the current project directory: copy history from another
      * session file while creating a fresh session file in this sessionDir.
@@ -290,4 +298,9 @@ export declare class SessionManager {
     /** List all sessions across all project directories. */
     static listAll(storage?: SessionStorage): Promise<SessionInfo[]>;
 }
+/**
+ * If the current session was created by `/move` and contains no real
+ * user/assistant messages, delete it so empty move sessions don't accumulate.
+ */
+export declare function cleanupEmptyMoveSession(sessionManager: SessionManager, movedFromEmptySessionFile: string | undefined): Promise<void>;
 export {};

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

@@ -4,7 +4,7 @@ export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
 export interface TuiBuiltinSlashCommand extends BuiltinSlashCommand {
-    getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null;
+    getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null | Promise<AutocompleteItem[] | null>;
     getInlineHint?: (argumentText: string) => string | null;
     getAutocompleteDescription?: () => string | undefined;
 }

package/dist/types/ssh/__tests__/connection-manager-args.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/ssh/__tests__/file-transfer-posix-guard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/ssh/connection-manager.d.ts

@@ -19,6 +19,8 @@ export interface SSHHostInfo {
 }
 interface SSHArgsOptions {
     platform?: SshPlatform;
+    /** When true, omit `-n` so the remote command can read from our piped stdin. */
+    allowStdin?: boolean;
 }
 export declare function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined>;
 export declare function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined>;

package/dist/types/ssh/file-transfer.d.ts

@@ -0,0 +1,79 @@
+import { type SSHConnectionTarget } from "./connection-manager";
+export interface RemoteFileReadOptions {
+    /** Maximum bytes to materialize; the helper fetches one extra byte to detect truncation. */
+    maxBytes: number;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface RemoteFileReadResult {
+    /** Raw file bytes, capped at `maxBytes`. */
+    bytes: Uint8Array;
+    /** True when the remote file was larger than `maxBytes` (`bytes` is the prefix). */
+    truncated: boolean;
+}
+export interface RemoteFileWriteOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/**
+ * Read a remote file's raw bytes. Fetches `maxBytes + 1` so the caller can
+ * distinguish an exactly-`maxBytes` file from a larger (truncated) one.
+ *
+ * Throws `ptree.NonZeroExitError` (carrying the remote stderr tail) when the
+ * file is missing/unreadable or the host is unreachable.
+ */
+export declare function readRemoteFile(target: SSHConnectionTarget, remotePath: string, opts: RemoteFileReadOptions): Promise<RemoteFileReadResult>;
+/**
+ * Write `content` to a remote file byte-exact. Stdin is always staged first into
+ * a uniquely named temp in the destination directory (so the remote never blocks
+ * on an unread pipe and a dropped connection lands in the temp, never the
+ * destination). The destination then dictates the commit:
+ *  - a directory — or a symlink to one, since the `-d` test follows links — is
+ *    refused (a plain `mv tmp dir` would move the temp INTO it).
+ *  - an existing non-symlink regular file is rewritten IN PLACE from the staged
+ *    temp, preserving its inode and therefore its ordinary permission bits (a
+ *    `0600` secret stays `0600` on overwrite), ACLs, xattrs, and hardlinks. The
+ *    setuid/setgid bits may be cleared by the write (per POSIX). This commit is
+ *    not fully atomic — a remote-side failure during the local temp->dest copy
+ *    (e.g. the disk filling) can truncate the destination — but the slow network
+ *    transfer has already landed in the temp, and the temp is removed on failure.
+ *    It also needs write permission on the file itself (a read-only file is
+ *    refused, not silently replaced).
+ *  - an existing special file (FIFO/socket/device) is refused, not replaced.
+ *  - anything else (a new path, a symlink to a non-directory, a dangling symlink)
+ *    is committed with an atomic rename, which REPLACES a symlink with a regular
+ *    file rather than writing through it (resolving the link target is not
+ *    portable across the macOS/Linux hosts this stack supports).
+ * Throws `ptree.NonZeroExitError` when the remote path is unwritable or the host
+ * is unreachable.
+ */
+export declare function writeRemoteFile(target: SSHConnectionTarget, remotePath: string, content: Uint8Array, opts: RemoteFileWriteOptions): Promise<void>;
+/** Classification of a remote path, used by the read handler's directory dispatch. */
+export type RemotePathKind = "file" | "directory" | "other" | "missing";
+/**
+ * Classify a remote path with POSIX `test` (portable across Linux/BSD/macOS):
+ * `directory`, regular `file`, `other` (special file), or `missing`.
+ */
+export declare function statRemotePath(target: SSHConnectionTarget, remotePath: string, opts?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<RemotePathKind>;
+/** A single entry in a remote directory listing. */
+export interface RemoteDirEntry {
+    /** Entry name (no path component), trailing `/` stripped. */
+    name: string;
+    /** True when the entry is a directory. */
+    isDirectory: boolean;
+}
+/**
+ * List a remote directory one level deep with `ls -1Ap` (one per line; all
+ * entries incl. dotfiles but not `.`/`..`; trailing `/` marks directories).
+ * Plain `ls` (no `| head`) so a permission/race failure surfaces as a non-zero
+ * exit instead of being masked as an empty listing. Entries are returned in
+ * full, sorted directories-first then by name to mirror the local
+ * directory-resource contract, so the read tool can paginate the listing.
+ */
+export declare function listRemoteDir(target: SSHConnectionTarget, remotePath: string, opts?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<RemoteDirEntry[]>;

package/dist/types/ssh/utils.d.ts

@@ -1,2 +1,8 @@
 export declare function sanitizeHostName(name: string): string;
 export declare function buildSshTarget(username: string | undefined, host: string): string;
+/**
+ * Single-quote a path for a POSIX remote shell, escaping embedded single quotes.
+ * Mirrors the private `quoteRemotePath` in `tools/ssh.ts`; shared here for the
+ * `ssh://` file-transfer helpers.
+ */
+export declare function quotePosixPath(value: string): string;

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

@@ -5,6 +5,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample, TSchema } from "@oh-my-pi/pi-ai";
 import type { Personality, SkillsSettings } from "./config/settings";
 import { type Skill } from "./extensibility/skills";
+import { type ActiveRepoContext } from "./utils/active-repo-context";
 import { type WorkspaceTree } from "./workspace-tree";
 interface AlwaysApplyRule {
     name: string;
@@ -114,6 +115,8 @@ export interface BuildSystemPromptOptions {
     includeWorkspaceTree?: boolean;
     /** Whether Mermaid fenced blocks render as terminal ASCII diagrams. Default: true */
     renderMermaid?: boolean;
+    /** Pre-resolved nested active repo context. Undefined resolves from cwd. */
+    activeRepoContext?: ActiveRepoContext | null;
 }
 /** Result of building provider-facing system prompt messages. */
 export interface BuildSystemPromptResult {

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

@@ -17,6 +17,7 @@ import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
 import type { MCPManager } from "../mcp/manager";
 import type { MnemopiSessionState } from "../mnemopi/state";
+import type { AgentSession } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
 import type { ContextFileEntry } from "../tools";
@@ -156,6 +157,12 @@ export interface ExecutorOptions {
      * passes its own `getAgentId()`).
      */
     parentAgentId?: string;
+    /**
+     * Keep the finished subagent addressable in the registry for IRC/revival.
+     * Defaults to true. Eval bridge agents are programmatic one-shot helpers and
+     * set this false so disposal unregisters them instead of leaving idle peers.
+     */
+    keepAlive?: boolean;
 }
 export interface YieldItem {
     data?: unknown;
@@ -197,6 +204,15 @@ export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputA
  */
 export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
 export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTier | null): Settings;
+export declare function finalizeSubagentLifecycle(args: {
+    id: string;
+    session: AgentSession;
+    aborted: boolean;
+    keepAlive: boolean;
+    isolated: boolean;
+    agentIdleTtlMs: number;
+    reviveSession: (() => Promise<AgentSession>) | null;
+}): Promise<void>;
 /**
  * Run a single agent in-process.
  */

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

@@ -33,4 +33,4 @@ export declare function isLowSignalTitleInput(message: string): boolean;
  * `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;
+export declare function normalizeGeneratedTitle(value: string | null | undefined, sourceText?: string): string | null;

package/dist/types/tools/builtin-names.d.ts

@@ -1,2 +1,6 @@
-export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "find", "search", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "job", "irc", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
+export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "ssh", "github", "glob", "grep", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "job", "irc", "todo", "web_search", "search_tool_bm25", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
+/** Return the canonical tool name for current and legacy built-in tool IDs. */
+export declare function normalizeToolName(name: string): string;
+/** Normalize and deduplicate tool names while preserving first-seen order. */
+export declare function normalizeToolNames(names: Iterable<string>): string[];

package/dist/types/tools/{find.d.ts → glob.d.ts}

@@ -12,8 +12,8 @@ declare const findSchema: import("arktype/internal/variants/object.ts").ObjectTy
     gitignore?: boolean | undefined;
     limit?: number | undefined;
 }, {}>;
-export type FindToolInput = typeof findSchema.infer;
-export interface FindToolDetails {
+export type GlobToolInput = typeof findSchema.infer;
+export interface GlobToolDetails {
     truncation?: TruncationResult;
     resultLimitReached?: number;
     meta?: OutputMeta;
@@ -34,7 +34,7 @@ export interface FindToolDetails {
  * Pluggable operations for the find tool.
  * Override these to delegate file search to remote systems (e.g., SSH).
  */
-export interface FindOperations {
+export interface GlobOperations {
     /** Check if path exists */
     exists: (absolutePath: string) => Promise<boolean> | boolean;
     /** Optional stat for distinguishing files vs directories. */
@@ -51,17 +51,17 @@ export interface FindOperations {
         limit: number;
     }) => Promise<string[]> | string[];
 }
-export interface FindToolOptions {
+export interface GlobToolOptions {
     /** Custom operations for find. Default: local filesystem + rg */
-    operations?: FindOperations;
+    operations?: GlobOperations;
 }
-export declare class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
+export declare class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
     #private;
     private readonly session;
-    readonly name = "find";
+    readonly name = "glob";
     readonly approval: "read";
     readonly loadMode = "essential";
-    readonly label = "Find";
+    readonly label = "Glob";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         paths: string[];
@@ -71,24 +71,24 @@ export declare class FindTool implements AgentTool<typeof findSchema, FindToolDe
     }, {}>;
     readonly examples: readonly ToolExample<typeof findSchema.infer>[];
     readonly strict = true;
-    constructor(session: ToolSession, options?: FindToolOptions);
-    execute(_toolCallId: string, params: typeof findSchema.infer, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<FindToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<FindToolDetails>>;
+    constructor(session: ToolSession, options?: GlobToolOptions);
+    execute(_toolCallId: string, params: typeof findSchema.infer, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<GlobToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<GlobToolDetails>>;
 }
-interface FindRenderArgs {
+interface GlobRenderArgs {
     paths?: string | string[];
     limit?: number;
 }
-export declare const findToolRenderer: {
+export declare const globToolRenderer: {
     inline: boolean;
-    renderCall(args: FindRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderCall(args: GlobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
-        details?: FindToolDetails;
+        details?: GlobToolDetails;
         isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme, args?: FindRenderArgs): Component;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GlobRenderArgs): Component;
     mergeCallAndResult: boolean;
 };
 export {};

package/dist/types/tools/{search.d.ts → grep.d.ts}

@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
@@ -12,7 +12,7 @@ declare const searchSchema: import("arktype/internal/variants/object.ts").Object
     gitignore?: boolean | undefined;
     skip?: number | null | undefined;
 }, {}>;
-export type SearchToolInput = typeof searchSchema.infer;
+export type GrepToolInput = typeof searchSchema.infer;
 export declare function toPathList(input: string | string[] | undefined): string[];
 /** Maximum number of distinct files surfaced in a single response. The
  * agent paginates further pages via `skip`. */
@@ -23,7 +23,7 @@ export declare const MULTI_FILE_PER_FILE_MATCHES = 20;
 /** Per-file match cap for single-file searches — there's no diversity
  * concern when the scope is one file. */
 export declare const SINGLE_FILE_MATCHES = 200;
-export interface SearchToolDetails {
+export interface GrepToolDetails {
     truncation?: TruncationResult;
     fileLimitReached?: number;
     perFileLimitReached?: number;
@@ -56,13 +56,13 @@ export interface SearchToolDetails {
     missingPaths?: string[];
 }
 type SearchParams = typeof searchSchema.infer;
-export declare class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
+export declare class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails> {
     private readonly session;
-    readonly name = "search";
-    readonly approval: "read";
-    readonly label = "Search";
+    readonly name = "grep";
+    readonly approval: (args: unknown) => ToolTier;
+    readonly label = "Grep";
     readonly loadMode = "discoverable";
-    readonly summary = "Search file contents using ripgrep (fast text search)";
+    readonly summary = "Grep file contents using ripgrep (fast regex search)";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         pattern: string;
@@ -73,26 +73,26 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
     }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
-    execute(_toolCallId: string, params: SearchParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<SearchToolDetails>>;
+    execute(_toolCallId: string, params: SearchParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<GrepToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<GrepToolDetails>>;
 }
-interface SearchRenderArgs {
+interface GrepRenderArgs {
     pattern: string;
     paths?: string | string[];
     case?: boolean;
     gitignore?: boolean;
     skip?: number;
 }
-export declare const searchToolRenderer: {
+export declare const grepToolRenderer: {
     inline: boolean;
-    renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderCall(args: GrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {
         content: Array<{
             type: string;
             text?: string;
         }>;
-        details?: SearchToolDetails;
+        details?: GrepToolDetails;
         isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme, args?: SearchRenderArgs): Component;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GrepRenderArgs): Component;
     mergeCallAndResult: boolean;
 };
 export {};

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

@@ -23,7 +23,7 @@ import type { AgentOutputManager } from "../task/output-manager";
 import type { DiscoverableTool, DiscoverableToolSearchIndex } from "../tool-discovery/tool-index";
 import type { EventBus } from "../utils/event-bus";
 import type { WorkspaceTree } from "../workspace-tree";
-import type { BuiltinToolName } from "./builtin-names";
+import { type BuiltinToolName } from "./builtin-names";
 import { type CheckpointState } from "./checkpoint";
 import { type TodoPhase } from "./todo";
 export * from "../edit";
@@ -41,8 +41,9 @@ export * from "./checkpoint";
 export * from "./debug";
 export * from "./eval";
 export * from "./eval-backends";
-export * from "./find";
 export * from "./gh";
+export * from "./glob";
+export * from "./grep";
 export * from "./image-gen";
 export * from "./inspect-image";
 export * from "./irc";
@@ -57,7 +58,6 @@ export * from "./read";
 export * from "./report-tool-issue";
 export * from "./resolve";
 export * from "./review";
-export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./ssh";
 export * from "./todo";

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

@@ -58,8 +58,37 @@ export declare function splitInternalUrlSel(rawPath: string): {
     path: string;
     sel?: string;
 };
+/**
+ * Peel a read-tool selector off an internal-URL write target so `write` resolves
+ * the same file `read` does (e.g. `ssh://h/f:raw` -> `ssh://h/f`). Only the
+ * whole-file display modes `raw`/`conflicts` are accepted (they do not change
+ * which bytes are written); any other selector-shaped tail `splitInternalUrlSel`
+ * peels — a line range, a compound like `raw:1-20`, or a malformed `:-N` — throws,
+ * because `write` addresses a whole file, not a partial range, and silently
+ * stripping it would write to a path the caller never named. Non-URL paths and
+ * URLs without a selector pass through unchanged.
+ */
+export declare function peelWriteUrlSelector(rawPath: string): string;
 export declare function normalizeLocalScheme(filePath: string): string;
 export declare function isInternalUrlPath(filePath: string): boolean;
+/**
+ * True when a tool path argument references the `ssh://` scheme anywhere.
+ *
+ * Substring (not anchored) on purpose: it feeds the read/search/write approval
+ * tier, which runs synchronously on the raw args. `search` only flattens a
+ * delimited `paths: "a,ssh://h/x"` into separate entries *after* approval, so an
+ * anchored check would let an embedded `ssh://` slip through at the read tier.
+ * Matching the literal `ssh://` substring also tracks exactly what routes to the
+ * SSH handler; over-matching only over-prompts (fail-closed).
+ */
+export declare function pathTargetsSsh(path: string): boolean;
+/**
+ * True when a path is specifically an `ssh://` URL (anchored scheme match).
+ * Unlike {@link pathTargetsSsh} (substring, for the pre-expansion approval
+ * scan), this is the exact per-entry check used to reject `ssh://` *before* a
+ * side-effecting `InternalUrlRouter.resolve` in tools that need a local file.
+ */
+export declare function isSshUrl(path: string): boolean;
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.

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

@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
@@ -53,7 +53,7 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     #private;
     private readonly session;
     readonly name = "read";
-    readonly approval: "read";
+    readonly approval: (args: unknown) => ToolTier;
     readonly label = "Read";
     readonly loadMode = "essential";
     readonly description: string;

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

@@ -52,6 +52,14 @@ export declare function expandKeyHint(): string;
  * Get first N lines of text as preview, with each line truncated.
  */
 export declare function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[];
+/**
+ * Collapse a possibly multi-line string into a single line, then truncate it to
+ * `maxWidth` display cells. {@link truncateToWidth} alone caps width but
+ * newlines are zero-width, so multi-line content (markdown briefs, tool args,
+ * provider errors) would otherwise spill a single status row across several
+ * visual lines. Whitespace runs collapse to one space, so tabs are handled too.
+ */
+export declare function previewLine(text: string, maxWidth: number, ellipsis?: Ellipsis): string;
 /**
  * Extract domain from URL, stripping www. prefix.
  */

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

@@ -30,5 +30,16 @@ export type ToolRenderer = {
      * streams rows the result render preserves.
      */
     provisionalPendingPreview?: boolean | "collapsed";
+    /**
+     * Whether the partial-result render is provisional: chrome rows (header
+     * glyph, frame state) that change between `options.isPartial === true` and
+     * the final result render. When `true`, the block is treated as
+     * commit-unstable while a partial result is in flight, so the
+     * stable-prefix ratchet in `deriveLiveCommitState` cannot promote the
+     * partial chrome to native scrollback only to have the final render strand
+     * it above the settled frame. Absent = the partial render is byte-stable
+     * with the final render and may commit like any settled stream.
+     */
+    provisionalPartialResult?: boolean;
 };
 export declare const toolRenderers: Record<string, ToolRenderer>;

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

@@ -62,10 +62,12 @@ export declare const sshToolRenderer: {
             text?: string;
         }>;
         details?: SSHToolDetails;
+        isError?: boolean;
     }, options: RenderResultOptions & {
         renderContext?: SshRenderContext;
     }, uiTheme: Theme, args?: SshRenderArgs): Component;
     mergeCallAndResult: boolean;
     provisionalPendingPreview: string;
+    provisionalPartialResult: boolean;
 };
 export {};

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

@@ -37,22 +37,6 @@ type TodoParams = TodoSchema;
 type TodoSchema = typeof todoSchema.infer;
 export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
 export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[];
-/**
- * Pick the actionable window of tasks to display in the sticky todo panel.
- *
- * Returns up to `maxVisible` open (pending / in_progress) tasks in their
- * original phase order, plus the count of remaining open tasks not shown so
- * 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`.
- *
- * Task identity and order are preserved — this is a slice, never a sort.
- */
-export declare function selectStickyTodoWindow(tasks: TodoItem[], maxVisible?: number): {
-    visible: TodoItem[];
-    hiddenOpenCount: number;
-};
 /**
  * Report whether `content` likely names the same work as any entry in
  * `descriptions`. Used by the sticky todo panel to light up a pending todo

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

@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type FileDiagnosticsResult } from "../lsp";
@@ -30,7 +30,7 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
     #private;
     private readonly session;
     readonly name = "write";
-    readonly approval: (args: unknown) => "read" | "write";
+    readonly approval: (args: unknown) => ToolTier;
     readonly formatApprovalDetails: (args: unknown) => string[];
     readonly label = "Write";
     readonly description: string;

package/dist/types/utils/active-repo-context.d.ts

@@ -0,0 +1,8 @@
+export interface ActiveRepoContext {
+    cwd: string;
+    repoRoot: string;
+    relativeRepoRoot: string;
+    source: "single-direct-child-repo";
+}
+export declare function resolveActiveRepoContext(cwd: string): Promise<ActiveRepoContext | null>;
+export declare function resolveActiveRepoContextSync(cwd: string): ActiveRepoContext | null;

package/dist/types/utils/image-resize.d.ts

@@ -16,6 +16,7 @@ export interface ResizedImage {
     width: number;
     height: number;
     wasResized: boolean;
+    decodeFailed?: boolean;
     get data(): string;
 }
 /**

package/dist/types/utils/markit-cache.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cache schema/format revision. Bumping it changes the on-disk key prefix
+ * (`v<N>-...`), so old entries become unreachable and are pruned naturally.
+ * Bump when the cache *file* shape changes (entry JSON layout, key scheme).
+ *
+ * Converter *output* changes are handled separately: the package version is
+ * folded into the key (see {@link markitConversionCacheKey}), so any release
+ * that ships new markdown from `src/markit/converters/*` auto-invalidates the
+ * cache without a manual bump here.
+ */
+export declare const MARKIT_CONVERSION_CACHE_VERSION = 1;
+export declare const MAX_MARKIT_CONVERSION_CACHE_BYTES: number;
+export type MarkitConversionCacheStatus = "hit" | "miss" | "skipped";
+export type MarkitConversionCacheReadResult = {
+    status: "hit";
+    content: string;
+} | {
+    status: "miss";
+};
+export declare function markitConversionCacheKey(bytes: Uint8Array, extension: string): string;
+export declare function readMarkitConversionCache(key: string): Promise<MarkitConversionCacheReadResult>;
+export declare function pruneMarkitConversionCache(cacheDir: string): Promise<void>;
+export declare function writeMarkitConversionCache(key: string, content: string): Promise<void>;

package/dist/types/utils/markit.d.ts

@@ -1,7 +1,9 @@
+import { type MarkitConversionCacheStatus } from "./markit-cache";
 export interface MarkitConversionResult {
     content: string;
     ok: boolean;
     error?: string;
+    cache?: MarkitConversionCacheStatus;
 }
 export interface MarkitFileConversionOptions {
     /**
@@ -13,4 +15,6 @@ export interface MarkitFileConversionOptions {
     imageDir?: string;
 }
 export declare function convertFileWithMarkit(filePath: string, signal?: AbortSignal, options?: MarkitFileConversionOptions): Promise<MarkitConversionResult>;
-export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
+export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal, options?: {
+    useCache?: boolean;
+}): Promise<MarkitConversionResult>;