@oh-my-pi/pi-coding-agent 16.2.6 → 16.2.7

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

@@ -1,5 +1,5 @@
 import type { ResolvedThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, ServiceTier, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, ServiceTierByFamily, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import { type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
 import { type CanonicalModelQueryOptions } from "../config/model-registry";
@@ -65,8 +65,8 @@ export interface BenchSummary {
     maxTokens: number;
     models: BenchModelReport[];
     failures: number;
-    /** Requested service tier passed to every request; absent when none was requested. Scoped tiers (`openai-only`/`claude-only`) may be dropped per-provider downstream. */
-    serviceTier?: ServiceTier;
+    /** Requested per-family service tiers, resolved per model before reaching the wire. */
+    serviceTierByFamily?: ServiceTierByFamily;
 }
 type BenchStreamSimple = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
 export interface BenchDependencies {

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

@@ -22,7 +22,7 @@ export default class Bench extends Command {
         };
         "service-tier": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
-            options: readonly ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+            options: readonly ["none", "auto", "default", "flex", "scale", "priority"];
         };
         json: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;

package/dist/types/config/service-tier.d.ts

@@ -1,34 +1,49 @@
-import type { ServiceTier } from "@oh-my-pi/pi-ai";
+import type { ServiceTier, ServiceTierByFamily } from "@oh-my-pi/pi-ai";
 import type { SubmenuOption } from "./settings-schema";
 /**
- * Service-tier setting values shared by every "Service Tier" setting. `"none"`
- * is the omit-the-parameter sentinel; the remaining values mirror
- * {@link ServiceTier}.
+ * Per-family service-tier setting values. `"none"` is the omit-the-parameter
+ * sentinel; the rest mirror the wire {@link ServiceTier} values each provider
+ * family actually realizes. OpenAI accepts the full set; Anthropic realizes
+ * only `priority` (fast mode); Google (Gemini API + Vertex) realizes
+ * `flex`/`priority`.
  */
-export declare const SERVICE_TIER_SETTING_VALUES: readonly ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
-export type ServiceTierSettingValue = (typeof SERVICE_TIER_SETTING_VALUES)[number];
-/** Variant value set for scoped service-tier settings (subagent/advisor) that can defer to the main agent. */
-export declare const SERVICE_TIER_INHERIT_SETTING_VALUES: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+export declare const SERVICE_TIER_OPENAI_VALUES: readonly ["none", "auto", "default", "flex", "scale", "priority"];
+export declare const SERVICE_TIER_ANTHROPIC_VALUES: readonly ["none", "priority"];
+export declare const SERVICE_TIER_GOOGLE_VALUES: readonly ["none", "flex", "priority"];
+export type ServiceTierOpenAISettingValue = (typeof SERVICE_TIER_OPENAI_VALUES)[number];
+export type ServiceTierAnthropicSettingValue = (typeof SERVICE_TIER_ANTHROPIC_VALUES)[number];
+export type ServiceTierGoogleSettingValue = (typeof SERVICE_TIER_GOOGLE_VALUES)[number];
+/**
+ * Inherit-capable single value for the subagent/advisor tiers. The chosen tier
+ * is broadcast across families and applied to whichever family the spawned
+ * model belongs to (clamped to what that family realizes); `"inherit"` defers
+ * to the main agent's live per-family selection.
+ */
+export declare const SERVICE_TIER_INHERIT_SETTING_VALUES: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority"];
 export type ServiceTierInheritSettingValue = (typeof SERVICE_TIER_INHERIT_SETTING_VALUES)[number];
-/** Submenu descriptions shared by the base `serviceTier` setting. */
-export declare const SERVICE_TIER_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierSettingValue>>;
-/** Submenu descriptions for inherit-capable service-tier settings. */
+export declare const SERVICE_TIER_OPENAI_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierOpenAISettingValue>>;
+export declare const SERVICE_TIER_ANTHROPIC_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierAnthropicSettingValue>>;
+export declare const SERVICE_TIER_GOOGLE_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierGoogleSettingValue>>;
 export declare const SERVICE_TIER_INHERIT_OPTIONS: ReadonlyArray<SubmenuOption<ServiceTierInheritSettingValue>>;
+/** Map a per-family setting value to a wire {@link ServiceTier}, or `undefined` to omit. */
+export declare function serviceTierSettingToTier(value: string): ServiceTier | undefined;
+/** Assemble the live per-family tier map from the three `tier.*` setting values. */
+export declare function buildServiceTierByFamily(openai: string, anthropic: string, google: string): ServiceTierByFamily;
 /**
- * Resolve a service-tier setting value to the wire {@link ServiceTier} (or
- * `undefined` to omit). `"inherit"` defers to `inherited`; `"none"` omits.
+ * Broadcast a single chosen tier across families, clamped to what each family
+ * realizes: OpenAI takes any tier, Anthropic only `priority`, Google only
+ * `flex`/`priority`. Used by the subagent/advisor single-value settings and the
+ * `omp bench --service-tier` flag, which apply one tier to whatever family the
+ * target model belongs to.
  */
-export declare function resolveServiceTierSetting(value: string, inherited: ServiceTier | undefined): ServiceTier | undefined;
+export declare function serviceTierForAllFamilies(tier: ServiceTier | undefined): ServiceTierByFamily;
 /**
- * Resolve the `serviceTier` *setting value* to stamp onto a subagent's settings
- * snapshot.
+ * Resolve a subagent/advisor service-tier setting to a per-family map.
  *
- * - A concrete `subagentSetting` (`"none"` or a tier) wins outright.
- * - `"inherit"` defers to the parent's live effective tier when the caller has a
- *   live session (`inherited` passed as `ServiceTier | null`, where `null` means
- *   the parent explicitly has no tier — e.g. `/fast off`). When no live session
- *   is available (`inherited === undefined`, e.g. cold subagent revive) it falls
- *   back to the parent's configured `serviceTier` setting so behavior matches a
- *   plain settings snapshot.
+ * - A concrete tier is broadcast across families (see
+ *   {@link serviceTierForAllFamilies}).
+ * - `"none"` yields an empty map.
+ * - `"inherit"` defers to `inherited` — the parent's live per-family tiers when
+ *   a live session supplied them, else the empty map.
  */
-export declare function resolveSubagentServiceTier(subagentSetting: string, configuredTier: ServiceTierSettingValue, inherited: ServiceTier | null | undefined): ServiceTierSettingValue;
+export declare function resolveSubagentServiceTier(setting: string, inherited: ServiceTierByFamily): ServiceTierByFamily;

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

@@ -1232,65 +1232,65 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
-    readonly serviceTier: {
+    readonly "tier.openai": {
         readonly type: "enum";
-        readonly values: readonly ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+        readonly values: readonly ["none", "auto", "default", "flex", "scale", "priority"];
         readonly default: "none";
         readonly ui: {
             readonly tab: "model";
             readonly group: "Sampling";
-            readonly label: "Service Tier";
-            readonly description: 'Processing priority hint (none = omit). OpenAI accepts the tier values directly; Anthropic realizes `priority` as `speed: "fast"` on supported Opus models. Scoped values target one family.';
-            readonly options: readonly SubmenuOption<"auto" | "claude-only" | "default" | "flex" | "none" | "openai-only" | "priority" | "scale">[];
+            readonly label: "Service Tier — OpenAI";
+            readonly description: "Processing tier for OpenAI / OpenAI-Codex requests, and OpenAI-family models routed via OpenRouter (none = omit). Sent as `service_tier`.";
+            readonly options: readonly SubmenuOption<"auto" | "default" | "flex" | "none" | "priority" | "scale">[];
         };
     };
-    readonly serviceTierSubagent: {
+    readonly "tier.anthropic": {
         readonly type: "enum";
-        readonly values: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
-        readonly default: "inherit";
+        readonly values: readonly ["none", "priority"];
+        readonly default: "none";
         readonly ui: {
             readonly tab: "model";
             readonly group: "Sampling";
-            readonly label: "Service Tier - Subagent";
-            readonly description: "Service Tier for spawned task/eval subagents. Inherit = match the main agent's live tier (tracks /fast); pick a value to scope subagents independently.";
-            readonly options: readonly SubmenuOption<"auto" | "claude-only" | "default" | "flex" | "inherit" | "none" | "openai-only" | "priority" | "scale">[];
+            readonly label: "Service Tier — Anthropic";
+            readonly description: 'Processing tier for Claude requests. `priority` realizes fast mode (`speed: "fast"`) on supported direct Anthropic models; ignored on Bedrock/Vertex Claude and via OpenRouter.';
+            readonly options: readonly SubmenuOption<"none" | "priority">[];
         };
     };
-    readonly serviceTierAdvisor: {
+    readonly "tier.google": {
         readonly type: "enum";
-        readonly values: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+        readonly values: readonly ["none", "flex", "priority"];
         readonly default: "none";
         readonly ui: {
             readonly tab: "model";
             readonly group: "Sampling";
-            readonly label: "Service Tier - Advisor";
-            readonly description: "Service Tier for the advisor model. None = standard processing; Inherit = match the main agent's live tier; pick a value (e.g. Priority) to run the advisor on a faster serving path.";
-            readonly options: readonly SubmenuOption<"auto" | "claude-only" | "default" | "flex" | "inherit" | "none" | "openai-only" | "priority" | "scale">[];
-            readonly condition: "advisorEnabled";
+            readonly label: "Service Tier — Google";
+            readonly description: "Processing tier for Gemini (Google AI Studio + Vertex) requests, and Google-family models routed via OpenRouter (none = omit). Sent as the top-level `serviceTier` field.";
+            readonly options: readonly SubmenuOption<"flex" | "none" | "priority">[];
         };
     };
-    readonly fastModeScope: {
+    readonly "tier.subagent": {
         readonly type: "enum";
-        readonly values: readonly ["both", "openai", "claude"];
-        readonly default: "both";
+        readonly values: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority"];
+        readonly default: "inherit";
         readonly ui: {
             readonly tab: "model";
             readonly group: "Sampling";
-            readonly label: "Fast Mode Scope";
-            readonly description: 'Which providers `/fast on` (and the fast-mode toggle) target. "both" = priority on every supported provider; "openai"/"claude" scope it to one family (mirrors serviceTier openai-only/claude-only).';
-            readonly options: readonly [{
-                readonly value: "both";
-                readonly label: "Both";
-                readonly description: "Priority on every supported provider";
-            }, {
-                readonly value: "openai";
-                readonly label: "OpenAI only";
-                readonly description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere";
-            }, {
-                readonly value: "claude";
-                readonly label: "Claude only";
-                readonly description: "Anthropic fast mode on direct Claude requests; ignored elsewhere";
-            }];
+            readonly label: "Service Tier — Subagent";
+            readonly description: "Service Tier for spawned task/eval subagents. Inherit = match the main agent's live per-family tiers (tracks /fast); pick a value to apply it to whichever family the subagent's model belongs to.";
+            readonly options: readonly SubmenuOption<"auto" | "default" | "flex" | "inherit" | "none" | "priority" | "scale">[];
+        };
+    };
+    readonly "tier.advisor": {
+        readonly type: "enum";
+        readonly values: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority"];
+        readonly default: "none";
+        readonly ui: {
+            readonly tab: "model";
+            readonly group: "Sampling";
+            readonly label: "Service Tier — Advisor";
+            readonly description: "Service Tier for the advisor model. None = standard processing; Inherit = match the main agent's live per-family tiers; pick a value to apply it to the advisor model's family.";
+            readonly options: readonly SubmenuOption<"auto" | "default" | "flex" | "inherit" | "none" | "priority" | "scale">[];
+            readonly condition: "advisorEnabled";
         };
     };
     readonly "retry.enabled": {
@@ -2228,7 +2228,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "snapcompact.shape": {
         readonly type: "enum";
-        readonly values: readonly ["auto", ...("11on16-bw" | "5x8-bw" | "5x8-sent" | "6x12-dim" | "6x6u-bw" | "6x6u-sent" | "8on16-bw" | "8on22-bw" | "8x13-bw" | "8x8r-bw" | "8x8r-sent" | "8x8u-bw" | "8x8u-sent" | "doc-8on16-bw" | "doc-8on16-sent" | "doc-8on16-sent-dim")[]];
+        readonly values: readonly ["auto", ...("11on16-bw" | "5x8-bw" | "5x8-sent" | "6x12-dim" | "6x6u-bw" | "6x6u-sent" | "8on16-bw" | "8on22-bw" | "8x13-bw" | "8x8r-bw" | "8x8r-sent" | "8x8u-bw" | "8x8u-sent" | "doc-8on16-bw" | "doc-8on16-sent" | "doc-8on16-sent-dim" | "silver16-bw")[]];
         readonly default: "auto";
         readonly ui: {
             readonly tab: "context";

package/dist/types/mcp/config-writer.d.ts

@@ -51,3 +51,51 @@ export declare function readDisabledServers(filePath: string): Promise<string[]>
  * Add or remove a server name from the disabled servers list.
  */
 export declare function setServerDisabled(filePath: string, name: string, disabled: boolean): Promise<void>;
+/**
+ * Read the user-level force-enable list (allowlist that overrides a
+ * non-writable source config's `enabled: false`).
+ */
+export declare function readEnabledServers(filePath: string): Promise<string[]>;
+/**
+ * Add or remove a server name from the user-level force-enable list.
+ * The list overrides a discovered server's `enabled: false` flag but does
+ * NOT override the `disabledServers` denylist.
+ */
+export declare function setServerForceEnabled(filePath: string, name: string, force: boolean): Promise<void>;
+/** Paths and target state for toggling one MCP server across known config files. */
+export interface SetMcpServerEnabledOptions {
+    userPath: string;
+    projectPath: string;
+    /**
+     * Absolute path to the loaded row's source mcp.json. Provide ONLY for
+     * formats this codebase owns (native `.omp/mcp.json` and `mcp-json`
+     * `mcp.json`/`.mcp.json`). Tool-owned configs (opencode.json, claude.json,
+     * settings.json …) MUST be omitted; we never mutate another tool's file.
+     */
+    sourcePath?: string;
+    name: string;
+    enabled: boolean;
+}
+/**
+ * Flip a server's enabled/disabled state regardless of where it lives.
+ *
+ * Resolution order, mirroring `/mcp enable` / `/mcp disable` plus the dashboard
+ * fix for non-writable source configs:
+ *
+ * - Server found in `sourcePath` (writable) → write `enabled` on that entry.
+ * - Else server in project mcp.json → write `enabled` there.
+ * - Else server in user mcp.json → write `enabled` there.
+ * - Else (server defined in a tool-owned source like opencode.json, OR a
+ *   purely discovered server):
+ *   - Disable → add to the user-level `disabledServers` denylist.
+ *   - Enable → add to the user-level `enabledServers` allowlist so the
+ *     dashboard / runtime override the non-writable source's
+ *     `enabled: false` flag.
+ *
+ * Cleanup invariants — on every call:
+ * - Re-enable clears any stale denylist entry so a server disabled via
+ *   `/mcp disable` and re-enabled here doesn't stay suppressed.
+ * - Disable clears any stale allowlist entry so re-disabling a
+ *   force-enabled server actually takes effect.
+ */
+export declare function setMcpServerEnabled(options: SetMcpServerEnabledOptions): Promise<void>;

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

@@ -88,7 +88,10 @@ export declare const MCP_CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/
 export interface MCPConfigFile {
     $schema?: string;
     mcpServers?: Record<string, MCPServerConfig>;
+    /** Names to hide regardless of any source `enabled` flag. Highest precedence. */
     disabledServers?: string[];
+    /** Names to force-enable when a non-writable source reports `enabled: false`. */
+    enabledServers?: string[];
 }
 /** MCP implementation info */
 export interface MCPImplementation {

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

@@ -15,7 +15,7 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import { Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StreamFn, ThinkingLevel, type ToolChoiceDirective } from "@oh-my-pi/pi-agent-core";
 import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core/compaction";
-import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, ServiceTierByFamily, ServiceTierFamily, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
 import { type AdvisorConfig } from "../advisor";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
@@ -141,6 +141,8 @@ export interface AgentSessionConfig {
     }>;
     /** Initial session thinking selector. */
     thinkingLevel?: ConfiguredThinkingLevel;
+    /** Initial per-family service tiers (OpenAI / Anthropic / Google) for the live session. */
+    serviceTierByFamily?: ServiceTierByFamily;
     /** Prompt templates for expansion */
     promptTemplates?: PromptTemplate[];
     /** File-based slash commands for expansion */
@@ -546,7 +548,8 @@ export declare class AgentSession {
     get isAutoThinking(): boolean;
     /** The level `auto` resolved to for the current turn (undefined until classified). */
     autoResolvedThinkingLevel(): Effort | undefined;
-    get serviceTier(): ServiceTier | undefined;
+    /** Live per-family service tiers (OpenAI / Anthropic / Google). */
+    get serviceTierByFamily(): ServiceTierByFamily;
     /** Whether agent is currently streaming a response */
     get isStreaming(): boolean;
     get isAborting(): boolean;
@@ -919,23 +922,29 @@ export declare class AgentSession {
      */
     cycleThinkingLevel(): ConfiguredThinkingLevel | undefined;
     /**
-     * True when *any* fast-mode-granting service tier is configured, regardless
-     * of whether the active model's provider actually realizes it. Used by the
-     * toggle (`/fast on|off`) so re-toggling a scoped tier (`openai-only`,
-     * `claude-only`) doesn't silently broaden it to unscoped `priority`.
+     * True when the currently selected model's family is set to `priority` — the
+     * `/fast` on/off state for the active model. Returns false when no model is
+     * selected or the model exposes no service-tier family (e.g. Fireworks, which
+     * has its own Providers › Fireworks Tier toggle).
      *
-     * For "is fast mode actually applied to the next request?" use
-     * {@link isFastModeActive} instead — that one respects the model's provider.
+     * For "is priority actually applied to the next request?" use
+     * {@link isFastModeActive} instead.
      */
     isFastModeEnabled(): boolean;
     /**
-     * True when the configured `serviceTier` resolves to `"priority"` for the
-     * *currently selected model's provider*. Returns false for scoped tiers
-     * that don't match (e.g. `"openai-only"` on an anthropic model) and when
-     * no model is selected.
+     * True when `priority` is actually realized on the wire for the currently
+     * selected model (OpenAI/Google `service_tier`, direct Anthropic fast mode,
+     * or Fireworks priority). Returns false for tiers the active model can't
+     * realize and when no model is selected.
      */
     isFastModeActive(): boolean;
-    setServiceTier(serviceTier: ServiceTier | undefined): void;
+    /** Set one family's tier (or clear it with `undefined`); persists the change. */
+    setServiceTierFamily(family: ServiceTierFamily, tier: ServiceTier | undefined): void;
+    /**
+     * `/fast on|off` targets the family of the currently selected model: it sets
+     * (or clears) that family's `priority` tier. Models without a service-tier
+     * family (Fireworks, or providers with no tier knob) have nothing to toggle.
+     */
     setFastMode(enabled: boolean): void;
     toggleFastMode(): boolean;
     /**
@@ -1102,6 +1111,17 @@ export declare class AgentSession {
     get isEvalRunning(): boolean;
     /** Whether there are pending Python messages waiting to be flushed */
     get hasPendingPythonMessages(): boolean;
+    /**
+     * Surfaces (and consumes) IRC incoming asides that have reached this running
+     * session but have not yet been folded into the next model step.
+     *
+     * The inbox tool injects the formatted body into the tool result, so the
+     * model sees it once via the result. Leaving the record in
+     * {@link #pendingIrcAsides} would let the aside provider deliver it a second
+     * time at the next step boundary — including on `peek`, which is why peek
+     * also drains here.
+     */
+    drainPendingIrcInboxMessages(agentId: string): IrcMessage[];
     /**
      * Deliver an IRC message into this session (recipient side; called by the
      * IrcBus). Emits the `irc_message` session event for UI cards and injects

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

@@ -184,7 +184,7 @@ export interface FileMentionMessage {
         /** File size in bytes, if known. */
         byteSize?: number;
         /** Why the file contents were omitted from auto-read. */
-        skippedReason?: "tooLarge";
+        skippedReason?: "tooLarge" | "binary";
         image?: ImageContent;
     }>;
     timestamp: number;

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

@@ -1,12 +1,12 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { ServiceTier } from "@oh-my-pi/pi-ai";
+import { type ServiceTierByFamily } from "@oh-my-pi/pi-ai";
 import { type CompactionEntry, type SessionEntry } from "./session-entries";
 export interface SessionContext {
     messages: AgentMessage[];
     thinkingLevel?: string;
     /** Configured thinking selector (`"auto"` or a concrete level) from the latest change. */
     configuredThinkingLevel?: string;
-    serviceTier?: ServiceTier;
+    serviceTier?: ServiceTierByFamily;
     /** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
     models: Record<string, string>;
     /** Names of TTSR rules that have been injected this session */

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

@@ -1,5 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, MessageAttribution, ServiceTier, TextContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent, MessageAttribution, ServiceTierByFamily, TextContent } from "@oh-my-pi/pi-ai";
 export declare const CURRENT_SESSION_VERSION = 3;
 export declare const SESSION_TITLE_SLOT_BYTES = 256;
 export declare const SESSION_TITLE_SLOT_ENTRY_TYPE = "title";
@@ -59,7 +59,7 @@ export interface ModelChangeEntry extends SessionEntryBase {
 }
 export interface ServiceTierChangeEntry extends SessionEntryBase {
     type: "service_tier_change";
-    serviceTier: ServiceTier | null;
+    serviceTier: ServiceTierByFamily | null;
 }
 export interface CompactionEntry<T = unknown> extends SessionEntryBase {
     type: "compaction";

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

@@ -1,4 +1,4 @@
-import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent, Message, MessageAttribution, ServiceTierByFamily, TextContent } from "@oh-my-pi/pi-ai";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutOptions, type BlobPutResult } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
@@ -141,7 +141,7 @@ export declare class SessionManager {
     appendMessage(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage): string;
     /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
     appendThinkingLevelChange(thinkingLevel?: string, configured?: string): string;
-    appendServiceTierChange(serviceTier: ServiceTier | null): string;
+    appendServiceTierChange(serviceTier: ServiceTierByFamily | null): string;
     appendModeChange(mode: string, data?: Record<string, unknown>): string;
     /**
      * Append a model change as a child of the current leaf, then advance the leaf.

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

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

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

@@ -4,7 +4,7 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ServiceTier } from "@oh-my-pi/pi-ai";
+import type { ServiceTierByFamily } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -123,12 +123,12 @@ export interface ExecutorOptions {
     modelRegistry?: ModelRegistry;
     settings?: Settings;
     /**
-     * Parent session's live effective service tier, the source of truth for a
-     * subagent whose `serviceTierSubagent` is `"inherit"`. `null` = the parent
+     * Parent session's live per-family service tiers, the source of truth for a
+     * subagent whose `tier.subagent` is `"inherit"`. `null` = the parent
      * explicitly has no tier (e.g. `/fast off`); omitted = no live session, so
-     * inherit falls back to the configured `serviceTier` setting.
+     * inherit falls back to the subagent's configured `tier.*` settings.
      */
-    parentServiceTier?: ServiceTier | null;
+    parentServiceTier?: ServiceTierByFamily | null;
     /** Override local:// protocol options so subagent shares parent's local:// root */
     localProtocolOptions?: LocalProtocolOptions;
     /**
@@ -191,7 +191,7 @@ export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputA
  * Create proxy tools that reuse the parent's MCP connections.
  */
 export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
-export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTier | null): Settings;
+export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTierByFamily | null): Settings;
 export declare function finalizeSubagentLifecycle(args: {
     id: string;
     session: AgentSession;

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

@@ -334,6 +334,12 @@ export interface SingleResult {
     patchPath?: string;
     /** Branch name for isolated branch-mode output */
     branchName?: string;
+    /**
+     * Baseline commit SHA the task branch was created from. Passed to
+     * `mergeTaskBranches` so cherry-pick uses the inclusive range
+     * `branchBaseSha..branchName` and preserves every agent commit's message.
+     */
+    branchBaseSha?: string;
     /** Nested repo patches to apply after parent merge */
     nestedPatches?: NestedRepoPatch[];
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */

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

@@ -80,11 +80,32 @@ export declare function cleanupIsolation(handle: IsolationHandle): Promise<void>
 export interface CommitToBranchResult {
     branchName?: string;
     nestedPatches: NestedRepoPatch[];
+    /**
+     * SHA of the parent-repo commit the task branch was created on top of, so
+     * {@link mergeTaskBranches} can cherry-pick the range `baseSha..branchName`
+     * and preserve every agent commit's message and author.
+     */
+    baseSha?: string;
 }
 /**
- * Commit task-only changes to a new branch.
- * Only root repo changes go on the branch. Nested repo patches are returned
- * separately since the parent git can't track files inside gitlinks.
+ * Capture task-only changes from the isolation worktree onto a parent-repo
+ * branch named `omp/task/${taskId}`. Only root-repo changes go on the branch;
+ * nested-repo patches are returned separately because the parent git can't
+ * track files inside gitlinks.
+ *
+ * If the agent committed inside isolation (HEAD moved past
+ * `baseline.root.headCommit`), clean-baseline runs fetch the raw commit range
+ * into the parent repo and later cherry-pick `baseSha..branchName`, preserving
+ * every message and author verbatim. Dirty-baseline runs rewrite each agent
+ * commit against the captured baseline WIP before committing it to the task
+ * branch, so user staged/unstaged/untracked changes present at isolation
+ * start are not replayed into the parent commit history.
+ *
+ * If the agent did not commit, the captured delta is collapsed onto a single
+ * branch commit with an AI-generated (or fallback) message — the legacy
+ * behaviour.
+ *
+ * Returns `null` when no root or nested changes exist.
  */
 export declare function commitToBranch(isolationDir: string, baseline: WorktreeBaseline, taskId: string, description: string | undefined, commitMessage?: (diff: string) => Promise<string | null>): Promise<CommitToBranchResult | null>;
 export interface MergeBranchResult {
@@ -95,14 +116,19 @@ export interface MergeBranchResult {
     stashConflict?: string;
 }
 /**
- * Cherry-pick task branch commits sequentially onto HEAD.
- * Each branch has a single commit that gets replayed cleanly.
- * Stops on first conflict and reports which branches succeeded.
+ * Cherry-pick task branch commits sequentially onto HEAD. When `baseSha` is
+ * provided the cherry-pick uses the inclusive range `baseSha..branchName`,
+ * replaying every commit individually and preserving each commit's message
+ * and author. When omitted, the branch is cherry-picked as a single commit
+ * (legacy callers).
+ *
+ * Stops on the first conflict and reports which branches succeeded.
  */
 export declare function mergeTaskBranches(repoRoot: string, branches: Array<{
     branchName: string;
     taskId: string;
     description?: string;
+    baseSha?: string;
 }>): Promise<MergeBranchResult>;
 /** Clean up temporary task branches. */
 export declare function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void>;

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

@@ -1,5 +1,9 @@
 import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
 import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
+export interface TinyTitleDownloadResult {
+    ok: boolean;
+    error?: string;
+}
 export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
     onProgress?: (event: TinyTitleProgressEvent) => void;
@@ -52,7 +56,7 @@ export declare class TinyTitleClient {
         maxTokens?: number;
         signal?: AbortSignal;
     }): Promise<string | null>;
-    downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<boolean>;
+    downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<TinyTitleDownloadResult>;
     terminate(): Promise<void>;
 }
 export declare const tinyTitleClient: TinyTitleClient;

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

@@ -1,6 +1,6 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { FetchImpl, ImageContent, Model, ServiceTier, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { FetchImpl, ImageContent, Model, ServiceTierByFamily, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AsyncJobManager } from "../async/job-manager";
 import type { Rule } from "../capability/rule";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -191,8 +191,8 @@ export interface ToolSession {
     getActiveModelString?: () => string | undefined;
     /** Get the current session model object (provider/api capabilities), regardless of how it was chosen. */
     getActiveModel?: () => Model | undefined;
-    /** Get the session's live effective service tier (undefined = none). Source of truth for subagent `serviceTierSubagent: inherit`. */
-    getServiceTier?: () => ServiceTier | undefined;
+    /** Get the session's live per-family service tiers (undefined = none). Source of truth for subagent `tier.subagent: inherit`. */
+    getServiceTierByFamily?: () => ServiceTierByFamily | undefined;
     /** Auth storage for passing to subagents (avoids re-discovery) */
     authStorage?: import("../session/auth-storage").AuthStorage;
     /** Model registry for passing to subagents (avoids re-discovery) */