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

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

@@ -0,0 +1,24 @@
+import { type SubagentEventPayload, type SubagentLifecyclePayload, type SubagentProgressPayload } from "../../task";
+import type { EventBus } from "../../utils/event-bus";
+import type { RpcSubagentFrame, RpcSubagentMessagesResult, RpcSubagentSnapshot, RpcSubagentSubscriptionLevel } from "./rpc-types";
+export interface RpcSubagentTranscriptSelector {
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
+}
+type RpcSubagentOutput = (frame: RpcSubagentFrame) => void;
+export declare function readRpcSubagentTranscript(sessionFile: string, fromByte?: number): Promise<RpcSubagentMessagesResult>;
+export declare class RpcSubagentRegistry {
+    #private;
+    constructor(eventBus: EventBus, output: RpcSubagentOutput);
+    dispose(): void;
+    clear(): void;
+    setSubscriptionLevel(level: RpcSubagentSubscriptionLevel): void;
+    getSubscriptionLevel(): RpcSubagentSubscriptionLevel;
+    getSubagents(): RpcSubagentSnapshot[];
+    handleLifecycle(payload: SubagentLifecyclePayload): void;
+    handleProgress(payload: SubagentProgressPayload): void;
+    handleEvent(payload: SubagentEventPayload): void;
+    resolveSessionFile(selector: RpcSubagentTranscriptSelector): string;
+}
+export {};

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

@@ -9,7 +9,9 @@ import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
-import type { SessionStats } from "../../session/agent-session";
+import type { AgentSessionEvent, SessionStats } from "../../session/agent-session";
+import type { FileEntry } from "../../session/session-manager";
+import type { AgentProgress, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload } from "../../task";
 import type { TodoPhase } from "../../tools/todo";
 export type RpcCommand = {
     id?: string;
@@ -54,6 +56,19 @@ export type RpcCommand = {
     id?: string;
     type: "set_host_uri_schemes";
     schemes: RpcHostUriSchemeDefinition[];
+} | {
+    id?: string;
+    type: "set_subagent_subscription";
+    level: RpcSubagentSubscriptionLevel;
+} | {
+    id?: string;
+    type: "get_subagents";
+} | {
+    id?: string;
+    type: "get_subagent_messages";
+    subagentId?: string;
+    sessionFile?: string;
+    fromByte?: number;
 } | {
     id?: string;
     type: "set_model";
@@ -174,6 +189,29 @@ export interface RpcSessionState {
 export interface RpcHandoffResult {
     savedPath?: string;
 }
+export type RpcSubagentSubscriptionLevel = "off" | "progress" | "events";
+export interface RpcSubagentSnapshot {
+    id: string;
+    index: number;
+    agent: string;
+    agentSource: AgentProgress["agentSource"];
+    description?: string;
+    status: AgentProgress["status"];
+    task?: string;
+    assignment?: string;
+    sessionFile?: string;
+    lastUpdate: number;
+    progress?: AgentProgress;
+    parentToolCallId?: string;
+}
+export interface RpcSubagentMessagesResult {
+    sessionFile: string;
+    fromByte: number;
+    nextByte: number;
+    reset: boolean;
+    entries: FileEntry[];
+    messages: AgentMessage[];
+}
 export type RpcResponse = {
     id?: string;
     type: "response";
@@ -237,6 +275,28 @@ export type RpcResponse = {
     data: {
         schemes: string[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_subagent_subscription";
+    success: true;
+    data: {
+        level: RpcSubagentSubscriptionLevel;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_subagents";
+    success: true;
+    data: {
+        subagents: RpcSubagentSnapshot[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_subagent_messages";
+    success: true;
+    data: RpcSubagentMessagesResult;
 } | {
     id?: string;
     type: "response";
@@ -418,6 +478,20 @@ export type RpcResponse = {
     success: false;
     error: string;
 };
+export interface RpcSubagentLifecycleFrame {
+    type: "subagent_lifecycle";
+    payload: SubagentLifecyclePayload;
+}
+export interface RpcSubagentProgressFrame {
+    type: "subagent_progress";
+    payload: SubagentProgressPayload;
+}
+export interface RpcSubagentEventFrame {
+    type: "subagent_event";
+    payload: SubagentEventPayload;
+}
+export type RpcSubagentFrame = RpcSubagentLifecycleFrame | RpcSubagentProgressFrame | RpcSubagentEventFrame;
+export type RpcSessionEventFrame = AgentSessionEvent | RpcSubagentFrame;
 /** Emitted when an extension needs user input */
 export type RpcExtensionUIRequest = {
     type: "extension_ui_request";

package/dist/types/modes/setup-wizard/index.d.ts

@@ -14,4 +14,8 @@ export interface SetupSceneSelectionOptions {
 }
 export declare function selectSetupScenes(storedVersion: number, scenes: readonly SetupScene[], ctx?: InteractiveModeContext, options?: SetupSceneSelectionOptions): Promise<SetupScene[]>;
 export declare function markSetupWizardComplete(settings: Settings, version?: number): Promise<void>;
-export declare function runSetupWizard(ctx: InteractiveModeContext, scenes?: readonly SetupScene[]): Promise<void>;
+export interface RunSetupWizardOptions {
+    markComplete?: boolean;
+    playWelcomeIntro?: boolean;
+}
+export declare function runSetupWizard(ctx: InteractiveModeContext, scenes?: readonly SetupScene[], options?: RunSetupWizardOptions): Promise<void>;

package/dist/types/modes/setup-wizard/lazy.d.ts

@@ -0,0 +1,2 @@
+import type { InteractiveModeContext } from "../types";
+export declare function runProviderSetupWizard(ctx: InteractiveModeContext): Promise<void>;

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

@@ -82,6 +82,7 @@ export interface InteractiveModeContext {
     historyStorage?: HistoryStorage;
     mcpManager?: MCPManager;
     lspServers?: LspStartupServerInfo[];
+    titleSystemPrompt?: string;
     isInitialized: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
@@ -262,6 +263,7 @@ export interface InteractiveModeContext {
     handleResumeSession(sessionPath: string): Promise<void>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showProviderSetup(): Promise<void>;
     showHookConfirm(title: string, message: string): Promise<boolean>;
     showDebugSelector(): Promise<void>;
     showSessionObserver(): void;

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

@@ -1,5 +1,5 @@
 import type { SecretEntry } from "./obfuscator";
-export { deobfuscateSessionContext, obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
+export { deobfuscateSessionContext, obfuscateMessages, obfuscateProviderContext, obfuscateProviderTools, type SecretEntry, SecretObfuscator, } from "./obfuscator";
 /**
  * Load secrets from project-local and global secrets.yml files.
  * Project-local entries override global entries with matching content.

package/dist/types/secrets/obfuscator.d.ts

@@ -1,4 +1,4 @@
-import type { Message } from "@oh-my-pi/pi-ai";
+import type { Context, Message, Tool } from "@oh-my-pi/pi-ai";
 import type { SessionContext } from "../session/session-manager";
 export interface SecretEntry {
     type: "plain" | "regex";
@@ -17,7 +17,13 @@ export declare class SecretObfuscator {
     deobfuscate(text: string): string;
     /** Deep-walk an object, deobfuscating all string values. */
     deobfuscateObject<T>(obj: T): T;
+    /** Deep-walk an object, obfuscating all string values. */
+    obfuscateObject<T>(obj: T): T;
 }
 export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
-/** Obfuscate all text content in LLM messages (for outbound interception). */
+/** Obfuscate all string content in LLM messages (for outbound interception). */
 export declare function obfuscateMessages(obfuscator: SecretObfuscator, messages: Message[]): Message[];
+/** Obfuscate provider request context without walking live tool schema instances. */
+export declare function obfuscateProviderContext(obfuscator: SecretObfuscator | undefined, context: Context): Context;
+/** Convert tool schemas to wire JSON Schema before obfuscating provider-visible strings. */
+export declare function obfuscateProviderTools(obfuscator: SecretObfuscator | undefined, tools: Tool[] | undefined): Tool[] | undefined;

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

@@ -127,6 +127,8 @@ export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
     settings: Settings;
+    /** Whether the caller explicitly requested yolo/auto-approve behavior for this session. */
+    autoApprove?: boolean;
     /** Models to cycle through with Ctrl+P (from --models flag) */
     scopedModels?: Array<{
         model: Model;
@@ -548,7 +550,14 @@ export declare class AgentSession {
      * @throws Error if streaming and no streamingBehavior specified
      * @throws Error if no model selected or no API key available (when not streaming)
      */
-    prompt(text: string, options?: PromptOptions): Promise<void>;
+    /**
+     * Returns `false` when the command was fully handled locally (extension or
+     * custom-TS command consumed without calling the LLM). Returns `true` when
+     * the prompt was forwarded to the agent — either directly or queued as a
+     * steer/follow-up. Callers that render a UI or manage turn lifecycle (e.g.
+     * the ACP agent) use this to know whether to expect an `agent_end` event.
+     */
+    prompt(text: string, options?: PromptOptions): Promise<boolean>;
     promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
@@ -700,7 +709,8 @@ export declare class AgentSession {
      */
     cycleRoleModels(roleOrder: readonly string[], direction?: "forward" | "backward"): Promise<RoleModelCycleResult | undefined>;
     /**
-     * Get all available models with valid API keys.
+     * Get all available models with valid API keys, filtered by `enabledModels` when configured.
+     * See {@link filterAvailableModelsByEnabledPatterns} for supported pattern forms and limitations.
      */
     getAvailableModels(): Model[];
     /**
@@ -849,9 +859,11 @@ export declare class AgentSession {
      * @param command The bash command to execute
      * @param onChunk Optional streaming callback for output
      * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
+     * @param options.useUserShell If true, allow caller to request configured user-shell routing
      */
     executeBash(command: string, onChunk?: (chunk: string) => void, options?: {
         excludeFromContext?: boolean;
+        useUserShell?: boolean;
     }): Promise<BashResult>;
     /**
      * Record a bash execution result in session history.

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

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

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

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

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

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

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

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

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

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

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

@@ -42,6 +42,7 @@ export interface ExecutorOptions {
     description?: string;
     index: number;
     id: string;
+    parentToolCallId?: string;
     modelOverride?: string | string[];
     /**
      * Active model selector of the parent session, used as an auth-aware fallback

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

@@ -8,7 +8,7 @@ export { loadBundledAgents as BUNDLED_AGENTS } from "./agents";
 export { discoverCommands, expandCommand, getCommand } from "./commands";
 export { discoverAgents, getAgent } from "./discovery";
 export { AgentOutputManager } from "./output-manager";
-export type { AgentDefinition, AgentProgress, SingleResult, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
+export type { AgentDefinition, AgentProgress, SingleResult, SubagentEventPayload, SubagentLifecyclePayload, SubagentProgressPayload, TaskParams, TaskToolDetails, } from "./types";
 export { TASK_SUBAGENT_EVENT_CHANNEL, TASK_SUBAGENT_LIFECYCLE_CHANNEL, TASK_SUBAGENT_PROGRESS_CHANNEL, taskSchema, } from "./types";
 export declare const READ_ONLY_TOOL_NAMES: ReadonlySet<string>;
 export declare function isReadOnlyAgent(agent: AgentDefinition): boolean;
@@ -39,5 +39,5 @@ export declare class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskT
      * Create a TaskTool instance with async agent discovery.
      */
     static create(session: ToolSession): Promise<TaskTool>;
-    execute(_toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
+    execute(toolCallId: string, rawParams: unknown, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TaskToolDetails>): Promise<AgentToolResult<TaskToolDetails>>;
 }

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

@@ -1,6 +1,7 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import * as z from "zod/v4";
+import type { AgentSessionEvent } from "../session/agent-session";
 import { type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
@@ -21,10 +22,16 @@ export interface SubagentProgressPayload {
     agent: string;
     agentSource: AgentSource;
     task: string;
+    parentToolCallId?: string;
     assignment?: string;
     progress: AgentProgress;
     sessionFile?: string;
 }
+/** Payload emitted on TASK_SUBAGENT_EVENT_CHANNEL */
+export interface SubagentEventPayload {
+    id: string;
+    event: AgentSessionEvent;
+}
 /** Payload emitted on TASK_SUBAGENT_LIFECYCLE_CHANNEL */
 export interface SubagentLifecyclePayload {
     id: string;
@@ -33,6 +40,7 @@ export interface SubagentLifecyclePayload {
     description?: string;
     status: "started" | "completed" | "failed" | "aborted";
     sessionFile?: string;
+    parentToolCallId?: string;
     index: number;
 }
 /** Single task item for parallel execution (default shape with context enabled). */

package/dist/types/thinking.d.ts

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

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

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

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

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

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

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

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

@@ -10,6 +10,7 @@ export interface GitRepository {
     gitEntryPath: string;
     headPath: string;
     repoRoot: string;
+    isReftable?: boolean;
 }
 export interface GitStatusSummary {
     staged: number;
@@ -327,7 +328,7 @@ export declare const ls: {
 };
 export declare const head: {
     /** Full HEAD state (branch, commit, repo info). */
-    resolve(cwd: string): Promise<GitHeadState | null>;
+    resolve(cwd: string, signal?: AbortSignal): Promise<GitHeadState | null>;
     /** Full HEAD state (synchronous). */
     resolveSync(cwd: string): GitHeadState | null;
     /** Current HEAD commit SHA. */
@@ -338,12 +339,24 @@ export declare const head: {
 export declare const repo: {
     /** Resolve the repository root (may be a worktree root). */
     root(cwd: string, signal?: AbortSignal): Promise<string | null>;
-    /** Resolve the primary repository root (not a worktree — the main checkout). */
+    /** Resolve the primary checkout root, or the shared common dir for bare-repo worktrees. */
     primaryRoot(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /**
+     * Sync sibling of {@link primaryRoot}. Resolves only via on-disk `.git`/
+     * `commondir` walking — no subprocess fallback — so it stays usable from
+     * paths where async I/O is impractical (e.g. `computeBankScope`). Returns
+     * `null` when `cwd` is outside a repository. Bare-repo worktrees resolve to
+     * the shared common dir (`foo.git`) because they have no primary checkout.
+     */
+    primaryRootSync(cwd: string): string | null;
     /** Full GitRepository metadata (sync). */
     resolveSync(cwd: string): GitRepository | null;
     /** Full GitRepository metadata. */
     resolve(cwd: string): Promise<GitRepository | null>;
+    /** Check if the repository uses the reftable reference storage format (sync). */
+    isReftableSync(repository: GitRepository): boolean;
+    /** Check if the repository uses the reftable reference storage format. */
+    isReftable(repository: GitRepository): Promise<boolean>;
 };
 export interface GhCommandResult {
     exitCode: number;

package/dist/types/utils/title-generator.d.ts

@@ -15,9 +15,10 @@ export declare function raceFirstNonNull<T>(primary: Promise<T | null>, startFal
  *   to produce request metadata (e.g. user_id for session attribution). Using a
  *   resolver instead of a pre-evaluated value ensures the metadata's account_uuid
  *   reflects the credential actually selected for this request.
+ * @param customSystemPrompt Optional title-specific system prompt override
  */
-export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined): Promise<string | null>;
-export declare function generateTitleOnline(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, signal?: AbortSignal): Promise<string | null>;
+export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, customSystemPrompt?: string): Promise<string | null>;
+export declare function generateTitleOnline(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, signal?: AbortSignal, customSystemPrompt?: string): Promise<string | null>;
 export declare function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string;
 /**
  * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.

package/package.json

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

package/src/auto-thinking/classifier.ts

@@ -86,6 +86,7 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Prom
 			apiKey: deps.registry.resolver(model.provider, {
 				sessionId: deps.sessionId,
 				baseUrl: model.baseUrl,
+				modelId: model.id,
 			}),
 			maxTokens,
 			disableReasoning: true,

package/src/cli/args.ts

@@ -14,6 +14,7 @@ export interface Args {
 	allowHome?: boolean;
 	provider?: string;
 	model?: string;
+	config?: string[];
 	smol?: string;
 	slow?: string;
 	plan?: string;
@@ -111,6 +112,8 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.allowHome = true;
 		} else if (arg === "--cwd" && i + 1 < args.length) {
 			result.cwd = args[++i];
+		} else if (arg === "--config" && i + 1 < args.length) {
+			result.config = [...(result.config ?? []), args[++i]];
 		} else if (arg === "--mode" && i + 1 < args.length) {
 			const mode = args[++i];
 			if (mode === "text" || mode === "json" || mode === "rpc" || mode === "acp" || mode === "rpc-ui") {

package/src/cli-commands.ts

@@ -38,6 +38,18 @@ export const commands: CommandEntry[] = [
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];
 
+const RESERVED_TOP_LEVEL_WORDS = new Map<string, string>([
+	[
+		"extensions",
+		'`omp extensions` is not a management command. Use `omp plugin list` / `omp plugin install`, or run `omp launch extensions` if you meant to send "extensions" as a prompt.',
+	],
+]);
+
+export function reservedTopLevelWordMessage(first: string | undefined, argc = 1): string | undefined {
+	if (argc !== 1 || !first || first.startsWith("-") || first.startsWith("@")) return undefined;
+	return RESERVED_TOP_LEVEL_WORDS.get(first);
+}
+
 /**
  * Return true when `first` matches a registered subcommand name or alias.
  *
@@ -48,3 +60,20 @@ export function isSubcommand(first: string | undefined): boolean {
 	if (!first || first.startsWith("-") || first.startsWith("@")) return false;
 	return commands.some(entry => entry.name === first || entry.aliases?.includes(first));
 }
+
+export type ResolvedCliArgv = { argv: string[] } | { error: string };
+
+/**
+ * Decide what the CLI runner should do with raw argv: reject bare reserved
+ * management words, pass help/version through untouched, and route everything
+ * that is not a known subcommand to `launch`.
+ */
+export function resolveCliArgv(argv: string[]): ResolvedCliArgv {
+	const first = argv[0];
+	const reservedMessage = reservedTopLevelWordMessage(first, argv.length);
+	if (reservedMessage) return { error: reservedMessage };
+	if (first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help") {
+		return { argv };
+	}
+	return { argv: isSubcommand(first) ? argv : ["launch", ...argv] };
+}