@gajae-code/coding-agent 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 ## [Unreleased]
 
+## [0.10.2] - 2026-07-14
+
+### Added
+
+- Gajae Pet selection is now terminal-capability aware: unsupported terminals show an actionable warning (with multiplexer-specific guidance for tmux/screen/zellij, including the `PI_FORCE_IMAGE_PROTOCOL=sixel` expert opt-in), `/pet` and Settings disable the unavailable `RedGajae`/`BlueGajae` choices while `off` stays selectable, a saved-but-unavailable choice is identified as `(saved)`, and the public command names are consistent across execution, completion, and inline hints (`/pet RedGajae`, `/pet BlueGajae`, `/pet off`, case-insensitive).
+
+### Changed
+
+- Documented the current GPT-5.6 Codex and combo profile mappings as product judgments, including the durable `opus-codex` `anthropic/claude-sonnet-5` planner override and `fable-opus-codex` `anthropic/claude-opus-4-8:medium` planner.
+- RPC clients can now durably select the machine-global default model and effective thinking level for subsequent messages, while project policy and resumed session history retain precedence; a late live-apply failure now restores the prior runtime model and thinking level without masking the original error.
+
+### Fixed
+
+- Gajae Pet overlays no longer leak images or stale pixels across lifecycle changes: each widget owns a randomized Kitty image ID (deleted on disable, replace, switch, and dispose), the previous Sixel footprint is tracked and erased on movement, resize, and narrow-terminal fallback, replaced pet widgets are disposed before their successors install, and a saved pet preference survives editor replacement while graphics are still unavailable (so a delayed Sixel capability probe can still activate it). Teardown is exception-safe and idempotent: a failed or unavailable terminal write never aborts logical disposal or steals a successor widget's overlay slot, and Sixel/Kitty cleanup authority is retained until the erase is actually delivered so a later mode switch or dispose retries it.
+- Gajae Pet cleanup that fails during final widget disposal is now retained by the TUI for retry, and Kitty image IDs remain reserved until their exact-ID delete is delivered.
+- Fixed `gjc --tmux` startup from GNOME and other VTE terminals by recognizing `vte-spawn-*.scope` only when cgroup metadata proves matching user-manager ancestry (#2159).
+
+## [0.10.1] - 2026-07-13
+
+### Added
+
+- Added an owner-proof idle session reaper and `gjc_coordinator_stop_session` for ephemeral (delegate-created) coordinator sessions. Termination goes exclusively through the owner-proof `forceCloseGjcTmuxSession` path (pid, native session id, owner generation, server key, and start time all verified before SIGTERM) — never a raw `process.kill`. The reaper binds each close to the persisted runtime-state file, re-validates ephemeral and no-active-turn at kill time under the same per-session mutation lock as delegate reuse, and purges state only on verified termination (#2080).
+- RPC clients can now durably select the machine-global default model and effective thinking level for subsequent messages, while project policy and resumed session history retain precedence.
+- Context-usage tokens/% now use provider-reported usage as the single source of truth on every surface. `AgentSession.getContextUsage()` returns a source-tagged snapshot (`source: "provider_anchor" | "heuristic" | "unknown"`), and the status-line `context_pct` segment, inline model percentage, and `/context` totals consume that snapshot instead of recomputing an independent heuristic sum — so footer, status line, `/context`, ACP, and RPC can no longer disagree about the same session state. Heuristic estimation now applies only when no provider anchor exists (session start, aborted/error-only turns), and that fallback now includes the fixed system-prompt/tool/skill context it previously omitted. The pre-prompt compaction estimate honors the latest-compaction boundary (never anchors on stale pre-compaction usage totals), unknown post-compaction usage stays unknown (status line renders `?`; ACP omits the `usage_update` instead of reporting `used: 0`), and `/context` labels its total by provenance with a reconciliation line when the estimated category composition diverges from the provider-reported total.
+### Fixed
+
+- IRC deliveries now accept their exchange batch in the recipient's volatile current-session queue before recipient/main UI observations or sender success. Awaited deliveries generate the reply first, then accept the ordered incoming + auto-reply pair and commit the IRC roster claim before observation; provider failures and sender aborts before acceptance leave no ghost exchange, while observer failures after acceptance are isolated. This is not a durability guarantee: durable history injection remains a later flush and no fsync, recovery, persistent IDs, or deduplication was added.
+- `/model` role-agent assignments now replace active model-profile overrides immediately, so changing architect, critic, planner, or executor models and reasoning levels takes effect in the current session and remains persisted afterward.
+- Print mode now records terminal text-mode errors as exit status 1 (or 78 for context overflow) without bypassing output quiescence or session disposal. It retains JSON event delivery through disposal and suppresses `EPIPE` from its owned stdout; `ERR_STREAM_DESTROYED` is suppressed only after that `EPIPE` has latched, while other output failures remain errors.
+- Extension contexts now receive a defensive copy from `getSystemPrompt()` instead of the live mutable system-prompt array, so an in-place mutation by an in-process extension can no longer bypass context-revision tracking and serve stale display-only context-usage estimates.
+- Preserved clipboard image attachments when the interactive editor clears the composer before dispatching the submit callback, so Alt+V image placeholders still send their image blocks instead of placeholder-only text (#2126).
+- Completed bracketed-paste input now returns a manually paged transcript to live output before the paste is dispatched, including asynchronous consumed and unconsumed paste paths.
+
 ## [0.10.0] - 2026-07-12
 
 ### Added

package/dist/types/cli.d.ts

@@ -3,6 +3,7 @@
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
+import "@gajae-code/utils/postmortem";
 import { Command, type CommandEntry } from "@gajae-code/utils/cli";
 export declare const commands: CommandEntry[];
 export declare class RootHelpCommand extends Command {

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

@@ -115,6 +115,8 @@ export declare class Settings {
      * Set a model role (helper for modelRoles record).
      */
     setModelRole(role: ModelRole | string, modelId: string): void;
+    setGlobalModelRole(role: ModelRole | string, modelId: string | undefined): void;
+    setGlobalModelRoleAndFlush(role: ModelRole | string, modelId: string | undefined): Promise<void>;
     /**
      * Set an agent model override while keeping any live runtime override aligned.
      *

package/dist/types/coordinator/contract.d.ts

@@ -1,4 +1,4 @@
 export declare const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
 export declare const COORDINATOR_MCP_SERVER_NAME = "gjc-coordinator-mcp";
-export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_watch_events", "gjc_coordinator_register_session", "gjc_coordinator_start_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status", "gjc_delegate_plan", "gjc_delegate_execute", "gjc_delegate_team"];
+export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_watch_events", "gjc_coordinator_register_session", "gjc_coordinator_start_session", "gjc_coordinator_stop_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status", "gjc_delegate_plan", "gjc_delegate_execute", "gjc_delegate_team"];
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/coordinator-mcp/policy.d.ts

@@ -10,6 +10,9 @@ export interface CoordinatorMcpConfig {
     namespace: CoordinatorNamespace;
     stateRoot: string;
     sessionCommand: string | null;
+    sessionIdleTtlMs: number;
+    sessionSweepIntervalMs: number;
+    forceStopEnabled: boolean;
 }
 export interface CoordinatorMutationRequest {
     allow_mutation?: boolean;

package/dist/types/coordinator-mcp/server.d.ts

@@ -2,6 +2,7 @@ import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINA
 import { type OwnerIsolationProbe } from "../gjc-runtime/tmux-owner-isolation";
 import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
+import { type SessionReaper } from "./session-reaper";
 export type { CoordinatorToolName };
 export { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES };
 interface JsonRpcRequest {
@@ -47,6 +48,7 @@ interface CoordinatorServices {
     listSessions?: () => unknown[] | Promise<unknown[]>;
     startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
     commandRunner?: CommandRunner;
+    forceCloseSession?: (sessionName: string, env: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string) => Promise<unknown>;
     ownerIsolationProbe?: OwnerIsolationProbe;
     resolveModelProfiles?: CoordinatorModelProfileLoader;
 }
@@ -93,6 +95,17 @@ export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServe
     callTool: (name: string, args?: Record<string, unknown>) => Promise<Record<string, unknown>>;
     handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
     handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    reapSession: (rawId: unknown, opts?: {
+        force?: boolean;
+        reason?: string;
+    }) => Promise<{
+        ok: boolean;
+        reason?: string;
+        killed: boolean;
+        active_turn_id?: string;
+        detail?: string;
+    }>;
+    sessionReaper: SessionReaper;
 };
 export declare function handleCoordinatorMcpRequest(request: JsonRpcRequest, options?: LegacyHandlerOptions): Promise<JsonRpcResponse>;
 export interface PumpCoordinatorOptions {
@@ -115,11 +128,10 @@ export interface PumpCoordinatorOptions {
  *    answerable even while data handlers saturate.
  *  - Data handlers are capped at `maxDataConcurrency`; excess is queued up to
  *    `maxQueueDepth`, then rejected as `server_busy` (bounded memory / fanout).
- *  - `writeLine` failures move the writer to a terminal closed state instead of
- *    poisoning the serialized write chain or escaping as an unhandled rejection;
- *    no writes happen after close.
- *  - On EOF the pump drains in-flight handlers (bounded by `drainTimeoutMs`) and
- *    flushes queued writes before returning, so shutdown never races live work.
+ *  - A coded local `EPIPE` terminalizes writer and dispatch together; other
+ *    writer faults reject the pump without poisoning the serialized write chain.
+ *  - On EOF or a closed peer the pump drains already-running handlers (bounded
+ *    by `drainTimeoutMs`) and never promotes queued work.
  *  - Byte chunks are decoded with a streaming decoder so multibyte characters
  *    split across chunks are not corrupted.
  */

package/dist/types/coordinator-mcp/session-reaper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Idle reaper for coordinator-managed GJC worker sessions.
+ *
+ * Every `gjc_delegate_*` call that omits `session_id` starts a fresh tmux worker
+ * session. Nothing in the coordinator ever tore those down, so completed/crashed
+ * sessions accumulated (RAM + worktrees) until something killed them by hand.
+ *
+ * This is the automatic backstop (defense-in-depth): a periodic sweep force-closes
+ * sessions that are (a) ephemeral — coordinator delegate-created, never a user's
+ * registered resident session, (b) not mid-turn, and (c) idle past a TTL.
+ *
+ * The controller is pure + fully injectable (clock / list / reap side-effects) so
+ * it is unit-testable without tmux, the filesystem, or wall-clock waits. The
+ * scheduling mirrors the proven resource-gc controller: a recursive setTimeout
+ * with a generation guard so a stop()+start() can never leak a duplicate timer.
+ */
+export declare const DEFAULT_SESSION_IDLE_TTL_MS: number;
+export declare const DEFAULT_SESSION_SWEEP_INTERVAL_MS: number;
+export declare const MIN_SESSION_IDLE_TTL_MS = 60000;
+export declare const MIN_SESSION_SWEEP_INTERVAL_MS = 30000;
+/** Minimal projection of a coordinator session the reaper needs to decide. */
+export interface ReapableSession {
+    sessionId: string;
+    /** True only for coordinator delegate-created sessions. User-registered resident sessions are false and never reaped. */
+    ephemeral: boolean;
+    /** Epoch ms of last observed activity (turn update / session-state write / session creation). */
+    lastActivityMs: number;
+    /** True while a turn is active — never reap mid-turn. */
+    hasActiveTurn: boolean;
+}
+export interface SessionReaperPolicy {
+    idleTtlMs: number;
+    sweepIntervalMs: number;
+}
+/**
+ * Pure selection: which sessions are safe to reap at `now`.
+ * A session is reapable iff ephemeral AND not mid-turn AND idle ≥ (clamped) TTL.
+ */
+export declare function selectReapableSessions(sessions: readonly ReapableSession[], now: number, idleTtlMs: number): ReapableSession[];
+/** Injectable side-effects so the controller runs in tests without tmux/fs/real time. */
+export interface SessionReaperDeps {
+    listSessions: () => Promise<ReapableSession[]>;
+    reapSession: (sessionId: string) => Promise<void>;
+    now: () => number;
+}
+export interface SessionReaper {
+    /** Run one sweep; returns the number of sessions successfully reaped. */
+    sweepOnce: () => Promise<number>;
+    start: () => void;
+    stop: () => void;
+    readonly running: boolean;
+}
+export declare function createSessionReaper(deps: SessionReaperDeps, policy: SessionReaperPolicy): SessionReaper;

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

@@ -176,11 +176,13 @@ export interface ExtensionUIContext {
     setToolsExpanded(expanded: boolean): void;
 }
 export interface ContextUsage {
-    /** Estimated context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
+    /** Context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
     tokens: number | null;
     contextWindow: number;
     /** Context usage as percentage of context window, or null if tokens is unknown. */
     percent: number | null;
+    /** Provenance: "provider_anchor" = anchored on provider-reported usage (+ heuristic trailing delta); "heuristic" = no provider anchor available, full estimate; "unknown" = post-compaction, no post-compaction provider response yet. */
+    source: "provider_anchor" | "heuristic" | "unknown";
 }
 export interface CompactOptions {
     onComplete?: (result: CompactionResult) => void;

package/dist/types/modes/components/gajae-pet-widget.d.ts

@@ -53,6 +53,7 @@ export declare class GajaePetWidget {
      *  eye-roll it fires the signature burst once (RedGajae flex, BlueGajae para-para
      *  then sob) so the selector demos the animation instead of waiting the random gap. */
     previewMode(mode: PetMode): void;
+    commitPreviewMode(mode: PetMode): void;
     dispose(): void;
     /** Re-mount the composer editor (framed when a skin is active) after an overlay. */
     remountComposer(): void;

package/dist/types/modes/components/pet-capability.d.ts

@@ -0,0 +1,37 @@
+import { type SelectItem } from "@gajae-code/tui";
+export type PetPixelProtocol = "sixel" | "kitty";
+export declare const PET_UNAVAILABLE_DESCRIPTION = "Unavailable: requires compatible Kitty or Sixel overlay rendering";
+export declare const PET_SAVED_UNAVAILABLE_DESCRIPTION = "Saved, unavailable \u2014 requires compatible Kitty or Sixel overlay rendering";
+export declare const PET_UNAVAILABLE_WARNING = "\u26A0 Pets aren\u2019t available in this terminal. Its image support isn\u2019t compatible with Gajae Pet\u2019s overlay rendering yet. Try Kitty, Ghostty, WezTerm, or a terminal with compatible Sixel support.";
+export declare function getPetUnavailableWarning(env?: NodeJS.ProcessEnv): string;
+export declare function getPetPixelProtocol(): PetPixelProtocol | null;
+export declare function isPetAvailable(): boolean;
+export declare function createPetSelectItems(options: ReadonlyArray<SelectItem>, currentValue: string, available: boolean): SelectItem[];
+/**
+ * Grace period before declaring the terminal pet-incapable at startup. The
+ * asynchronous Sixel capability probe starts inside `TUI.start()` and answers
+ * within its own 250 ms deadline; this margin covers probe scheduling so a
+ * supported terminal is never told it is incompatible while the probe is
+ * still in flight.
+ */
+export declare const PET_CAPABILITY_SETTLE_MS = 1000;
+/**
+ * Whether the asynchronous startup Sixel capability probe may still enable
+ * graphics for this session, meaning current unavailability is not final.
+ */
+export declare function isPetCapabilityProbePending(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+/**
+ * Deliver the pet-unavailable startup warning only once the capability
+ * question is settled. With no probe pending, unavailability is final and
+ * `onUnavailable` fires immediately. While a probe may still enable
+ * graphics, the warning is deferred: a protocol-change event cancels it (the
+ * saved pet re-applies through the existing subscription), and only the
+ * settle deadline passing with the terminal still unavailable emits it.
+ * Returns a disposer that cancels the pending decision.
+ */
+export declare function warnWhenPetCapabilitySettled(options: {
+    probePending: boolean;
+    isAvailable?: () => boolean;
+    onUnavailable: () => void;
+    settleMs?: number;
+}): () => void;

package/dist/types/modes/components/pet-selector.d.ts

@@ -6,6 +6,6 @@ import type { PetMode } from "./gajae-pet-widget";
  */
 export declare class PetSelectorComponent extends Container {
     #private;
-    constructor(current: PetMode, onSelect: (mode: PetMode) => void, onCancel: () => void, onPreview: (mode: PetMode) => void);
+    constructor(current: PetMode, onSelect: (mode: PetMode) => void, onCancel: () => void, onPreview: (mode: PetMode) => void, available: boolean);
     getSelectList(): SelectList;
 }

package/dist/types/modes/components/settings-selector.d.ts

@@ -20,6 +20,8 @@ export interface SettingsRuntimeContext {
     availableModelProfiles: string[];
     /** Working directory for plugins tab */
     cwd: string;
+    /** Whether this terminal can render the pet overlay. */
+    petAvailable?: boolean;
 }
 /** Status line settings subset for preview */
 export interface StatusLinePreviewSettings {
@@ -41,6 +43,13 @@ export interface SettingsCallbacks {
     onThemePreviewCancel?: (theme: string) => void | Promise<void>;
     /** Called to live-preview the gajae pet skin while browsing the pet setting. */
     onPetPreview?: (mode: string) => void;
+    /**
+     * Commit a pet mode through the shared result-returning policy. The policy
+     * rechecks capability immediately before mutation and owns persistence, so
+     * the settings surface never persists `pet.mode` ahead of acceptance.
+     * Returns whether the commit was accepted.
+     */
+    onPetCommit?: (mode: string) => boolean;
     /** Called for status line preview while configuring */
     onStatusLinePreview?: (settings: StatusLinePreviewSettings) => void;
     /** Get current rendered status line for inline preview */

package/dist/types/modes/components/status-line/types.d.ts

@@ -25,7 +25,7 @@ export interface SegmentContext {
         cost: number;
         tokensPerSecond: number | null;
     };
-    contextPercent: number;
+    contextPercent: number | null;
     contextWindow: number;
     /**
      * True when a standalone `context_pct` segment is also part of the active

package/dist/types/modes/components/status-line.d.ts

@@ -70,16 +70,6 @@ export declare class StatusLineComponent implements Component {
      * unit tests can verify the backoff invariant.
      */
     refreshUsageInBackground(): void;
-    /**
-     * Compute the (cached) used-tokens / context-window totals for the
-     * status-line context% segment. Exposed (non-private) so unit tests can
-     * verify the incremental-cache invariants; not part of any external
-     * API.
-     */
-    getCachedContextBreakdown(): {
-        usedTokens: number;
-        contextWindow: number;
-    };
     getTopBorder(width: number): {
         content: string;
         width: number;

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

@@ -139,8 +139,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     updateEditorChrome(): void;
     updateEditorBorderColor(): void;
     updateEditorTopBorder(): void;
-    setPetMode(mode: PetMode): void;
+    setPetMode(mode: PetMode): boolean;
     previewPetMode(mode: PetMode): void;
+    commitPetPreviewMode(mode: PetMode): boolean;
     restoreComposer(): void;
     rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
     /** Apply any deferred model switch after the current stream ends. */

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

@@ -20,9 +20,8 @@ export interface PrintModeOptions {
     /** Images to attach to the initial message */
     initialImages?: ImageContent[];
     /**
-     * When true, an assistant error/abort does not call process.exit(); print mode
-     * returns instead so the caller (e.g. RLM autonomous mode) can run its own
-     * finalization/cleanup before the process exits.
+     * When true, a terminal assistant error/abort leaves process exit status
+     * untouched so the caller can run its own finalization and status handling.
      */
     suppressProcessExit?: boolean;
 }
@@ -37,7 +36,7 @@ export interface PrintModeOptions {
  * events from the subscription and does not run this terminal-error branch, so
  * it is intentionally NOT covered by this exit code.
  */
-export declare const CONTEXT_OVERFLOW_EXIT_CODE = 2;
+export declare const CONTEXT_OVERFLOW_EXIT_CODE = 78;
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.

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

@@ -3,7 +3,7 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
-import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@gajae-code/agent-core";
+import { type AgentEvent, type AgentMessage, type AgentToolResult, type ResolvedThinkingLevel, ThinkingLevel } from "@gajae-code/agent-core";
 import type { CompactionResult } from "@gajae-code/agent-core/compaction";
 import type { ImageContent, Model } from "@gajae-code/ai";
 import type { BashResult } from "../../exec/bash-executor";
@@ -36,6 +36,11 @@ export interface RpcClientOptions {
     customTools?: RpcClientCustomTool[];
 }
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
+export type RpcDefaultModelSelection = {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly thinkingLevel: ResolvedThinkingLevel;
+};
 export type RpcEventListener = (event: AgentEvent) => void;
 export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
 export interface RpcClientToolContext<TDetails = unknown> {
@@ -149,6 +154,7 @@ export declare class RpcClient {
         provider: string;
         id: string;
     }>;
+    setDefaultModelSelection(provider: string, modelId: string, thinkingLevel: ResolvedThinkingLevel): Promise<RpcDefaultModelSelection>;
     /**
      * Cycle to next model.
      */

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

@@ -18,7 +18,7 @@ export type PendingExtensionRequest = {
     resolve: (response: RpcExtensionUIResponse) => void;
     reject: (error: Error) => void;
 };
-type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => Promise<void>;
 export declare function shouldEmitRpcTitlesForTest(): boolean;
 /**
  * Cancellation commands bypass the ordered serial chain because they must
@@ -63,6 +63,7 @@ export declare function isFastLaneRpcCommand(type: RpcCommand["type"]): boolean;
  */
 export declare function createRpcCommandScheduler(run: (command: RpcCommand) => Promise<void>, track: (task: Promise<void>) => void): {
     dispatch: (command: RpcCommand) => void;
+    close: () => void;
 };
 export { RpcListenRefusedError } from "./rpc-socket-security";
 /**

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

@@ -4,7 +4,7 @@
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
-import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@gajae-code/agent-core";
+import type { AgentMessage, AgentToolResult, ResolvedThinkingLevel, ThinkingLevel } from "@gajae-code/agent-core";
 import type { CompactionResult } from "@gajae-code/agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@gajae-code/ai";
 import type { BashResult } from "../../exec/bash-executor";
@@ -69,6 +69,12 @@ export type RpcCommand = {
     type: "set_model";
     provider: string;
     modelId: string;
+} | {
+    id?: string;
+    type: "set_default_model_selection";
+    provider: string;
+    modelId: string;
+    thinkingLevel?: ResolvedThinkingLevel;
 } | {
     id?: string;
     type: "cycle_model";
@@ -278,6 +284,16 @@ export type RpcResponse = {
     command: "set_model";
     success: true;
     data: Model;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_default_model_selection";
+    success: true;
+    data: {
+        provider: string;
+        modelId: string;
+        thinkingLevel: ResolvedThinkingLevel;
+    };
 } | {
     id?: string;
     type: "response";

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

@@ -153,9 +153,19 @@ export interface InteractiveModeContext {
     setWorkingMessage(message?: string): void;
     applyPendingWorkingMessage(): void;
     ensureLoadingAnimation(): void;
-    setPetMode(mode: PetMode): void;
+    /**
+     * Commit a pet mode through the shared result-returning policy: capability
+     * is rechecked immediately before mutation and the preference persists only
+     * on acceptance. Returns whether the commit was accepted.
+     */
+    setPetMode(mode: PetMode): boolean;
     /** Live-preview a pet skin during a selector without persisting. */
     previewPetMode(mode: PetMode): void;
+    /**
+     * Commit a settings-overlay pet change without re-mounting the composer.
+     * Same shared commit policy and result semantics as `setPetMode`.
+     */
+    commitPetPreviewMode(mode: PetMode): boolean;
     /** Re-mount the composer (pet-aware) after an overlay/selector closes. */
     restoreComposer(): void;
     startPendingSubmission(input: {

package/dist/types/modes/utils/context-usage.d.ts

@@ -1,9 +1,8 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { Model } from "@gajae-code/ai";
-import type { Skill } from "../../extensibility/skills";
 import type { AgentSession } from "../../session/agent-session";
-import type { Tool } from "../../tools";
 import type { theme as Theme } from "../theme/theme";
+export { computeNonMessageTokens, estimateSkillsTokens, estimateToolSchemaTokens, } from "../../session/context-estimation";
 type CategoryId = "systemPrompt" | "systemContext" | "rules" | "tools" | "skills" | "messages" | "lastUserTurn";
 interface CategoryInfo {
     id: CategoryId;
@@ -17,25 +16,12 @@ export interface ContextBreakdown {
     contextWindow: number;
     categories: CategoryInfo[];
     lastUserTurnTokens: number;
-    usedTokens: number;
+    estimatedCategoryTotal: number;
+    usedTokens: number | null;
+    source: "provider_anchor" | "heuristic" | "unknown";
     autoCompactBufferTokens: number;
     freeTokens: number;
 }
-export declare function estimateSkillsTokens(skills: readonly Skill[]): number;
-export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">>): number;
-/**
- * Compute just the NON-MESSAGE token total: system prompt (with its skills
- * section subtracted, since skills are tokenized separately) + system context
- * (the rest of the system-prompt array) + tools + skills.
- *
- * Exposed so callers like `StatusLineComponent` can cache the non-message
- * total separately from the message total. Non-message inputs (skills,
- * tools, system prompt) change rarely; the message list grows on every
- * streaming turn. Splitting the two lets the caller refresh each on its own
- * cadence — non-message recomputed only when the inputs identity changes,
- * messages walked incrementally as new entries append.
- */
-export declare function computeNonMessageTokens(session: AgentSession): number;
 /**
  * Compute a breakdown of estimated context usage by category for the active
  * session and model.
@@ -48,4 +34,3 @@ export declare function computeContextBreakdown(session: AgentSession, options?:
  * lines pairing the grid (left) with the legend (right).
  */
 export declare function renderContextUsage(breakdown: ContextBreakdown, theme: typeof Theme): string;
-export {};

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

@@ -12,7 +12,7 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
+import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type ResolvedThinkingLevel, type StablePrefixSnapshot, ThinkingLevel } from "@gajae-code/agent-core";
 import { type CompactionResult, type EmergencyCompactionSample } from "@gajae-code/agent-core/compaction";
 import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, Usage, UsageReport } from "@gajae-code/ai";
 export interface ForkContextSeedMetadata {
@@ -309,6 +309,11 @@ export interface RoleModelCycleResult {
     thinkingLevel: ThinkingLevel | undefined;
     role: string;
 }
+export interface DefaultModelSelectionResult {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly thinkingLevel: ResolvedThinkingLevel;
+}
 /** Session statistics for /session command */
 export interface SessionStats {
     sessionFile: string | undefined;
@@ -854,6 +859,7 @@ export declare class AgentSession {
     setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel, options?: {
         persistAsSessionDefault?: boolean;
     }): Promise<void>;
+    setDefaultModelSelection(model: Model, thinkingLevel: ThinkingLevel | undefined): Promise<DefaultModelSelectionResult>;
     /**
      * Cycle to next/previous model.
      * Uses scoped models (from --models flag) if available, otherwise all available models.
@@ -1108,9 +1114,13 @@ export declare class AgentSession {
         promptText: string;
         onTextDelta?: (delta: string) => void;
         signal?: AbortSignal;
+        /** Defer the successful roster-claim commit until the caller accepts its exchange. */
+        deferRosterCommit?: boolean;
     }): Promise<{
         replyText: string;
         assistantMessage: AssistantMessage;
+        commitRosterClaim?: () => void;
+        releaseRosterClaim?: () => void;
     }>;
     /**
      * Reload the current session from disk.
@@ -1176,6 +1186,9 @@ export declare class AgentSession {
      * otherwise estimates tokens for all messages.
      */
     getContextUsage(): ContextUsage | undefined;
+    getContextUsageObservabilityForTests(): {
+        estimateCount: number;
+    };
     fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
     /**
      * Export session to HTML.

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

@@ -0,0 +1,31 @@
+import type { Skill } from "../extensibility/skills";
+import type { Tool } from "../tools";
+import type { AgentSession } from "./agent-session";
+export declare function estimateSkillsTokens(skills: readonly Skill[]): number;
+export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">>): number;
+/**
+ * Compute just the NON-MESSAGE token total: system prompt (with its skills
+ * section subtracted, since skills are tokenized separately) + system context
+ * (the rest of the system-prompt array) + tools + skills.
+ *
+ * Exposed so callers like `StatusLineComponent` can cache the non-message
+ * total separately from the message total. Non-message inputs (skills,
+ * tools, system prompt) change rarely; the message list grows on every
+ * streaming turn. Splitting the two lets the caller refresh each on its own
+ * cadence — non-message recomputed only when the inputs identity changes,
+ * messages walked incrementally as new entries append.
+ */
+export declare function computeNonMessageTokens(session: AgentSession): number;
+/**
+ * Shared helper for the four non-message token totals. Single source of truth
+ * for `computeNonMessageTokens` (session estimates + status-line incremental
+ * cache) and `computeContextBreakdown` (/context panel). The split avoids
+ * drift between the surfaces — they MUST report the same numbers.
+ */
+export declare function computeNonMessageBreakdown(session: AgentSession): {
+    rulesTokens: number;
+    skillsTokens: number;
+    toolsTokens: number;
+    systemContextTokens: number;
+    systemPromptTokens: number;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.10.0",
+	"version": "0.10.2",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -49,12 +49,12 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.10.0",
-		"@gajae-code/agent-core": "0.10.0",
-		"@gajae-code/ai": "0.10.0",
-		"@gajae-code/natives": "0.10.0",
-		"@gajae-code/tui": "0.10.0",
-		"@gajae-code/utils": "0.10.0",
+		"@gajae-code/stats": "0.10.2",
+		"@gajae-code/agent-core": "0.10.2",
+		"@gajae-code/ai": "0.10.2",
+		"@gajae-code/natives": "0.10.2",
+		"@gajae-code/tui": "0.10.2",
+		"@gajae-code/utils": "0.10.2",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli.ts

@@ -4,6 +4,7 @@
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
+import "@gajae-code/utils/postmortem";
 import { Args, type CliConfig, Command, type CommandEntry, Flags, run } from "@gajae-code/utils/cli";
 import { APP_NAME, formatBunRuntimeError, MIN_BUN_VERSION, VERSION } from "@gajae-code/utils/dirs";
 import { runFixtureReport } from "./cli/fixture-report";