@oh-my-pi/pi-coding-agent 15.13.0 → 15.13.1

package/dist/types/autolearn/managed-skills.d.ts

@@ -3,7 +3,7 @@ export declare const MANAGED_SKILLS_PROVIDER_ID = "omp-managed";
 /** Hard cap on a managed SKILL.md body to keep generated skills bounded. */
 export declare const MAX_MANAGED_SKILL_BYTES = 64000;
 /** Resolve the isolated managed-skills directory (`~/.omp/agent/managed-skills`). */
-export declare function getManagedSkillsDir(home?: string): string;
+export declare function getManagedSkillsDir(agentDir?: string): string;
 /**
  * Validate + normalize a managed-skill name. Throws on anything outside the
  * strict allowlist so a bad name can never escape `getManagedSkillsDir()`

package/dist/types/capability/mcp.d.ts

@@ -30,13 +30,14 @@ export interface MCPServer {
         clientSecret?: string;
         resource?: string;
     };
-    /** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath) for servers requiring explicit client credentials */
+    /** OAuth configuration (clientId, clientSecret, redirectUri, callbackPort, callbackPath, prompt) for servers requiring explicit client credentials */
     oauth?: {
         clientId?: string;
         clientSecret?: string;
         redirectUri?: string;
         callbackPort?: number;
         callbackPath?: string;
+        prompt?: string;
     };
     /** Transport type */
     transport?: "stdio" | "sse" | "http";

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

@@ -5,6 +5,8 @@ import { type Effort } from "@oh-my-pi/pi-catalog/effort";
 export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui";
 export interface Args {
     cwd?: string;
+    profile?: string;
+    alias?: string;
     allowHome?: boolean;
     provider?: string;
     model?: string;

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

@@ -0,0 +1,126 @@
+/**
+ * Single source of truth for argv flag classification, shared by:
+ *   - `parseArgs` in `./args.ts` (the launch-time CLI parser)
+ *   - `extractProfileFlags` in `./profile-bootstrap.ts` (the early
+ *     `--profile` / `--alias` pre-parser)
+ *
+ * `parseArgs` dispatches string-valued flags by looking up their setter in
+ * {@link STRING_SETTERS}. Optional-value flags use {@link OPTIONAL_FLAGS} so
+ * per-flag quirks (currently empty-string rejection for `--resume`) live here
+ * instead of being hard-coded in the dispatch loop.
+ *
+ * The bootstrap doesn't dispatch — it only needs to know which flags consume
+ * a value — so it consults {@link STRING_VALUE_FLAGS} and
+ * {@link OPTIONAL_VALUE_FLAGS}, both derived from `Object.keys(...)` on the
+ * setter/config records below.
+ *
+ * The deliberate consequence: a string-valued flag exists in this CLI surface
+ * iff it has an entry here. Adding a new string-valued flag means adding a
+ * setter/config entry in this file; both `args.ts` and the bootstrap pick it
+ * up automatically, so the two cannot drift out of sync.
+ *
+ * IMPORT RULE: this module MUST NOT import any runtime value from
+ * `@oh-my-pi/pi-utils` (or anything that transitively does). That package's
+ * `env.ts` eagerly loads `.env` files from `getAgentDir()` during module
+ * initialization, which would race the profile bootstrap. Type-only imports
+ * are erased at runtime and are therefore safe.
+ *
+ * If a setter needs runtime dependencies (logging, validators, lookup
+ * tables), they're passed in through {@link ParseDeps} and `args.ts` wires the
+ * real implementations at the dispatch site.
+ */
+import type { Effort } from "@oh-my-pi/pi-ai";
+import type { Args } from "./args";
+/**
+ * Runtime dependencies injected into setters that need to validate input or
+ * warn about bad values. `args.ts` constructs one object at module load and
+ * passes it to each {@link STRING_SETTERS} call.
+ *
+ * Keeping these out of the setter closures means this module stays free of
+ * runtime imports from `@oh-my-pi/pi-utils`, which is the whole reason it can
+ * be safely imported by `profile-bootstrap.ts` before `setProfile` runs.
+ */
+export interface ParseDeps {
+    logger: {
+        warn: (message: string, meta?: Record<string, unknown>) => void;
+    };
+    parseEffort: (value: string | null | undefined) => Effort | undefined;
+    builtinToolNames: readonly string[];
+    thinkingEfforts: readonly string[];
+}
+export type StringSetter = (result: Args, value: string, deps: ParseDeps) => void;
+/**
+ * Setter for a flag that may or may not consume the next argv token.
+ * Receives `undefined` for the bare form (`--resume` with no value, etc.).
+ */
+export type OptionalSetter = (result: Args, value: string | undefined) => void;
+/**
+ * Per-flag optional-value consumption policy.
+ *
+ * Every optional flag always rejects tokens that start with `-` — that shared
+ * rule lives in the dispatch site. These booleans capture the *additional*
+ * per-flag quirks:
+ *
+ * - `rejectEmpty`: treat `""` like “no value provided”. Needed for
+ *   `--resume` / `-r` / `--session`. Without it, an empty string
+ *   gets consumed as the session prefix and downstream resolution can match
+ *   every session.
+ */
+export interface OptionalFlagConfig {
+    set: OptionalSetter;
+    rejectEmpty?: boolean;
+}
+/**
+ * Setters for flags with string values. Most built-ins consume the next argv
+ * token even when it starts with `-`; flags listed in
+ * {@link EXTENSION_SHADOWABLE_STRING_FLAGS} use extension-style consumption so
+ * a registered boolean extension can shadow them before profile bootstrap.
+ */
+export declare const STRING_SETTERS: Record<string, StringSetter>;
+/**
+ * Optional-value flags. Setters receive `undefined` for the bare form.
+ *
+ * The dispatch in `args.ts` applies the shared "doesn't start with `-`"
+ * check for every flag, then consults the per-flag booleans below for the
+ * remaining quirks.
+ */
+export declare const OPTIONAL_FLAGS: Record<string, OptionalFlagConfig>;
+/**
+ * Derived from {@link STRING_SETTERS}. A flag is in this set if and only if
+ * it has a setter — by construction, drift between "the bootstrap thinks
+ * this flag accepts a value" and "the launch parser can set one" is
+ * structurally impossible.
+ */
+export declare const STRING_VALUE_FLAGS: ReadonlySet<string>;
+/**
+ * Built-in string flags known to be shadowed by bundled/common boolean
+ * extensions before extension metadata is available. They still accept a
+ * value-like successor for the built-in form (`--plan opus`), but a
+ * flag-looking successor remains a fresh flag (`--plan --profile work`).
+ */
+export declare const EXTENSION_SHADOWABLE_STRING_FLAGS: ReadonlySet<string>;
+/**
+ * Derived from {@link OPTIONAL_FLAGS}. Same single-source contract as
+ * {@link STRING_VALUE_FLAGS}.
+ */
+export declare const OPTIONAL_VALUE_FLAGS: ReadonlySet<string>;
+/**
+ * Internal marker inserted by the profile bootstrap when removing `--profile`
+ * or `--alias` would otherwise make the following value-like token become the
+ * value of a preceding optional/extension flag. `parseArgs` ignores it, but its
+ * flag-looking shape preserves argv boundaries during the second parse.
+ */
+export declare const PROFILE_BOOTSTRAP_BOUNDARY_ARG = "--omp-profile-boundary";
+/**
+ * Long-form launch flags that take NO value (booleans). The bootstrap pre-parser
+ * needs this to tell a known value-less flag (whose successor is a fresh
+ * argument — `omp --print --profile work` still selects a profile) apart from an
+ * UNKNOWN long option that might be an extension string flag consuming the next
+ * token as its value (so the bootstrap must not steal that token as a global
+ * `--profile`/`--alias`). MUST mirror the value-less flag arms of `parseArgs`
+ * in `./args.ts`: adding a new boolean launch flag there means adding it here,
+ * or `--<newflag> --profile X` stops selecting a profile. Short aliases
+ * (`-h`/`-v`/`-c`/`-p`) are intentionally omitted — the protection rule only
+ * fires for `--`-prefixed tokens.
+ */
+export declare const VALUELESS_FLAGS: ReadonlySet<string>;

package/dist/types/cli/profile-alias.d.ts

@@ -0,0 +1,29 @@
+export type ProfileAliasShell = "bash" | "zsh" | "fish" | "powershell" | "pwsh";
+export interface ProfileAliasCommand {
+    display: string;
+    posix: string;
+    fish: string;
+    powerShell: string;
+}
+export interface ProfileAliasInstallOptions {
+    profile: string;
+    aliasName: string;
+    shellPath?: string;
+    platform?: NodeJS.Platform;
+    homeDir?: string;
+    env?: NodeJS.ProcessEnv;
+    readFile?: (filePath: string) => Promise<string>;
+    command?: ProfileAliasCommand;
+    writeFile?: (filePath: string, content: string) => Promise<void>;
+}
+export interface ProfileAliasInstallResult {
+    shell: ProfileAliasShell;
+    configPath: string;
+    aliasName: string;
+    profile: string;
+    command: string;
+    reloadedWith: string;
+}
+export declare function resolveProfileAliasCommandFromProcess(argv?: readonly string[], cwd?: string): ProfileAliasCommand;
+export declare function readProfileAliasConfigFile(filePath: string, readText?: (filePath: string) => Promise<string>): Promise<string>;
+export declare function installProfileAlias(options: ProfileAliasInstallOptions): Promise<ProfileAliasInstallResult>;

package/dist/types/cli/profile-bootstrap.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bootstrap-time argv preparser for the global `--profile` / `--alias` flags.
+ *
+ * Profile selection MUST happen before any module reads `getAgentDir()` (notably
+ * `@oh-my-pi/pi-utils/env`, which eagerly loads `.env` from the agent directory
+ * during its own import). The full `parseArgs` from `./args.ts` lives downstream
+ * of those imports, so we can't rely on it for profile bootstrap — we have to
+ * crack open argv before the lazy command modules load.
+ *
+ * Because of that, this preparser must respect the same value-consumption
+ * contract as `args.ts`: known string-valued flags usually consume the next
+ * token even when it starts with `-`, except for string flags that can be
+ * shadowed by preloaded boolean extensions (currently `--plan`). Optional-value
+ * flags (`--resume`, `--session`, `-r`) consume the next token only when it
+ * doesn't look like another flag. Without this, `omp --system-prompt --profile
+ * foo` silently activates profile `foo`
+ * instead of passing the literal `--profile` to the system prompt and `foo`
+ * as a positional message.
+ *
+ * The shared classification lives in {@link ./flag-tables}, imported below,
+ * so the bootstrap and `args.ts` reference one source of truth instead of
+ * maintaining parallel constants.
+ *
+ * An unclassified bare long option (one not in any flag table) is treated as a
+ * possible extension string flag, but the bootstrap mirrors `parseArgs`'
+ * extension-flag rules ({@link ./args}): a string extension flag consumes its
+ * successor ONLY when that successor is value-like (does not start with `-`), and
+ * a boolean extension flag consumes nothing. So the successor is forwarded
+ * untouched (and never read as a global `--profile`/`--alias`) only when it is
+ * value-like; a flag-looking successor is left for normal processing, so
+ * `omp --some-ext-flag --profile work` still selects a profile. Known value-less
+ * launch flags ({@link VALUELESS_FLAGS}) are exempt so a trailing profile after
+ * them also activates (`omp --print --profile work`).
+ */
+export interface ProfileBootstrapResult {
+    argv: string[];
+    profile?: string;
+    aliasName?: string;
+}
+/**
+ * Strip `--profile` / `--alias` from argv while preserving the surrounding
+ * argument structure, returning the residual argv to hand to the launch parser
+ * and the captured flag values.
+ *
+ * Global flag extraction stops only when the first residual argv token names a
+ * registered command that owns its own flags (e.g. `grep`): everything from
+ * that token onward is forwarded verbatim so a subcommand's own flags and
+ * positionals are never stolen (`omp grep --profile <path>` greps for
+ * `--profile`; it does not select a profile). `launch` and `acp` are explicit
+ * spellings of launch-shaped commands, so `omp launch --profile work` and
+ * `omp acp --profile work` still select profile `work`.
+ *
+ * Throws when either flag is supplied without a value.
+ */
+export declare function extractProfileFlags(argv: readonly string[]): ProfileBootstrapResult;

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

@@ -40,6 +40,12 @@ export default class Index extends Command {
         "allow-home": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        profile: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        alias: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         cwd: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

package/dist/types/config/model-roles.d.ts

@@ -3,15 +3,16 @@
  */
 import { type ThemeColor } from "../modes/theme/theme";
 import type { Settings } from "./settings";
-export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "task";
+export type ModelRole = "default" | "smol" | "slow" | "vision" | "plan" | "designer" | "commit" | "title" | "task";
 export interface ModelRoleInfo {
     tag?: string;
     name: string;
     color?: ThemeColor;
+    /** If true, the role is functional but not shown in the model selector UI. */
+    hidden?: boolean;
 }
 export declare const MODEL_ROLES: Record<ModelRole, ModelRoleInfo>;
 export declare const MODEL_ROLE_IDS: ModelRole[];
-/** Alias for ModelRoleInfo - used for both built-in and custom roles */
 export type RoleInfo = ModelRoleInfo;
 /**
  * Return the canonical set of known roles for selector/carousel UI.

package/dist/types/config/settings-schema.d.ts

@@ -107,6 +107,8 @@ type SettingDef = BooleanDef | StringDef | NumberDef | EnumDef<readonly string[]
 export interface ModelTagDef {
     name: string;
     color?: string;
+    /** If true, the role is functional but not shown in the model selector UI. */
+    hidden?: boolean;
 }
 export interface ModelTagsSettings {
     [key: string]: ModelTagDef;

package/dist/types/edit/file-snapshot-store.d.ts

@@ -45,4 +45,18 @@ export declare function canonicalSnapshotKey(absolutePath: string): string;
  * validates whenever the live file is byte-identical to what was read.
  */
 export declare function recordFileSnapshot(session: FileSnapshotStoreOwner, absolutePath: string): Promise<string | undefined>;
+/**
+ * The 1-indexed file lines a hashline-formatted body actually displayed.
+ * Single `NN:` rows contribute that line; a collapsed summary `NN-MM:` row
+ * (a `{ .. }` brace pair) contributes only its boundary lines `NN` and `MM` —
+ * the elided interior was never shown, so editing inside it must be rejected.
+ */
+export declare function parseSeenLinesFromHashlineBody(body: string): number[];
+/**
+ * Attach the lines a read displayed to the snapshot it minted, so the patcher
+ * can reject edits anchored on lines the model never saw. Best-effort: a no-op
+ * when the body has no numbered rows or the snapshot already aged out. `tag`
+ * must be the tag returned when this exact content was recorded.
+ */
+export declare function recordSeenLinesFromBody(session: FileSnapshotStoreOwner, absolutePath: string, tag: string, body: string): void;
 export {};

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

@@ -17,6 +17,17 @@ interface BeforeAgentStartCombinedResult {
 export type ExtensionErrorListener = (error: ExtensionError) => void;
 export declare const EXTENSION_HANDLER_TIMEOUT_MS = 30000;
 export declare function testSetExtensionHandlerTimeoutMs(timeoutMs: number): void;
+/**
+ * Dedicated cap for `session_shutdown` handlers. The generic 30s budget is
+ * appropriate for events extensions can observe (e.g. `session_start`,
+ * `before_provider_request`), but `session_shutdown` is fire-and-forget
+ * teardown — extensions receive no result and the user has already asked to
+ * leave. A hung handler (e.g. an extension waiting on a stuck IPC pipe to a
+ * companion app) MUST NOT hold Ctrl+C / `/exit` hostage for the full window.
+ * See issue #2600.
+ */
+export declare const SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS = 2000;
+export declare function testSetSessionShutdownHandlerTimeoutMs(timeoutMs: number): void;
 /**
  * Events handled by the generic emit() method.
  * Events with dedicated emitXxx() methods are excluded for stronger type safety.

package/dist/types/mcp/manager.d.ts

@@ -118,8 +118,12 @@ export declare class MCPManager {
     waitForConnection(name: string): Promise<MCPServerConnection>;
     /**
      * Resolve auth and shell-command substitutions in config before connecting.
+     * Pass `oauth: false` to skip OAuth credential injection (used by reauth's
+     * unauthenticated probe, which must observe the server's bare 401).
      */
-    prepareConfig(config: MCPServerConfig): Promise<MCPServerConfig>;
+    prepareConfig(config: MCPServerConfig, options?: {
+        oauth?: boolean;
+    }): Promise<MCPServerConfig>;
     /**
      * Get all connected server names.
      */

package/dist/types/mcp/oauth-credentials.d.ts

@@ -0,0 +1,17 @@
+import type { AuthStorage } from "../session/auth-storage";
+import { type MCPStoredOAuthCredential } from "./oauth-flow";
+import type { MCPAuthConfig, MCPServerConfig } from "./types";
+export interface MCPOAuthCredentialLookup {
+    credentialId: string;
+    credential: MCPStoredOAuthCredential;
+}
+export type MCPOAuthRefreshMaterial = MCPStoredOAuthCredential | MCPAuthConfig | undefined;
+export declare function mcpOAuthCredentialIdsForServerUrl(serverUrl: string | undefined): string[];
+export declare function hasMcpAuthorizationHeader(config: MCPServerConfig): boolean;
+export declare function lookupMcpOAuthCredentialForServer(authStorage: AuthStorage | null | undefined, auth: MCPAuthConfig | undefined, serverUrl: string | undefined, options?: {
+    allowUrlKeyedFallback?: boolean;
+}): MCPOAuthCredentialLookup | undefined;
+export declare function lookupMcpOAuthCredential(authStorage: AuthStorage | null | undefined, config: MCPServerConfig): MCPOAuthCredentialLookup | undefined;
+export declare function selectMcpOAuthRefreshMaterial(credential: MCPStoredOAuthCredential, auth: MCPAuthConfig | undefined): MCPOAuthRefreshMaterial;
+export declare function removeManagedMcpOAuthCredential(authStorage: AuthStorage, credentialId: string | undefined): Promise<boolean>;
+export declare function removeManagedMcpOAuthCredentials(authStorage: AuthStorage, credentialIds: readonly (string | undefined)[]): Promise<boolean>;

package/dist/types/mcp/oauth-flow.d.ts

@@ -7,6 +7,38 @@
 import { OAuthCallbackFlow } from "@oh-my-pi/pi-ai/oauth/callback-server";
 import type { OAuthController, OAuthCredentials } from "@oh-my-pi/pi-ai/oauth/types";
 import type { FetchImpl } from "@oh-my-pi/pi-ai/types";
+import type { OAuthCredential } from "../session/auth-storage";
+/**
+ * Deterministic credential id for an MCP server URL scoped to an OMP profile.
+ *
+ * Local profile stores are already separate, but auth-broker storage shares one
+ * provider namespace across profiles. Including the profile in the provider key
+ * keeps a shared project `mcp.json` definition from making profile B overwrite
+ * or read profile A's OAuth row for the same server URL. The URL is used
+ * verbatim (query string included) because it can carry tenant selectors such
+ * as `?project_ref=`.
+ */
+export declare function mcpOAuthCredentialId(serverUrl: string, profile?: string | undefined): string;
+/** Whether a credential id was minted by OMP's MCP OAuth flows (either era). */
+export declare function isManagedMCPOAuthCredentialId(credentialId: string | undefined): credentialId is string;
+/**
+ * Profile segment of a profile-scoped `mcp_oauth:profile:<profile>:<serverUrl>`
+ * credential id, or `undefined` for legacy non-profile-scoped managed ids
+ * (`mcp_oauth:<url>`, `mcp_oauth_<rand>`). The server URL itself contains `:`
+ * and `/`, so only the segment between the prefix and the FIRST subsequent `:`
+ * is the profile; everything after it is the URL.
+ */
+export declare function mcpOAuthCredentialProfile(credentialId: string): string | undefined;
+/**
+ * Stored MCP OAuth credential. Refresh material is embedded so token refresh
+ * works without any `auth` block persisted in (possibly shared) config files.
+ */
+export interface MCPStoredOAuthCredential extends OAuthCredential {
+    tokenUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    resource?: string;
+}
 export interface MCPOAuthConfig {
     /** Authorization endpoint URL */
     authorizationUrl: string;
@@ -18,6 +50,15 @@ export interface MCPOAuthConfig {
     clientSecret?: string;
     /** OAuth scopes (space-separated) */
     scopes?: string;
+    /**
+     * `prompt` parameter for the authorization request. Defaults to `"consent"`
+     * so the provider always shows its authorize screen instead of silently
+     * re-approving the browser's current session — without it, reauthorizing to
+     * switch accounts/workspaces is impossible once a session cookie exists
+     * (RFC 6749 §3.1 requires servers to ignore the param when unsupported).
+     * Set to `""` to omit the parameter entirely.
+     */
+    prompt?: string;
     /** Exact redirect URI to advertise to the provider */
     redirectUri?: string;
     /** Custom callback port (default: 3000) */

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

@@ -58,6 +58,8 @@ interface MCPServerConfigBase {
         redirectUri?: string;
         callbackPort?: number;
         callbackPath?: string;
+        /** `prompt` param for the authorization request (default "consent"; "" to omit) */
+        prompt?: string;
     };
 }
 /** Stdio server configuration */

package/dist/types/modes/components/background-tan-message.d.ts

@@ -0,0 +1,9 @@
+import type { CustomMessage } from "../../session/messages";
+import { TranscriptBlock } from "./transcript-container";
+/**
+ * Single-line transcript pill for a `/tan` background-dispatch breadcrumb,
+ * styled as a sibling of the "Background job completed" line. The full
+ * system-notice content (the persisted `content`) is for the model only — the
+ * user sees one compact line, not the raw `<system-notice>` block.
+ */
+export declare function createBackgroundTanDispatchBlock(message: CustomMessage<unknown>): TranscriptBlock;

package/dist/types/modes/components/mcp-add-wizard.d.ts

@@ -8,19 +8,23 @@ import type { MCPServerConfig } from "../../mcp/types";
 type Scope = "user" | "project";
 /**
  * Result of the wizard's OAuth callback. `credentialId` is mandatory;
- * `clientId`/`clientSecret` are populated when the OAuth provider performed
- * dynamic client registration (or when the caller pre-supplied them) so the
- * wizard can fold them into the final `mcp.json` entry for refresh.
+ * `clientId` is populated when the OAuth provider performed dynamic client
+ * registration (or when the caller pre-supplied it) so the wizard can fold it
+ * into the final `mcp.json` entry. Refresh material (including any DCR client
+ * secret) is embedded in the stored credential, never written to config files.
  */
 export interface MCPAddWizardOAuthResult {
     credentialId: string;
     clientId?: string;
-    clientSecret?: string;
+    resource?: string;
+}
+interface MCPAddWizardOAuthOptions {
+    serverUrl?: string;
     resource?: string;
 }
 export declare class MCPAddWizard extends Container {
     #private;
-    constructor(onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void, onCancel: () => void, onOAuth?: (authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string, resource?: string) => Promise<MCPAddWizardOAuthResult>, onTestConnection?: (config: MCPServerConfig) => Promise<void>, onRender?: () => void, initialName?: string);
+    constructor(onComplete: (name: string, config: MCPServerConfig, scope: Scope) => void, onCancel: () => void, onOAuth?: (authUrl: string, tokenUrl: string, clientId: string, clientSecret: string, scopes: string, options?: MCPAddWizardOAuthOptions) => Promise<MCPAddWizardOAuthResult>, onTestConnection?: (config: MCPServerConfig) => Promise<void>, onRender?: () => void, initialName?: string);
     handleInput(keyData: string): void;
 }
 export {};

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

@@ -129,6 +129,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     lastEscapeTime: number;
     lastLeftTapTime: number;
     shutdownRequested: boolean;
+    /** True once `shutdown()` has begun teardown. Surfaced to the input
+     *  controller so a Ctrl+C arriving while teardown is in flight can hard-
+     *  abort the remaining work instead of stacking another no-op call. */
+    get isShuttingDown(): boolean;
     hookSelector: HookSelectorComponent | undefined;
     hookInput: HookInputComponent | undefined;
     hookEditor: HookEditorComponent | undefined;

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

@@ -140,6 +140,9 @@ export interface InteractiveModeContext {
     lastEscapeTime: number;
     lastLeftTapTime: number;
     shutdownRequested: boolean;
+    /** True once `shutdown()` has started. Read-only from the context;
+     *  controllers use this to skip work that races with teardown. */
+    readonly isShuttingDown: boolean;
     hookSelector: HookSelectorComponent | undefined;
     hookInput: HookInputComponent | undefined;
     hookEditor: HookEditorComponent | undefined;

package/dist/types/sdk.d.ts

@@ -48,7 +48,7 @@ export interface CreateAgentSessionOptions {
         thinkingLevel?: ThinkingLevel;
     }>;
     /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */
-    systemPrompt?: string[] | ((defaultPrompt: string[]) => string[]);
+    systemPrompt?: string | string[] | ((defaultPrompt: string[]) => string | string[]);
     /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
      * Keeps persisted session files isolated while reusing provider-side caches. */
     providerSessionId?: string;

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

@@ -11,6 +11,14 @@ export { type BranchSummaryMessage, type CompactionSummaryMessage, createBranchS
 import type { OutputMeta } from "../tools/output-meta";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
+export declare const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
+/** Details persisted on a `/tan` background-dispatch breadcrumb. */
+export interface BackgroundTanDispatchDetails {
+    jobId: string;
+    work: string;
+    /** Forked clone session file, named `<agentId>.jsonl`; the Agent Hub reads its transcript. */
+    sessionFile: string;
+}
 export interface SkillPromptDetails {
     name: string;
     path: string;

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

@@ -237,9 +237,15 @@ export declare class SessionManager {
     /**
      * Fork a session into the current project directory: copy history from another
      * session file while creating a fresh session file in this sessionDir.
+     *
+     * `options.sessionFile` pins the new session's file path (default: an
+     * auto-named `<timestamp>_<id>.jsonl` in `sessionDir`). Callers that register
+     * the fork as a named agent (e.g. `/tan`) pass `<agentId>.jsonl` so the
+     * persisted-subagent scan keys the agent by the same id the live ref uses.
      */
     static forkFrom(sourcePath: string, cwd: string, sessionDir?: string, storage?: SessionStorage, options?: {
         suppressBreadcrumb?: boolean;
+        sessionFile?: string;
     }): Promise<SessionManager>;
     /**
      * Open a specific session file.

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

@@ -0,0 +1,2 @@
+export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "render_mermaid", "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 type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];

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

@@ -23,6 +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 CheckpointState } from "./checkpoint";
 import { type TodoPhase } from "./todo";
 export * from "../edit";
@@ -341,9 +342,9 @@ export declare function filterInitialToolsForDiscoveryAll(initialToolNames: stri
  * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
  * `BUILTIN_TOOLS[name](session)` to construct a tool directly.
  */
-export declare const BUILTIN_TOOLS: Record<string, ToolFactory>;
+export declare const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory>;
 export declare const HIDDEN_TOOLS: Record<string, ToolFactory>;
-export type ToolName = keyof typeof BUILTIN_TOOLS;
+export type ToolName = BuiltinToolName;
 /**
  * Create tools from BUILTIN_TOOLS registry.
  */

package/dist/types/utils/external-editor.d.ts

@@ -1,4 +1,14 @@
-/** Returns the user's preferred editor command, or undefined if not configured. */
+/**
+ * Returns the user's preferred editor command, or a platform default.
+ *
+ * Resolution order:
+ *   1. `$VISUAL`
+ *   2. `$EDITOR`
+ *   3. `notepad` on Windows (always present in `%SystemRoot%\System32`)
+ *
+ * POSIX returns `undefined` when neither variable is set so the caller can
+ * surface a warning that nudges the user to configure one.
+ */
 export declare function getEditorCommand(): string | undefined;
 export interface OpenInEditorOptions {
     /** File extension for the temp file (default: ".md"). */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.13.0",
+	"version": "15.13.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,17 +47,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.13.0",
-		"@oh-my-pi/omp-stats": "15.13.0",
-		"@oh-my-pi/pi-agent-core": "15.13.0",
-		"@oh-my-pi/pi-ai": "15.13.0",
-		"@oh-my-pi/pi-catalog": "15.13.0",
-		"@oh-my-pi/pi-mnemopi": "15.13.0",
-		"@oh-my-pi/pi-natives": "15.13.0",
-		"@oh-my-pi/pi-tui": "15.13.0",
-		"@oh-my-pi/pi-utils": "15.13.0",
-		"@oh-my-pi/pi-wire": "15.13.0",
-		"@oh-my-pi/snapcompact": "15.13.0",
+		"@oh-my-pi/hashline": "15.13.1",
+		"@oh-my-pi/omp-stats": "15.13.1",
+		"@oh-my-pi/pi-agent-core": "15.13.1",
+		"@oh-my-pi/pi-ai": "15.13.1",
+		"@oh-my-pi/pi-catalog": "15.13.1",
+		"@oh-my-pi/pi-mnemopi": "15.13.1",
+		"@oh-my-pi/pi-natives": "15.13.1",
+		"@oh-my-pi/pi-tui": "15.13.1",
+		"@oh-my-pi/pi-utils": "15.13.1",
+		"@oh-my-pi/pi-wire": "15.13.1",
+		"@oh-my-pi/snapcompact": "15.13.1",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",