@gajae-code/coding-agent 0.4.5 → 0.5.1

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

@@ -2,7 +2,7 @@
  * Generic selector component for hooks.
  * Displays a list of string options with keyboard navigation.
  */
-import { Container, type TUI } from "@gajae-code/tui";
+import { type AutocompleteProvider, Container, type TUI } from "@gajae-code/tui";
 export interface HookSelectorOptions {
     tui?: TUI;
     timeout?: number;
@@ -33,6 +33,12 @@ export interface HookSelectorOptions {
         optionLabel: string;
         onSubmit: (text: string) => void;
     };
+    /**
+     * Autocomplete provider for the inline custom-input editor. When present,
+     * the "Other (type your own)" editor gains the same `@` file-link and `/`
+     * completion behavior as the main prompt editor.
+     */
+    autocompleteProvider?: AutocompleteProvider;
 }
 export declare class HookSelectorComponent extends Container {
     #private;

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

@@ -5,24 +5,12 @@ import type { GjcModelAssignmentTargetId, ModelRegistry } from "../../config/mod
 import { type ScopedModelSelection } from "../../config/model-resolver";
 import type { Settings } from "../../config/settings";
 type ScopedModelItem = ScopedModelSelection;
-export interface ModelAssignmentPreset {
-    id: "openai-codex";
-    label: string;
-    description: string;
-    assignments: Partial<Record<GjcModelAssignmentTargetId, ThinkingLevel>>;
-}
 export type ModelSelectorSelection = {
     kind: "assignment";
     model: Model;
     role: GjcModelAssignmentTargetId | null;
     thinkingLevel?: ThinkingLevel;
     selector?: string;
-} | {
-    kind: "preset";
-    model: Model;
-    selector: string;
-    preset: ModelAssignmentPreset;
-    assignments: Record<GjcModelAssignmentTargetId, ThinkingLevel>;
 } | {
     kind: "profile";
     profileName: string;
@@ -41,6 +29,7 @@ export declare class ModelSelectorComponent extends Container {
     constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
         temporaryOnly?: boolean;
         initialSearchInput?: string;
+        sessionId?: string;
     });
     handleInput(keyData: string): void;
     getSearchInput(): Input;

package/dist/types/modes/controllers/command-controller.d.ts

@@ -35,3 +35,4 @@ export declare class CommandController {
     handleContributionPrepCommand(customInstructions?: string): Promise<void>;
 }
 export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number): string;

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

@@ -8,7 +8,7 @@ import type { CompactionResult } from "@gajae-code/agent-core/compaction";
 import type { ImageContent, Model } from "@gajae-code/ai";
 import type { BashResult } from "../../exec/bash-executor";
 import type { SessionStats } from "../../session/agent-session";
-import type { RpcExtensionUIRequest, RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution } from "./rpc-types";
+import type { RpcExtensionUIRequest, RpcGetStateInclude, RpcHandoffResult, RpcHostToolDefinition, RpcSessionState, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution } from "./rpc-types";
 export interface RpcClientOptions {
     /** Path to the CLI entry point (default: searches for dist/cli.js) */
     cliPath?: string;
@@ -115,7 +115,7 @@ export declare class RpcClient {
     /**
      * Get current session state.
      */
-    getState(): Promise<RpcSessionState>;
+    getState(include?: RpcGetStateInclude[]): Promise<RpcSessionState>;
     /**
      * Set model by provider and ID.
      */

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

@@ -1,3 +1,15 @@
+/**
+ * RPC mode: Headless operation with JSON stdin/stdout protocol.
+ *
+ * Used for embedding the agent in other applications.
+ * Receives commands as JSON on stdin, outputs events and responses as JSON on stdout.
+ *
+ * Protocol:
+ * - Commands: JSON objects with `type` field, optional `id` for correlation
+ * - Responses: JSON objects with `type: "response"`, `command`, `success`, and optional `data`/`error`
+ * - Events: AgentSessionEvent objects streamed as they occur
+ * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
+ */
 import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
 import type { RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
@@ -7,6 +19,7 @@ export type PendingExtensionRequest = {
     reject: (error: Error) => void;
 };
 type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+export declare function shouldEmitRpcTitlesForTest(): boolean;
 export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
     promptStyle?: boolean;
 }): Promise<string | undefined>;
@@ -14,4 +27,6 @@ export declare function requestRpcEditor(pendingRequests: Map<string, PendingExt
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
-export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export declare function runRpcMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void, options?: {
+    listen?: string;
+}): Promise<never>;

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

@@ -11,6 +11,7 @@ import type { BashResult } from "../../exec/bash-executor";
 import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { SessionStats } from "../../session/agent-session";
 import type { TodoPhase } from "../../tools/todo-write";
+export type RpcGetStateInclude = "tools" | "dumpTools" | "systemPrompt";
 export type RpcCommand = {
     id?: string;
     type: "prompt";
@@ -42,6 +43,7 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_state";
+    include?: RpcGetStateInclude[];
 } | {
     id?: string;
     type: "set_todos";
@@ -168,8 +170,9 @@ export interface RpcSessionState {
     messageCount: number;
     queuedMessageCount: number;
     todoPhases: TodoPhase[];
-    /** For session dump / export (plain-text parity with /dump). */
+    /** Optional static system prompt blocks. Omitted by default; request with get_state include ["systemPrompt"]. */
     systemPrompt?: string[];
+    /** Optional static tool schemas. Omitted by default; request with get_state include ["tools"]. */
     dumpTools?: Array<{
         name: string;
         description: string;

package/dist/types/modes/shared/agent-wire/deep-interview-gate.d.ts

@@ -1,6 +1,14 @@
 import type { OpenGateInput } from "./workflow-gate-broker";
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
 export declare const GATE_OTHER_OPTION = "Other (type your own)";
+/** Optional structured deep-interview round metadata supplied by the agent. */
+export interface AskGateDeepInterviewState {
+    round_id?: string;
+    round: number;
+    component: string;
+    dimension: string;
+    ambiguity: number;
+}
 export interface AskGateQuestion {
     id: string;
     question: string;
@@ -9,6 +17,11 @@ export interface AskGateQuestion {
     }>;
     multi?: boolean;
     recommended?: number;
+    /**
+     * Structured round metadata. When present it is the authoritative source for gate
+     * `stage_state`; when absent, the question text is regex-parsed as a fallback.
+     */
+    deepInterview?: AskGateDeepInterviewState;
 }
 export interface AskGateResult {
     id: string;

package/dist/types/modes/shared/agent-wire/session-registry.d.ts

@@ -0,0 +1,25 @@
+export type RpcSessionTransport = "stdio" | "bridge" | "socket";
+export interface RpcSessionRecord {
+    sessionId: string;
+    pid: number;
+    transport: RpcSessionTransport;
+    cwd: string;
+    model?: string;
+    /** ISO-8601 start timestamp. */
+    startedAt: string;
+    /** Reachable endpoint for persistent transports (issue 09); absent for stdio. */
+    endpoint?: string;
+}
+/**
+ * Write (or replace) the registry record for a session. The record is written to
+ * a same-directory temp file and atomically renamed into place so a concurrent
+ * reader never observes (and reaps) a partially-written record.
+ */
+export declare function registerRpcSession(record: RpcSessionRecord, agentDir?: string): Promise<string>;
+/** Remove a session's registry record. Best-effort: a missing file is not an error. */
+export declare function unregisterRpcSession(sessionId: string, agentDir?: string): Promise<void>;
+/**
+ * List live RPC sessions, reaping records whose process is gone or whose file is
+ * unparseable. Returns records sorted by `startedAt` ascending.
+ */
+export declare function listRpcSessions(agentDir?: string): Promise<RpcSessionRecord[]>;

package/dist/types/modes/shared/agent-wire/unattended-action-policy.d.ts

@@ -20,6 +20,8 @@ import type { RpcUnattendedActionClass } from "../../rpc/rpc-types";
 import type { BridgeCommandScope } from "./scopes";
 /** Coarse command scope -> `command.<scope>` action class. */
 export declare function actionClassForScope(scope: BridgeCommandScope): RpcUnattendedActionClass;
+/** Runtime list of every v1 action class — membership-validation source for negotiate (#319). */
+export declare const RPC_UNATTENDED_ACTION_CLASSES: readonly RpcUnattendedActionClass[];
 /**
  * Classify a (possibly compound / nested) bash command into the most severe
  * action class across all statements and nested substitutions. Fail-closed.

package/dist/types/sdk.d.ts

@@ -40,6 +40,11 @@ export interface CreateAgentSessionOptions {
     modelPattern?: string;
     /** Thinking selector. Default: from settings, else unset */
     thinkingLevel?: ThinkingLevel;
+    /** Runtime substitution metadata for the initial model_change session event. */
+    modelSubstitution?: {
+        requestedModel: Model;
+        reason: string;
+    };
     /** Models available for cycling (Ctrl+P in interactive mode) */
     scopedModels?: ScopedModelSelection[];
     /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */

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

@@ -143,7 +143,7 @@ export type AgentSessionEvent = AgentEvent | {
 };
 /** Listener function for agent session events */
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "metadata">;
+export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime" | "endTime" | "metadata">;
 export interface AsyncJobSnapshot {
     running: AsyncJobSnapshotItem[];
     recent: AsyncJobSnapshotItem[];
@@ -678,6 +678,8 @@ export declare class AgentSession {
         selector?: string;
         thinkingLevel?: ThinkingLevel;
     }): Promise<void>;
+    setActiveModelProfile(name: string | undefined): void;
+    getActiveModelProfile(): string | undefined;
     /**
      * Set model temporarily (for this session only).
      * Validates API key, saves to session log but NOT to settings.

package/dist/types/session/blob-store.d.ts

@@ -31,6 +31,14 @@ export declare class BlobStore {
     /** Check if a blob exists. */
     has(hash: string): Promise<boolean>;
 }
+export declare class EphemeralBlobStore extends BlobStore {
+    #private;
+    constructor(dir: string);
+    putSync(data: Buffer): BlobPutResult;
+    getSync(hash: string): Buffer | null;
+    clear(): void;
+    dispose(): void;
+}
 export declare class MemoryBlobStore extends BlobStore {
     #private;
     constructor();
@@ -40,6 +48,13 @@ export declare class MemoryBlobStore extends BlobStore {
     getSync(hash: string): Buffer | null;
     has(hash: string): Promise<boolean>;
 }
+export declare class ResidentBlobMissingError extends Error {
+    readonly hash: string;
+    readonly kind: "text" | "imageUrl" | "imageData";
+    readonly sessionId?: string | undefined;
+    readonly sessionFile?: string | undefined;
+    constructor(hash: string, kind: "text" | "imageUrl" | "imageData", sessionId?: string | undefined, sessionFile?: string | undefined);
+}
 /** Check if a data string is a blob reference. */
 export declare function isBlobRef(data: string): boolean;
 /** Extract the SHA-256 hash from a blob reference string. */
@@ -63,18 +78,58 @@ export declare function externalizeImageDataSync(blobStore: BlobStore, base64Dat
 /**
  * Resolve an externalized provider image data URL back to its original string.
  * If the data is not a blob reference, returns it unchanged.
- * If the blob is missing, logs a warning and returns the reference as-is.
+ *
+ * LEGACY PERSISTED-IMAGE COMPATIBILITY BOUNDARY: when the persisted blob is missing
+ * (e.g. resuming an old session whose image blob was pruned), this warns and returns
+ * the reference as-is rather than throwing, so legacy resume degrades gracefully.
+ * New resident byte-sensitive TEXT uses the fail-closed path instead
+ * (`resolveTextBlobSync` -> `ResidentBlobMissingError`). Do NOT route new byte-sensitive
+ * resident data through this warn-and-return path.
  */
 export declare function resolveImageDataUrl(blobStore: BlobStore, data: string): Promise<string>;
 /**
  * Resolve a blob reference back to base64 data.
  * If the data is not a blob reference, returns it unchanged.
- * If the blob is missing, logs a warning and returns a placeholder.
+ *
+ * LEGACY PERSISTED-IMAGE COMPATIBILITY BOUNDARY: when the blob is missing this warns
+ * and returns the reference as-is (downstream sees an invalid base64 ref but does not
+ * crash), preserving legacy-session resume. Byte-sensitive resident TEXT is fail-closed
+ * via `resolveTextBlobSync`; do NOT route new byte-sensitive resident data here.
  */
 export declare function resolveImageData(blobStore: BlobStore, data: string): Promise<string>;
 /** Synchronously resolve an externalized provider image data URL back to its original string. */
 export declare function resolveImageDataUrlSync(blobStore: BlobStore, data: string): string;
 /** Synchronously resolve a blob reference back to base64 data. */
 export declare function resolveImageDataSync(blobStore: BlobStore, data: string): string;
-/** Synchronously resolve a blob reference back to utf8 text. */
-export declare function resolveTextBlobSync(blobStore: BlobStore, data: string): string;
+/**
+ * Synchronously resolve a blob reference back to utf8 text.
+ *
+ * FAIL-CLOSED byte-sensitive path: a missing resident blob throws
+ * `ResidentBlobMissingError` rather than degrading, so a missing resident text blob can
+ * never silently leak a `blob:sha256:` ref into provider payloads, UI, or exports.
+ * (Contrast the legacy persisted-image warn-and-return resolvers above.)
+ */
+export declare function resolveTextBlobSync(blobStore: BlobStore, data: string, context?: {
+    kind?: "text";
+    sessionId?: string;
+    sessionFile?: string;
+}): string;
+/**
+ * FAIL-CLOSED resident variant of {@link resolveImageDataUrlSync}: a missing resident
+ * image-data-url blob throws `ResidentBlobMissingError` ("imageUrl") instead of warn-returning,
+ * so resident byte-sensitive provider image data can never leak a `blob:sha256:` ref into
+ * materialized entries, context, or provider payloads. The warn-and-return `resolveImageDataUrl*`
+ * resolvers remain ONLY for legacy persisted-image resume.
+ */
+export declare function resolveResidentImageDataUrlSync(blobStore: BlobStore, data: string, context?: {
+    sessionId?: string;
+    sessionFile?: string;
+}): string;
+/**
+ * FAIL-CLOSED resident variant of {@link resolveImageDataSync}: a missing resident image blob
+ * throws `ResidentBlobMissingError` ("imageData") instead of warn-returning a placeholder.
+ */
+export declare function resolveResidentImageDataSync(blobStore: BlobStore, data: string, context?: {
+    sessionId?: string;
+    sessionFile?: string;
+}): string;

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

@@ -40,6 +40,12 @@ export interface ModelChangeEntry extends SessionEntryBase {
     model: string;
     /** Role: "default" or an agent role. Undefined treated as "default" */
     role?: string;
+    /** Requested model before a runtime substitution/fallback, in "provider/modelId" format. */
+    previousModel?: string;
+    /** Machine-readable reason for runtime model substitution/fallback. */
+    reason?: string;
+    /** Effective thinking level when the change was recorded. */
+    thinkingLevel?: string | null;
 }
 export interface ServiceTierChangeEntry extends SessionEntryBase {
     type: "service_tier_change";
@@ -262,6 +268,7 @@ interface SessionManagerStateSnapshot {
     flushed: boolean;
     needsFullRewriteOnNextPersist: boolean;
     fileEntries: FileEntry[];
+    materializedFileEntries: FileEntry[];
 }
 export declare class SessionManager {
     #private;
@@ -270,6 +277,18 @@ export declare class SessionManager {
     private readonly persist;
     private readonly storage;
     private constructor();
+    /**
+     * Snapshot of the five cache-invalidation revision domains (plan: Lane 1
+     * revision contract). Tests assert the invalidation mapping through this;
+     * future export/label-view caches key off their respective domains.
+     */
+    revisionSnapshot(): {
+        entry: number;
+        leaf: number;
+        headerExport: number;
+        label: number;
+        replayMetadata: number;
+    };
     /** Puts a binary blob into the blob store and returns the blob reference */
     putBlob(data: Buffer): Promise<BlobPutResult>;
     captureState(): SessionManagerStateSnapshot;
@@ -388,7 +407,11 @@ export declare class SessionManager {
      * @param model Model in "provider/modelId" format
      * @param role Optional role (default: "default")
      */
-    appendModelChange(model: string, role?: string): string;
+    appendModelChange(model: string, role?: string, metadata?: {
+        previousModel?: string;
+        reason?: string;
+        thinkingLevel?: string | null;
+    }): string;
     /** Append session init metadata (for subagent debugging/replay). Returns entry id. */
     appendSessionInit(init: {
         systemPrompt: string;
@@ -480,11 +503,6 @@ export declare class SessionManager {
      * Get session header.
      */
     getHeader(): SessionHeader | null;
-    /**
-     * Get all session entries (excludes header). Returns a shallow copy.
-     * The session is append-only: use appendXXX() to add entries, branch() to
-     * change the leaf pointer. Entries cannot be modified or deleted.
-     */
     getEntries(): SessionEntry[];
     /**
      * Get the session as a tree structure. Returns a shallow defensive copy of all entries.

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

@@ -159,8 +159,9 @@ export declare class OutputSink {
     #private;
     constructor(options?: OutputSinkOptions);
     /**
-     * Push a chunk of output. The buffer management and onChunk callback run
-     * synchronously. File sink writes are deferred and serialized internally.
+     * Push a chunk of output. Raw bytes are mirrored to artifacts, while the
+     * visible retention windows are selected from the sanitized/column-capped
+     * stream so production-default display matches the historical processed view.
      */
     push(chunk: string): void;
     createInput(): WritableStream<Uint8Array | string>;

package/dist/types/session/tool-choice-queue.d.ts

@@ -63,6 +63,12 @@ export declare class ToolChoiceQueue {
      * lost value at the head of the queue; anything else drops it.
      */
     reject(reason: RejectInfo["reason"]): void;
+    /**
+     * Drop an in-flight yield after runtime tool_choice degradation. This bypasses
+     * onRejected so forced directives cannot requeue themselves after the model
+     * proved incapable of honoring the forced choice.
+     */
+    degradeInFlight(reason?: string): string | undefined;
     /** True if there is an in-flight yield that hasn't been resolved or rejected. */
     get hasInFlight(): boolean;
     /** Peek the in-flight directive's onInvoked handler, if any. */

package/dist/types/skill-state/workflow-hud.d.ts

@@ -18,6 +18,8 @@ interface RalplanHudState extends WorkflowGateHudState {
     stage?: string;
     waiting?: string;
     iteration?: number;
+    iterationFromIndex?: number;
+    stages?: string;
     verdict?: string;
     latestSummary?: string;
     pendingApproval?: boolean;
@@ -61,6 +63,18 @@ interface TeamHudState extends WorkflowGateHudState {
     };
 }
 export declare function buildDeepInterviewHudSummary(state: DeepInterviewHudState): WorkflowHudSummary;
+export interface DeepInterviewHudDeriveOptions {
+    phase?: string;
+    specStatus?: string;
+    updatedAt?: string;
+}
+/**
+ * Single source of deep-interview HUD derivation. Reads a complete (normalized)
+ * mode-state envelope so recorder, `gjc state write`, reconcile, seed, and handoff
+ * all produce identical chips. Topology-aware `target`/`weakest` come from
+ * `state.topology`; `legacy_missing` topology omits those chips (no synthetic values).
+ */
+export declare function deriveDeepInterviewHud(payload: Record<string, unknown>, options?: DeepInterviewHudDeriveOptions): WorkflowHudSummary;
 export declare function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary;
 export declare function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudSummary;
 export declare function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary;

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

@@ -28,6 +28,7 @@ export interface TaskResultReceipt {
     contextTokens?: number;
     contextWindow?: number;
     modelOverride?: string | string[];
+    modelSubstitutionWarning?: SingleResult["modelSubstitutionWarning"];
     usage?: SingleResult["usage"];
     cost?: number;
     branchName?: string;

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

@@ -280,6 +280,11 @@ export interface AgentDefinition {
     source: AgentSource;
     filePath?: string;
 }
+export interface ModelSubstitutionWarning {
+    requested: string;
+    effective: string;
+    reason: "auth_unavailable" | "assistant_model_mismatch";
+}
 /** Progress tracking for a single agent */
 export interface AgentProgress {
     index: number;
@@ -316,6 +321,7 @@ export interface AgentProgress {
     cost: number;
     durationMs: number;
     modelOverride?: string | string[];
+    modelSubstitutionWarning?: ModelSubstitutionWarning;
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */
     extractedToolData?: Record<string, unknown[]>;
     /**
@@ -374,6 +380,7 @@ export interface SingleResult {
     /** Model's context window in tokens, when known. */
     contextWindow?: number;
     modelOverride?: string | string[];
+    modelSubstitutionWarning?: ModelSubstitutionWarning;
     error?: string;
     aborted?: boolean;
     abortReason?: string;

package/dist/types/thinking-metadata.d.ts

@@ -0,0 +1,16 @@
+export type ThinkingLevelValue = "inherit" | "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/**
+ * Metadata used to render thinking selector values in the coding-agent UI.
+ *
+ * This module is intentionally provider/native-free so schema generation can
+ * import settings metadata before native addons have been built in CI.
+ */
+export interface ThinkingLevelMetadata {
+    value: ThinkingLevelValue;
+    label: string;
+    description: string;
+}
+/**
+ * Returns display metadata for a thinking selector.
+ */
+export declare function getThinkingLevelMetadata(level: ThinkingLevelValue): ThinkingLevelMetadata;

package/dist/types/thinking.d.ts

@@ -1,14 +1,7 @@
 import { type ResolvedThinkingLevel, ThinkingLevel } from "@gajae-code/agent-core/thinking";
 import { type Effort } from "@gajae-code/ai/model-thinking";
 import type { Model } from "@gajae-code/ai/types";
-/**
- * Metadata used to render thinking selector values in the coding-agent UI.
- */
-export interface ThinkingLevelMetadata {
-    value: ThinkingLevel;
-    label: string;
-    description: string;
-}
+export { getThinkingLevelMetadata, type ThinkingLevelMetadata } from "./thinking-metadata";
 /**
  * Parses a provider-facing effort value.
  */
@@ -17,10 +10,6 @@ export declare function parseEffort(value: string | null | undefined): Effort |
  * Parses an agent-local thinking selector.
  */
 export declare function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined;
-/**
- * Returns display metadata for a thinking selector.
- */
-export declare function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata;
 /**
  * Converts an agent-local selector into the effort sent to providers.
  */
@@ -29,3 +18,5 @@ export declare function toReasoningEffort(level: ThinkingLevel | undefined): Eff
  * Resolves a selector against the current model while preserving explicit "off".
  */
 export declare function resolveThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ResolvedThinkingLevel | undefined;
+export declare function clampExplicitThinkingLevelForModel(model: Model | undefined, level: ThinkingLevel | undefined): ThinkingLevel | undefined;
+export declare function formatClampedModelSelector(selector: string, model: Model | undefined): string;

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

@@ -20,7 +20,7 @@ import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
-declare const askSchema: z.ZodObject<{
+export declare const askSchema: z.ZodObject<{
     questions: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         question: z.ZodString;
@@ -29,6 +29,13 @@ declare const askSchema: z.ZodObject<{
         }, z.core.$strip>>;
         multi: z.ZodOptional<z.ZodBoolean>;
         recommended: z.ZodOptional<z.ZodNumber>;
+        deepInterview: z.ZodOptional<z.ZodObject<{
+            round_id: z.ZodOptional<z.ZodString>;
+            round: z.ZodNumber;
+            component: z.ZodString;
+            dimension: z.ZodString;
+            ambiguity: z.ZodNumber;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type AskToolInput = z.infer<typeof askSchema>;
@@ -73,6 +80,13 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
             }, z.core.$strip>>;
             multi: z.ZodOptional<z.ZodBoolean>;
             recommended: z.ZodOptional<z.ZodNumber>;
+            deepInterview: z.ZodOptional<z.ZodObject<{
+                round_id: z.ZodOptional<z.ZodString>;
+                round: z.ZodNumber;
+                component: z.ZodString;
+                dimension: z.ZodString;
+                ambiguity: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly strict = true;

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

@@ -193,6 +193,8 @@ export interface ToolSession {
     getToolChoiceQueue?(): ToolChoiceQueue;
     /** Build a model-provider-specific ToolChoice that targets the named tool, or undefined if unsupported. */
     buildToolChoice?(toolName: string): ToolChoice | undefined;
+    /** Build a named tool-choice decision, preserving whether exact named forcing survived capability degradation. */
+    buildToolChoiceResult?(toolName: string): import("../utils/tool-choice").NamedToolChoiceResult;
     /** Steer a hidden custom message into the conversation (e.g. a preview reminder). */
     steer?(message: {
         customType: string;

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

@@ -21,16 +21,6 @@ export interface ResolveToolDetails {
     label?: string;
     sourceResultDetails?: unknown;
 }
-/**
- * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
- * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
- * callbacks into an onInvoked closure that matches the resolve schema, and
- * steers a preview reminder so the model understands why.
- *
- * This is the canonical entry point for any tool that wants preview/apply
- * semantics. No session-level abstraction is needed: callers pass their
- * apply/reject functions directly.
- */
 export declare function queueResolveHandler(session: ToolSession, options: {
     label: string;
     sourceToolName: string;

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

@@ -46,6 +46,12 @@ export interface SubagentSnapshot {
     progress?: AgentProgress;
     /** True when a live in-session progress producer exists for this subagent. */
     liveProgressAvailable?: boolean;
+    /** Model the subagent actually runs on (after any auth fallback). */
+    effectiveModel?: string;
+    /** Model originally requested via role/preset mapping; differs from effective on fallback. */
+    requestedModel?: string;
+    /** True when the requested model lacked credentials and fell back to the parent model. */
+    modelFellBack?: boolean;
 }
 export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];

package/dist/types/utils/tool-choice.d.ts

@@ -1,7 +1,20 @@
-import type { Api, Model, ToolChoice } from "@gajae-code/ai";
+import type { Api, Model, ResolveToolChoiceResult, ToolChoice } from "@gajae-code/ai";
 /**
  * Build a provider-aware tool choice that targets one specific tool when supported.
  * Providers that only expose required/any forcing may still honor named choices by
  * narrowing their request tool list before transport.
  */
+export interface NamedToolChoiceResult {
+    choice: ToolChoice | undefined;
+    exactNamed: boolean;
+    resolved?: ResolveToolChoiceResult;
+}
+export declare function buildNamedToolChoiceResult(toolName: string, model?: Model<Api>): NamedToolChoiceResult;
+/**
+ * Legacy capability-aware wrapper. May return a lossy `"required"` when named
+ * forcing degrades (e.g. Google APIs, or compat `toolChoiceSupport: "required"`),
+ * which forces *some* tool rather than `toolName` specifically. Queue directives
+ * that need exact tool identity (resolve / todo_write / yield) MUST use
+ * `buildNamedToolChoiceResult` and gate on `exactNamed` instead.
+ */
 export declare function buildNamedToolChoice(toolName: string, model?: Model<Api>): ToolChoice | undefined;