@oh-my-pi/pi-coding-agent 17.3.0 → 17.3.2

package/dist/types/cli/args.d.ts

@@ -82,6 +82,8 @@ export interface Args {
 export declare function parseArgs(inputArgs: string[], extensionFlags?: Map<string, {
     type: "boolean" | "string";
 }>): Args;
+/** Reject requested tool names absent from the fully discovered session registry. */
+export declare function validateToolNames(requested: readonly string[] | undefined, known: readonly string[]): void;
 /**
  * Emit a stderr error listing the unrecognized flags and return `true` when
  * there were any. Caller is expected to exit with a non-zero status. Splitting

package/dist/types/cli/extension-flags.d.ts

@@ -29,8 +29,8 @@ export interface ExtensionFlagSink {
  * semantics and surfaces in `unknownFlags` — without consuming the following
  * message or overwriting the built-in field. No built-in name list to maintain.
  *
- * Returns `null` when there is no sink or no registered extension flags, in
- * which case the caller keeps its original startup parse (an extension-aware
- * re-parse would be identical anyway).
+ * Returns `null` only when there is no sink. Once extensions have loaded, the
+ * reparse always runs so `--tools` can be validated against their registered
+ * tools even when no extension registered CLI flags.
  */
 export declare function applyExtensionFlags(runner: ExtensionFlagSink | undefined, rawArgs: string[]): Args | null;

package/dist/types/cli/flag-tables.d.ts

@@ -45,7 +45,6 @@ export interface ParseDeps {
         warn: (message: string, meta?: Record<string, unknown>) => void;
     };
     parseThinking: (value: string | null | undefined) => ConfiguredThinkingLevel | undefined;
-    builtinToolNames: readonly string[];
     normalizeToolNames: (values: Iterable<string>) => string[];
     thinkingEfforts: readonly string[];
 }

package/dist/types/cli/setup-cli.d.ts

@@ -11,6 +11,16 @@ export interface SetupCommandArgs {
  * Returns undefined if not a setup command.
  */
 export declare function parseSetupArgs(args: string[]): SetupCommandArgs | undefined;
+export interface PythonCheckResult {
+    available: boolean;
+    pythonPath?: string;
+    usingManagedEnv?: boolean;
+    managedEnvPath?: string;
+}
+/**
+ * Check Python environment and kernel dependencies.
+ */
+export declare function checkPythonSetup(cwd: string, interpreter?: string): Promise<PythonCheckResult>;
 /**
  * Install Python packages using uv (preferred) or pip.
  */

package/dist/types/cli/update-cli.d.ts

@@ -112,6 +112,8 @@ interface UpdateMethodResolutionOptions {
     miseBinDirs?: readonly string[];
     miseDataDir?: string;
     npmBinDir?: string;
+    /** Bun's configured global package directory, independent of its bin directory. */
+    bunGlobalDir?: string;
     /**
      * Whether the resolved omp path is a plain file (the standalone binary)
      * rather than a package-manager symlink. Stops a binary install from being
@@ -119,8 +121,34 @@ interface UpdateMethodResolutionOptions {
      * target directory.
      */
     ompIsRegularFile?: boolean;
+    /**
+     * Absolute path named by the bin entry's first symlink hop. This deliberately
+     * preserves a global package symlink instead of resolving into its checkout.
+     */
+    ompLinkTarget?: string;
 }
+type UpdateTarget = {
+    method: "brew";
+} | {
+    method: "mise";
+} | {
+    method: "nix";
+} | {
+    method: "bun";
+    path?: string;
+} | {
+    method: "npm";
+    path?: string;
+} | {
+    method: "binary";
+    path: string;
+    replacesSymlink: boolean;
+};
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
+/** Resolve an update target from the concrete PATH entry selected by the shell. */
+export declare function resolveUpdateTargetFromPath(ompPath: string, bunBinDir: string | undefined, options: UpdateMethodResolutionOptions & {
+    allowPackageManagers: boolean;
+}): UpdateTarget;
 /**
  * Get the latest release info from the npm registry, following `omp.rename`
  * pointers ({@link resolveReleaseRename}) when the package has moved to a new
@@ -145,7 +173,13 @@ interface BunInstallCachePruneResult {
  * cache stays internally consistent.
  */
 export declare function pruneBunInstallCache(cacheDir: string, packageNames?: Set<string>): Promise<BunInstallCachePruneResult>;
-export declare function resolveBunGlobalNodeModulesDirFromLocations(globalBinDir: string | undefined, cacheDir: string | undefined): string | undefined;
+interface BunGlobalInstallLocations {
+    globalDir?: string;
+    globalBinDir?: string;
+    cacheDir?: string;
+}
+/** Resolve Bun's global node_modules root from explicit, default, or cache locations. */
+export declare function resolveBunGlobalNodeModulesDirFromLocations({ globalDir, globalBinDir, cacheDir, }: BunGlobalInstallLocations): string | undefined;
 /**
  * Detect a musl-libc Linux host (Alpine, Void-musl) so self-update replaces a
  * musl binary with the musl release asset instead of the glibc build, which
@@ -168,16 +202,21 @@ declare function verifyBinaryAtPath(binaryPath: string, expectedVersion: string)
  */
 declare function verifyInstalledVersion(expectedVersion: string): Promise<InstalledVersionVerification>;
 /**
- * Best-effort removal of binary-update backups left by earlier runs.
+ * Best-effort removal of binary-update leftovers from earlier runs.
  *
- * Each self-update moves the previous executable to `<binary>.<timestamp>.<pid>.bak`
- * before swapping the new one in. On Windows that backup cannot be deleted
- * while the updating process is alive, so it is left for a later run to reclaim
- * once its owning process has exited. Also matches the legacy fixed
- * `<binary>.bak` name produced before backups were timestamped, so users
- * upgrading from a buggy release get the orphaned file cleaned up.
+ * Each self-update writes to `<binary>.<timestamp>.<pid>.new` and moves the
+ * previous executable to `<binary>.<timestamp>.<pid>.bak` before swapping the
+ * new one in. On Windows a backup cannot be deleted while the updating process
+ * is alive (it is the running process image), so it is left for a later run to
+ * reclaim once its owning process has exited. A `.new` temp file only survives
+ * a hard kill mid-download; it is reaped once older than the download window,
+ * which a live download cannot exceed without timing out and cleaning up after
+ * itself — so a concurrent run's in-progress temp is never deleted. Legacy
+ * fixed `<binary>.bak` / `<binary>.new` names (from before suffixes were made
+ * unique) are matched too, so users upgrading from a buggy release get the
+ * orphaned files cleaned up.
  */
-export declare function sweepStaleBackups(targetPath: string): Promise<void>;
+export declare function sweepStaleUpdateArtifacts(targetPath: string): Promise<void>;
 /**
  * Atomically replace the installed binary and roll back if version verification fails.
  */

package/dist/types/commands/completions.d.ts

@@ -5,6 +5,9 @@
  * (see `cli/completion-gen.ts`), so it never drifts from the actual CLI surface.
  */
 import { Command } from "@oh-my-pi/pi-utils/cli";
+import { type Shell } from "../cli/completion-gen.js";
+/** Generate a completion script from the live command registry. */
+export declare function generateLiveCompletion(shell: Shell): Promise<string>;
 export default class Completions extends Command {
     static description: string;
     static args: {

package/dist/types/config/claude-paths.d.ts

@@ -0,0 +1,7 @@
+/** Paths to Claude Code's user data and configuration file. */
+export interface ClaudePaths {
+    configDir: string;
+    configFile: string;
+}
+/** Resolves Claude Code's user paths, honoring `CLAUDE_CONFIG_DIR`. */
+export declare function resolveClaudePaths(home?: string): ClaudePaths;

package/dist/types/discovery/agents.d.ts

@@ -7,13 +7,13 @@ interface UserPathCandidateOptions {
 }
 /**
  * Run a best-effort discovery probe and return its trimmed stdout, or
- * `undefined` when the command fails, produces no output, or exceeds
- * {@link HOST_PROBE_TIMEOUT_MS}. On timeout the child is killed with SIGKILL so
- * a wedged interop pipe cannot hang startup; the killed/non-zero exit is then
- * reported as "unavailable" and discovery falls back to the Linux
- * `$HOME`/`~/.omp` candidates.
+ * `undefined` when the command fails, produces no output, or exceeds the
+ * timeout. On timeout the child is killed with SIGKILL so a wedged interop pipe
+ * cannot hang startup; the killed/non-zero exit is then reported as
+ * "unavailable" and discovery falls back to the Linux `$HOME`/`~/.omp`
+ * candidates.
  */
-export declare function runHostProbe(cmd: string[]): string | undefined;
+export declare function runHostProbe(cmd: string[], timeoutMs?: number): string | undefined;
 /** Resolve the Windows host profile home exposed to WSL, if available. */
 export declare function getWslWindowsHomeCandidate(options?: UserPathCandidateOptions): string | undefined;
 /** User-level paths: ~/.agent[s]/<segments>, plus the Windows host profile under WSL. */

package/dist/types/discovery/helpers.d.ts

@@ -261,11 +261,10 @@ export declare function resolveOrDefaultProjectRegistryPath(cwd: string): Promis
 /** Register a process-global plugin cache invalidator called whenever plugin roots are cleared. */
 export declare function registerPluginCacheInvalidator(invalidator: () => void): void;
 /**
- * List all installed Claude Code plugin roots from the plugin cache.
- * Reads ~/.claude/plugins/installed_plugins.json and ~/.omp/plugins/installed_plugins.json,
- * and optionally the nearest project-scoped registry resolved from `cwd`.
+ * List all installed Claude Code plugin roots from its active plugin cache and
+ * ~/.omp/plugins/installed_plugins.json, plus the nearest project registry when present.
  *
- * Results are cached per home, project registry, and canonical active project.
+ * Results are cached per Claude and OMP config directories, project registry, and canonical active project.
  */
 export declare function listClaudePluginRoots(home: string, cwd?: string): Promise<{
     roots: ClaudePluginRoot[];

package/dist/types/extensibility/extensions/runner.d.ts

@@ -8,7 +8,7 @@ import type { MemoryRuntimeContext } from "../../memory-backend/index.js";
 import type { AsyncJobSnapshot } from "../../session/agent-session.js";
 import type { SessionManager } from "../../session/session-manager.js";
 import type { BranchHandler, NavigateTreeHandler, NewSessionHandler } from "../session-handler-types.js";
-import type { AfterProviderResponseEvent, AssistantThinkingRenderer, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, ContextEvent, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, McpNotificationEvent, MessageRenderer, RegisteredCommand, RegisteredTool, ResourcesDiscoverEvent, SessionBeforeBranchResult, SessionBeforeCompactResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionCompactingResult, SessionStopEvent, SessionStopEventResult, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult, UserPythonEvent, UserPythonEventResult } from "./types.js";
+import type { AfterProviderResponseEvent, AssistantThinkingRenderer, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, ContextEvent, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, InputEvent, InputEventResult, McpNotificationEvent, MessageRenderer, RegisteredCommand, RegisteredTool, ResourcesDiscoverEvent, SessionBeforeBranchResult, SessionBeforeCompactResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionCompactingResult, SessionStopEvent, SessionStopEventResult, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, UserBashEvent, UserBashEventResult, UserPythonEvent, UserPythonEventResult } from "./types.js";
 /** Combined result from all before_agent_start handlers */
 interface BeforeAgentStartCombinedResult {
     messages?: NonNullable<BeforeAgentStartEventResult["message"]>[];
@@ -115,7 +115,7 @@ export declare class ExtensionRunner {
      * leak into another's `ctx.cwd` by reading a shared global.
      */
     get cwd(): string;
-    initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
+    initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext, mode?: ExtensionMode): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
      *

package/dist/types/extensibility/extensions/types.d.ts

@@ -280,9 +280,13 @@ export interface ExtensionModelQuery {
      */
     family(model: Model): string;
 }
+/** Runtime host mode exposed to Pi-compatible extensions. */
+export type ExtensionMode = "tui" | "rpc" | "json" | "print";
 export interface ExtensionContext {
     /** UI methods for user interaction */
     ui: ExtensionUIContext;
+    /** Current run mode. Use `"tui"` to guard terminal-only UI such as custom components. */
+    mode: ExtensionMode;
     /** Get current context usage for the active model. */
     getContextUsage(): ContextUsage | undefined;
     /** Get a read-only snapshot of async jobs owned by this session. */

package/dist/types/launch/broker.d.ts

@@ -1,2 +1,6 @@
+export interface DaemonBrokerStartOptions {
+    /** Base of the exponential child-restart backoff. */
+    restartBackoffBaseMs?: number;
+}
 /** Start the detached project or global daemon broker selected by the CLI worker host. */
-export declare function startDaemonBrokerFromEnvironment(): Promise<void>;
+export declare function startDaemonBrokerFromEnvironment(options?: DaemonBrokerStartOptions): Promise<void>;

package/dist/types/main.d.ts

@@ -28,7 +28,7 @@ export interface AcpSessionFactoryOptions {
     sessionDir?: string;
     authStorage: AuthStorage;
     modelRegistry: ModelRegistry;
-    parsedArgs: Pick<Args, "apiKey" | "trustedExtensions">;
+    parsedArgs: Pick<Args, "apiKey" | "trustedExtensions" | "tools">;
     rawArgs: string[];
     createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
 }

package/dist/types/mcp/transports/stdio.d.ts

@@ -110,7 +110,7 @@ interface KillableSubprocess {
 }
 /**
  * Terminate an MCP stdio subprocess: SIGTERM (process-group when `detached`
- * on POSIX, direct child otherwise), wait up to `TERM_GRACE_MS` for a
+ * on POSIX, direct child otherwise), wait up to `termGraceMs` for a
  * cooperative exit, then escalate to SIGKILL — waiting up to `KILL_GRACE_MS`
  * more only when the leader itself hadn't already exited. A detached
  * leader's cooperative exit does not prove the whole process group is gone
@@ -123,9 +123,12 @@ interface KillableSubprocess {
  * `detached`/`platform` pair: `StdioTransport.connect()` derives `detached`
  * from `resolveStdioSpawnCommand()`, which is tied to the host's real
  * `process.platform`, so a POSIX detached session cannot be reproduced
- * end-to-end through `connect()` on a non-Linux dev/CI host.
+ * end-to-end through `connect()` on a non-Linux dev/CI host. `termGraceMs`
+ * preserves the production grace by default while allowing those real
+ * subprocess tests to cover the same transition without sleeping for a
+ * production-length shutdown window.
  */
-export declare function terminateStdioProcess(proc: KillableSubprocess, detached: boolean, platform?: NodeJS.Platform): Promise<void>;
+export declare function terminateStdioProcess(proc: KillableSubprocess, detached: boolean, platform?: NodeJS.Platform, termGraceMs?: number): Promise<void>;
 /**
  * Stdio transport for MCP servers.
  * Spawns a subprocess and communicates via stdin/stdout.

package/dist/types/modes/components/footer.d.ts

@@ -17,8 +17,9 @@ export declare class FooterComponent implements Component {
      */
     setExtensionStatus(key: string, text: string | undefined): void;
     /**
-     * Set up a file watcher on .git/HEAD to detect branch changes.
-     * Call the provided callback when branch changes.
+     * Watch the repository HEAD for branch changes; invokes the callback so the
+     * footer repaints with the new branch. Uses `git.head.watch` (stat-poll) —
+     * see that helper for why `fs.watch` cannot track git's atomic HEAD swaps.
      */
     watchBranch(onBranchChange: () => void): void;
     /**

package/dist/types/modes/interactive-mode.d.ts

@@ -51,6 +51,7 @@ import type { CompactionQueuedMessage, InteractiveModeContext, InteractiveModeIn
  * any further, it would only misreport the rows it actually occupies.
  */
 export declare function computeEditorMaxHeight(terminalRows: number): number;
+export declare function shouldEnterPlanModeOnStartup(sessionManager: Pick<SessionManager, "buildSessionContext" | "getEntries">, sessionSettings: Pick<Settings, "get">): boolean;
 /** Options for creating an InteractiveMode instance (for future API use) */
 export interface InteractiveModeOptions {
     /** Providers that were migrated during startup */
@@ -334,7 +335,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
         reuseSettledComponent?: boolean;
     }): Component[];
     renderSessionContext(sessionContext: SessionContext, options?: RenderSessionContextOptions): void;
-    /** Render a session context in bounded chunks so terminal input runs between transcript paints. */
+    /** Build a session context in bounded chunks so terminal input runs between event-loop turns. */
     renderSessionContextIncrementally(sessionContext: SessionContext, options: RenderSessionContextOptions, renderChunk?: () => void): Promise<void>;
     renderInitialMessages(options?: {
         preserveExistingChat?: boolean;

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -25,6 +25,8 @@ export interface RpcClientOptions {
     sessionDir?: string;
     /** Additional CLI arguments */
     args?: string[];
+    /** Grace period before escalating process termination (default: process utility default, 1000ms) */
+    terminationGraceMs?: number;
     /** Custom tools owned by the embedding host and exposed over the RPC transport */
     customTools?: RpcClientCustomTool[];
 }

package/dist/types/modes/rpc/rpc-input.d.ts

@@ -3,3 +3,8 @@
  * RPC startup uses this before extension discovery so in-process modules cannot steal protocol input.
  */
 export declare function claimRpcInput(): ReadableStream<Uint8Array>;
+/**
+ * Parses newline-delimited RPC input without letting one malformed line stop
+ * subsequent protocol frames.
+ */
+export declare function readRpcInputFrames(input: ReadableStream<Uint8Array>, onFrame: (frame: unknown) => void, onParseError: (message: string) => void): Promise<void>;

package/dist/types/modes/runtime-init.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionError, ExtensionUIContext } from "../extensibility/extensions/types.js";
+import type { ExtensionError, ExtensionMode, ExtensionUIContext } from "../extensibility/extensions/types.js";
 import type { AgentSession } from "../session/agent-session.js";
 /** Action name for an extension-originated send failure. */
 export type ExtensionSendAction = "extension_send" | "extension_send_user";
@@ -9,6 +9,8 @@ export interface InitializeExtensionsOptions {
     reportRuntimeError: (error: ExtensionError) => void;
     /** Optional shutdown hook (rpc mode signals its loop; print mode is a no-op). */
     onShutdown?: () => void;
+    /** Pi-compatible mode exposed to extension contexts. Defaults to `"print"`. */
+    mode?: ExtensionMode;
     /** Optional UI context (rpc supplies one; print runs headless). */
     uiContext?: ExtensionUIContext;
     /** Optional lifecycle hook for extension-originated messages that can start an agent turn. */

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -35,7 +35,7 @@ export declare class UiHelpers {
      * @param options.populateHistory Add user messages to editor history
      */
     renderSessionContext(sessionContext: SessionContext, options?: RenderSessionContextOptions): void;
-    /** Render a session context in bounded chunks so terminal input runs between transcript paints. */
+    /** Build a session context in bounded chunks so terminal input runs between event-loop turns. */
     renderSessionContextIncrementally(sessionContext: SessionContext, options: RenderSessionContextOptions, renderChunk?: () => void): Promise<void>;
     renderInitialMessages(options?: RenderInitialMessagesOptions): Promise<void>;
     clearEditor(): void;

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

@@ -213,6 +213,8 @@ export interface ExecutorOptions {
     keepAlive?: boolean;
     /** Internal ownership handoff for cleanup that outlives the visible Task result. */
     onCleanupDeferred?: (completion: Promise<void>) => void;
+    /** Internal cleanup grace override for deterministic lifecycle tests. */
+    cleanupGraceMs?: number;
 }
 interface FinalizeSubprocessOutputArgs {
     rawOutput: string;

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

@@ -155,6 +155,11 @@ export declare const GIT_COMMAND_OUTPUT_LIMIT_BYTES: number;
  * degrades instead of freezing the UI indefinitely.
  */
 export declare const GIT_SPAWN_SYNC_TIMEOUT_MS = 5000;
+/**
+ * Stat-poll interval for {@link head.watch}. One `stat` per interval keeps an
+ * always-on status line cheap while surfacing a branch switch within a second.
+ */
+export declare const HEAD_WATCH_INTERVAL_MS = 1000;
 interface CommandOptions {
     readonly env?: Record<string, string | undefined>;
     readonly maxOutputBytes?: number;
@@ -458,6 +463,20 @@ export declare const head: {
     sha(cwd: string, signal?: AbortSignal): Promise<string | null>;
     /** Abbreviated HEAD commit SHA. */
     short(cwd: string, length?: number, signal?: AbortSignal): Promise<string | null>;
+    /**
+     * Watch the repository's HEAD for branch moves. Returns a disposer.
+     *
+     * Deliberately stat-polls via `fs.watchFile` instead of `fs.watch`: git
+     * swaps HEAD with `HEAD.lock` + atomic rename, which unlinks the HEAD inode
+     * — and Bun's inotify-backed `fs.watch` permanently stops delivering events
+     * after observing a rename in the watched directory (oven-sh/bun#24875), so
+     * an event watcher fires once and then freezes on Linux (issue #8412 was
+     * the same freeze for file-inode watches on every platform). A path-based
+     * stat poll re-resolves the path each interval and survives inode swaps
+     * everywhere. Reftable repos keep ref state in `<gitDir>/reftable` (their
+     * HEAD file is a static stub), so the poll targets that directory instead.
+     */
+    watch(repository: GitRepository, onChange: () => void): () => void;
 };
 export declare const repo: {
     /** Resolve the repository root (may be a worktree root). */

package/dist/types/utils/shell-snapshot.d.ts

@@ -11,5 +11,8 @@ export declare function sanitizeSnapshotForBrush(content: string): {
 /**
  * Create a shell snapshot, caching the result.
  * Returns the path to the snapshot file, or null if creation failed.
+ *
+ * `timeoutMs` is configurable so callers exercising failure handling do not
+ * have to wait out the production startup budget.
  */
-export declare function getOrCreateSnapshot(shell: string, env: Record<string, string | undefined>): Promise<string | null>;
+export declare function getOrCreateSnapshot(shell: string, env: Record<string, string | undefined>, timeoutMs?: number): Promise<string | null>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.3.0",
+	"version": "17.3.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -50,18 +50,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.3.0",
-		"@oh-my-pi/omp-stats": "17.3.0",
-		"@oh-my-pi/omptype": "17.3.0",
-		"@oh-my-pi/pi-agent-core": "17.3.0",
-		"@oh-my-pi/pi-ai": "17.3.0",
-		"@oh-my-pi/pi-catalog": "17.3.0",
-		"@oh-my-pi/pi-mnemopi": "17.3.0",
-		"@oh-my-pi/pi-natives": "17.3.0",
-		"@oh-my-pi/pi-tui": "17.3.0",
-		"@oh-my-pi/pi-utils": "17.3.0",
-		"@oh-my-pi/pi-wire": "17.3.0",
-		"@oh-my-pi/snapcompact": "17.3.0",
+		"@oh-my-pi/hashline": "17.3.2",
+		"@oh-my-pi/omp-stats": "17.3.2",
+		"@oh-my-pi/omptype": "17.3.2",
+		"@oh-my-pi/pi-agent-core": "17.3.2",
+		"@oh-my-pi/pi-ai": "17.3.2",
+		"@oh-my-pi/pi-catalog": "17.3.2",
+		"@oh-my-pi/pi-mnemopi": "17.3.2",
+		"@oh-my-pi/pi-natives": "17.3.2",
+		"@oh-my-pi/pi-tui": "17.3.2",
+		"@oh-my-pi/pi-utils": "17.3.2",
+		"@oh-my-pi/pi-wire": "17.3.2",
+		"@oh-my-pi/snapcompact": "17.3.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/async/job-manager.ts

@@ -152,6 +152,7 @@ export class AsyncJobManager {
 	readonly #maxRunningJobs: number;
 	readonly #retentionMs: number;
 	#deliveryLoop: Promise<void> | undefined;
+	#deliveryQueueChanged = Promise.withResolvers<void>();
 	#disposed = false;
 
 	#filterJobs(jobs: Iterable<AsyncJob>, filter?: AsyncJobFilter): AsyncJob[] {
@@ -335,6 +336,7 @@ export class AsyncJobManager {
 		for (const jobId of uniqueJobIds) {
 			this.#watchedJobs.add(jobId);
 		}
+		this.#notifyDeliveryQueueChanged();
 		return uniqueJobIds.length;
 	}
 
@@ -389,6 +391,7 @@ export class AsyncJobManager {
 			this.#deliveries.length,
 			...this.#deliveries.filter(delivery => !this.isDeliverySuppressed(delivery.jobId)),
 		);
+		this.#notifyDeliveryQueueChanged();
 		return before - this.#deliveries.length;
 	}
 
@@ -603,6 +606,7 @@ export class AsyncJobManager {
 		this.#clearEvictionTimers();
 		this.#jobs.clear();
 		this.#deliveries.length = 0;
+		this.#notifyDeliveryQueueChanged();
 		this.#inFlightDeliveries.length = 0;
 		this.#suppressedDeliveries.clear();
 		this.#watchedJobs.clear();
@@ -704,13 +708,14 @@ export class AsyncJobManager {
 			const now = Date.now();
 			if (selected.nextAttemptAt > now) {
 				if (selected.nextAttemptAt > deadline) return false;
-				await Bun.sleep(selected.nextAttemptAt - now);
+				await this.#waitForDeliveryQueueChange(selected.nextAttemptAt - now);
 				continue;
 			}
 
 			const index = this.#deliveries.indexOf(selected);
 			if (index === -1) continue;
 			this.#deliveries.splice(index, 1);
+			this.#notifyDeliveryQueueChanged();
 			if (this.isDeliverySuppressed(selected.jobId)) continue;
 
 			return this.#waitForDeliveryPromise(this.#deliverDelivery(selected), deadline);
@@ -726,7 +731,7 @@ export class AsyncJobManager {
 		if (this.isDeliverySuppressed(jobId)) {
 			return;
 		}
-		this.#deliveries.push({
+		this.#queueDelivery({
 			jobId,
 			text,
 			attempt: 0,
@@ -762,7 +767,8 @@ export class AsyncJobManager {
 			}
 			const waitMs = delivery.nextAttemptAt - Date.now();
 			if (waitMs > 0) {
-				await Bun.sleep(waitMs);
+				await this.#waitForDeliveryQueueChange(waitMs);
+				continue;
 			}
 			if (this.#deliveries[0] !== delivery) {
 				continue;
@@ -813,7 +819,7 @@ export class AsyncJobManager {
 				delivery.lastError = error instanceof Error ? error.message : String(error);
 				delivery.nextAttemptAt = Date.now() + this.#getRetryDelay(delivery.attempt);
 				if (!this.isDeliverySuppressed(delivery.jobId)) {
-					this.#deliveries.push(delivery);
+					this.#queueDelivery(delivery);
 				}
 				logger.warn("Async job completion delivery failed", {
 					jobId: delivery.jobId,
@@ -831,6 +837,29 @@ export class AsyncJobManager {
 		return promise;
 	}
 
+	#queueDelivery(delivery: AsyncJobDelivery): void {
+		const index = this.#deliveries.findIndex(candidate => candidate.nextAttemptAt > delivery.nextAttemptAt);
+		if (index === -1) this.#deliveries.push(delivery);
+		else this.#deliveries.splice(index, 0, delivery);
+		this.#notifyDeliveryQueueChanged();
+	}
+
+	async #waitForDeliveryQueueChange(delayMs: number): Promise<void> {
+		const timerElapsed = Promise.withResolvers<void>();
+		const timer = setTimeout(timerElapsed.resolve, delayMs);
+		timer.unref();
+		try {
+			await Promise.race([timerElapsed.promise, this.#deliveryQueueChanged.promise]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+
+	#notifyDeliveryQueueChanged(): void {
+		this.#deliveryQueueChanged.resolve();
+		this.#deliveryQueueChanged = Promise.withResolvers<void>();
+	}
+
 	async #waitForDeliveryPromise(promise: Promise<void> | undefined, deadline: number): Promise<boolean> {
 		if (!promise) return true;
 		if (deadline === Number.POSITIVE_INFINITY) {

package/src/cli/args.ts

@@ -6,7 +6,7 @@ import { $env, APP_NAME, logger } from "@oh-my-pi/pi-utils";
 import chalk from "@oh-my-pi/pi-utils/chalk";
 import type { ServiceTierOpenAISettingValue } from "../config/service-tier";
 import { CLI_THINKING_LEVELS, type ConfiguredThinkingLevel, parseCliThinkingLevel } from "../thinking";
-import { BUILTIN_TOOL_NAMES, HIDDEN_TOOL_NAMES, normalizeToolNames } from "../tools/builtin-names";
+import { normalizeToolNames } from "../tools/builtin-names";
 import {
 	OPTIONAL_FLAGS,
 	OPTIONAL_VALUE_FLAGS,
@@ -108,7 +108,6 @@ export interface Args {
 const PARSE_DEPS: ParseDeps = {
 	logger,
 	parseThinking: parseCliThinkingLevel,
-	builtinToolNames: [...BUILTIN_TOOL_NAMES, ...HIDDEN_TOOL_NAMES],
 	normalizeToolNames,
 	thinkingEfforts: CLI_THINKING_LEVELS,
 };
@@ -148,6 +147,7 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 	// reparse in `runRootCommand` parses it a second time). Mutating the input
 	// would corrupt that later parse, so never touch the caller's array.
 	const args = [...inputArgs];
+	const parseDeps = PARSE_DEPS;
 	const result: Args = {
 		messages: [],
 		fileArgs: [],
@@ -214,7 +214,7 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			if (i + 1 < args.length && args[i + 1] !== PROFILE_BOOTSTRAP_BOUNDARY_ARG) {
 				const consumed = consumeBuiltInStringValue(arg, args, i + 1);
 				i = consumed.index;
-				STRING_SETTERS[arg](result, consumed.value, PARSE_DEPS);
+				STRING_SETTERS[arg](result, consumed.value, parseDeps);
 			}
 		} else if (OPTIONAL_VALUE_FLAGS.has(arg)) {
 			const config = OPTIONAL_FLAGS[arg];
@@ -332,6 +332,17 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 	return result;
 }
 
+/** Reject requested tool names absent from the fully discovered session registry. */
+export function validateToolNames(requested: readonly string[] | undefined, known: readonly string[]): void {
+	if (!requested) return;
+	const knownNames = new Set(known);
+	const unknown = requested.filter(name => !knownNames.has(name));
+	if (unknown.length === 0) return;
+	throw new CliUsageError(
+		`Unknown tool${unknown.length === 1 ? "" : "s"} in --tools: ${unknown.join(", ")}. Valid tools: ${known.join(", ")}.`,
+	);
+}
+
 /**
  * Emit a stderr error listing the unrecognized flags and return `true` when
  * there were any. Caller is expected to exit with a non-zero status. Splitting

package/src/cli/extension-flags.ts

@@ -29,18 +29,14 @@ export interface ExtensionFlagSink {
  * semantics and surfaces in `unknownFlags` — without consuming the following
  * message or overwriting the built-in field. No built-in name list to maintain.
  *
- * Returns `null` when there is no sink or no registered extension flags, in
- * which case the caller keeps its original startup parse (an extension-aware
- * re-parse would be identical anyway).
+ * Returns `null` only when there is no sink. Once extensions have loaded, the
+ * reparse always runs so `--tools` can be validated against their registered
+ * tools even when no extension registered CLI flags.
  */
 export function applyExtensionFlags(runner: ExtensionFlagSink | undefined, rawArgs: string[]): Args | null {
-	const extensionFlags = runner?.getFlags();
-	if (!runner || !extensionFlags || extensionFlags.size === 0) {
-		return null;
-	}
-	const parsed = parseArgs(rawArgs, extensionFlags);
-	// `parseArgs` only records registered extension flags in `unknownFlags`, so
-	// every entry here is a flag this runner owns that was actually passed.
+	if (!runner) return null;
+	const parsed = parseArgs(rawArgs, runner.getFlags());
+	// `parseArgs` records extension flag values in `unknownFlags`.
 	for (const [name, value] of parsed.unknownFlags) {
 		runner.setFlagValue(name, value);
 	}