@gajae-code/coding-agent 0.5.0 → 0.5.2

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[];

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

@@ -78,22 +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. */
+/**
+ * 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/history-storage.d.ts

@@ -11,6 +11,6 @@ export declare class HistoryStorage {
     /** @internal Reset the singleton — test-only. */
     static resetInstance(): void;
     add(prompt: string, cwd?: string): Promise<void>;
-    getRecent(limit: number): HistoryEntry[];
-    search(query: string, limit: number): HistoryEntry[];
+    getRecent(limit: number, cwd?: string): HistoryEntry[];
+    search(query: string, limit: number, cwd?: string): HistoryEntry[];
 }

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

@@ -1,7 +1,7 @@
 import type { AgentMessage } from "@gajae-code/agent-core";
 import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@gajae-code/ai";
 import { ArtifactManager } from "./artifacts";
-import { type BlobPutResult } from "./blob-store";
+import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
 import type { SessionStorage } from "./session-storage";
 export declare const CURRENT_SESSION_VERSION = 3;
@@ -234,6 +234,15 @@ declare class RecentSessionInfo {
 export declare function recoverOrphanedBackups(sessionDir: string, storage: SessionStorage): Promise<void>;
 /** Exported for testing */
 export declare function findMostRecentSession(sessionDir: string, storage?: SessionStorage): Promise<string | null>;
+declare const RESIDENT_BLOB_SENTINEL_KEY = "__gjcResidentBlob";
+type ResidentBlobKind = "text" | "imageUrl" | "imageData";
+interface ResidentBlobSentinel {
+    [RESIDENT_BLOB_SENTINEL_KEY]: true;
+    kind: ResidentBlobKind;
+    ref: string;
+}
+export declare function residentBlobSentinelForTests(kind: ResidentBlobKind, ref: string): ResidentBlobSentinel;
+export declare function materializeResidentEntriesForPersistenceForTests<T>(entries: T[], textStore: BlobStore, imageStore?: BlobStore): T[];
 /** Get recent sessions for display in welcome screen */
 export declare function getRecentSessions(sessionDir: string, limit?: number, storage?: SessionStorage): Promise<RecentSessionInfo[]>;
 /**

package/dist/types/setup/credential-import.d.ts

@@ -0,0 +1,79 @@
+import type { AuthCredential } from "@gajae-code/ai";
+/** gjc provider ids that external credentials map onto. */
+export type ExternalProvider = "anthropic" | "openai-codex";
+/** Where a discovered credential came from. */
+export type CredentialOrigin = "claude-code-file" | "claude-code-keychain" | "codex-file";
+/** Human labels for providers, used in redacted summaries. */
+export declare const EXTERNAL_PROVIDER_LABELS: Record<ExternalProvider, string>;
+/** A credential that can be safely imported into gjc's store. */
+export interface ImportableCredential {
+    provider: ExternalProvider;
+    origin: CredentialOrigin;
+    /** Redacted, human-readable description of where this came from. */
+    source: string;
+    kind: AuthCredential["type"];
+    identity?: {
+        email?: string;
+        accountId?: string;
+    };
+    /** Epoch-ms expiry for OAuth credentials, when known. */
+    expiresAt?: number;
+    /** Redacted access token / API key — safe to display. */
+    redactedToken: string;
+    /** Opaque credential payload. Never include this in any summary output. */
+    credential: AuthCredential;
+}
+/** A source that was found but could not be imported. */
+export interface SkippedCredential {
+    origin: CredentialOrigin;
+    source: string;
+    reason: string;
+}
+/** Ambient environment-backed auth that is already usable without import. */
+export interface EnvironmentCredentialHint {
+    provider: ExternalProvider;
+    variable: string;
+    redactedValue: string;
+}
+export interface CredentialDiscoveryResult {
+    importable: ImportableCredential[];
+    skipped: SkippedCredential[];
+    environment: EnvironmentCredentialHint[];
+}
+export interface DiscoveryOptions {
+    /** Override the home directory (defaults to `os.homedir()`). */
+    homeDir?: string;
+    /** Override the environment (defaults to `process.env`). */
+    env?: Record<string, string | undefined>;
+    /** Override the platform (defaults to `process.platform`). */
+    platform?: NodeJS.Platform;
+    /**
+     * Reader for the macOS Keychain `Claude Code-credentials` entry. Defaults to
+     * shelling out to `security`; injected in tests. Returns the raw JSON string,
+     * or `null` when no entry exists.
+     */
+    readClaudeKeychain?: () => Promise<string | null>;
+}
+export type CredentialUpserter = (provider: string, credential: AuthCredential) => unknown | Promise<unknown>;
+export interface ImportSummary {
+    imported: ImportableCredential[];
+    failed: Array<{
+        credential: ImportableCredential;
+        error: string;
+    }>;
+}
+/**
+ * Discover Claude Code and Codex CLI credentials across files, the macOS
+ * Keychain, and environment variables. Never throws for individual unreadable or
+ * malformed sources — those land in {@link CredentialDiscoveryResult.skipped}.
+ */
+export declare function discoverExternalCredentials(options?: DiscoveryOptions): Promise<CredentialDiscoveryResult>;
+/** Redacted one-line summary of an importable credential. Never includes secrets. */
+export declare function formatCredentialSummary(credential: ImportableCredential): string;
+/** Redacted summary lines for an entire discovery result. Never includes secrets. */
+export declare function formatDiscoverySummary(result: CredentialDiscoveryResult): string[];
+/**
+ * Persist discovered credentials via `upsert`. Each credential is imported
+ * independently; a failure on one is recorded without aborting the rest.
+ */
+export declare function importCredentials(credentials: readonly ImportableCredential[], upsert: CredentialUpserter): Promise<ImportSummary>;

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/executor.d.ts

@@ -105,6 +105,7 @@ interface FinalizeSubprocessOutputResult {
 export declare const SUBAGENT_WARNING_NULL_YIELD = "SYSTEM WARNING: Subagent called yield with null data.";
 export declare const SUBAGENT_WARNING_MISSING_YIELD = "SYSTEM WARNING: Subagent exited without calling yield tool after 3 reminders.";
 export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputArgs): FinalizeSubprocessOutputResult;
+export declare function createSubagentSettings(baseSettings: Settings): Settings;
 /**
  * Run a single agent in-process.
  */

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

@@ -11,7 +11,7 @@ export declare function renderCall(args: TaskParams, _options: RenderResultOptio
  * `subagent` await panel. Reuses the internal task-progress renderer so the
  * await panel stays at parity with the inline task panel.
  */
-export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number): string[];
+export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number, staticTime?: boolean): string[];
 /**
  * Render the tool result.
  */

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/subagent-render.d.ts

@@ -10,7 +10,13 @@
 import type { Component } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import type { SubagentToolDetails } from "./subagent";
+import { type SubagentToolDetails } from "./subagent";
+/** Test-only seam (PR3 deterministic cache-hit assertions). */
+export declare const subagentBodyCacheTestHooks: {
+    readonly bodyRenders: number;
+    readonly size: number;
+    reset(): void;
+};
 export declare const subagentToolRenderer: {
     inline: boolean;
     renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component;

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[];
@@ -84,4 +90,25 @@ export declare class SubagentTool implements AgentTool<typeof subagentSchema, Su
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: SubagentParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SubagentToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<SubagentToolDetails>>;
 }
+/**
+ * Canonical, value-based rendered-state signature for the `subagent` await panel.
+ *
+ * Producer-side await gating compares this signature against the last emitted one
+ * and only fires `onUpdate` when the *rendered* state actually changed. Unchanged
+ * idle ticks therefore stop rebuilding the renderer component and stop mutating
+ * transcript lines above the viewport, which is what triggers TUI full-redraw
+ * storms (`tui.ts` `firstChanged < viewportTop`).
+ *
+ * It is deliberately value-based, never object identity: `AsyncJobManager.record-
+ * SubagentProgress` stores a `structuredClone` but `getSubagentProgress` returns
+ * the retained object by reference, so identity comparison would be both noisy and
+ * unsafe.
+ *
+ * Time-derived fields are intentionally excluded so the panel does not churn while
+ * idle: raw durations (`durationMs`), current-tool elapsed (`currentToolStartMs`),
+ * and retry countdowns (`retryState.startedAtMs`) are omitted. Idle duration and
+ * countdown ticking is sacrificed by design; every real transition still changes
+ * the signature.
+ */
+export declare function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[]): string;
 export {};

package/dist/types/tools/ultragoal-ask-guard.d.ts

@@ -0,0 +1,5 @@
+import type { AgentTool } from "@gajae-code/agent-core";
+import { type UltragoalAskBlockDiagnostic } from "../gjc-runtime/ultragoal-guard";
+export declare function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string;
+export declare function assertUltragoalAskAllowed(cwd: string): Promise<void>;
+export declare function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string): T;

package/dist/types/web/search/index.d.ts

@@ -10,7 +10,7 @@ import * as z from "zod/v4";
 import type { CustomTool } from "../../extensibility/custom-tools/types";
 import type { ToolSession } from "../../tools";
 import { type SearchRenderDetails } from "./render";
-import type { SearchProviderId } from "./types";
+import type { ActiveSearchModelContext, SearchProviderId } from "./types";
 /** Web search tool parameters schema */
 export declare const webSearchSchema: z.ZodObject<{
     query: z.ZodString;
@@ -40,7 +40,7 @@ export declare function runSearchQuery(params: SearchQueryParams, options?: {
     authStorage?: AuthStorage;
     sessionId?: string;
     signal?: AbortSignal;
-    activeModelProvider?: string;
+    activeModelContext?: ActiveSearchModelContext;
 }): Promise<{
     content: Array<{
         type: "text";
@@ -80,6 +80,6 @@ export declare class WebSearchTool implements AgentTool<typeof webSearchSchema,
 /** Web search tool as CustomTool (for TUI rendering support) */
 export declare const webSearchCustomTool: CustomTool<typeof webSearchSchema, SearchRenderDetails>;
 export declare function getSearchTools(): CustomTool<any, any>[];
-export { getSearchProvider, setPreferredSearchProvider } from "./provider";
+export { getSearchProvider, setPreferredSearchProvider, setSearchFallbackProviders } from "./provider";
 export type { SearchProviderId as SearchProvider, SearchResponse } from "./types";
-export { isSearchProviderPreference } from "./types";
+export { isConfigurableSearchProviderId, isSearchProviderPreference } from "./types";

package/dist/types/web/search/provider.d.ts

@@ -1,28 +1,24 @@
 import type { AuthStorage } from "@gajae-code/ai";
 import type { SearchProvider } from "./providers/base";
-import type { SearchProviderId } from "./types";
+import type { ActiveSearchModelContext, SearchProviderId } from "./types";
 export type { SearchParams } from "./providers/base";
 export { SearchProvider } from "./providers/base";
-/** Cheap, sync metadata accessor — never triggers a provider load. */
 export declare function getSearchProviderLabel(id: SearchProviderId): string;
-/**
- * Resolve and cache a provider instance. First call for a given id loads the
- * underlying module; subsequent calls return the cached singleton.
- */
 export declare function getSearchProvider(id: SearchProviderId): Promise<SearchProvider>;
 export declare const SEARCH_PROVIDER_ORDER: SearchProviderId[];
-/** Set the preferred web search provider from settings */
 export declare function setPreferredSearchProvider(provider: SearchProviderId | "auto"): void;
-/**
- * Resolve the ordered provider chain for a search request.
- *
- * Resolution is active-model-gated, never credential-scanning:
- *   1. An explicitly preferred provider (settings) that is available is primary.
- *   2. Otherwise the active model's own native search is primary, but only when
- *      that provider's own credentials are present (its `isAvailable()`).
- *   3. DuckDuckGo (keyless) is always appended as the terminal fallback, so a
- *      missing primary — or a primary runtime failure — still returns results
- *      with zero configuration. Keyed standalone providers are never
- *      auto-selected; they are reachable only via explicit selection (step 1).
- */
-export declare function resolveProviderChain(authStorage: AuthStorage, preferredProvider?: SearchProviderId | "auto", activeModelProvider?: string): Promise<SearchProvider[]>;
+export declare function setSearchFallbackProviders(ids: readonly string[]): void;
+export interface ResolveProviderChainOptions {
+    authStorage: AuthStorage;
+    sessionId?: string;
+    signal?: AbortSignal;
+    preferredProvider?: SearchProviderId | "auto";
+    activeModelContext?: ActiveSearchModelContext;
+    fallbackProviders?: readonly SearchProviderId[];
+}
+export declare function looksHostedModelId(modelId: string | undefined): boolean;
+export declare function isLocalBaseUrl(baseUrl: string | undefined): boolean;
+export declare function inferNativeProviderFromModel(ctx: ActiveSearchModelContext | undefined): SearchProviderId | undefined;
+export declare function canUseGenericCredentials(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
+export declare function shouldTryGenericOpenAICompat(authStorage: AuthStorage, ctx: ActiveSearchModelContext | undefined, sessionId?: string, signal?: AbortSignal): Promise<boolean>;
+export declare function resolveProviderChain(options: ResolveProviderChainOptions): Promise<SearchProvider[]>;

package/dist/types/web/search/providers/base.d.ts

@@ -1,5 +1,5 @@
 import type { AuthStorage } from "@gajae-code/ai";
-import type { SearchProviderId, SearchResponse } from "../types";
+import type { ActiveSearchModelContext, SearchProviderId, SearchResponse } from "../types";
 /**
  * Shared web search parameters passed to providers.
  *
@@ -49,6 +49,7 @@ export interface SearchParams {
      * caller's agent session when available; otherwise omit.
      */
     sessionId?: string;
+    activeModelContext?: ActiveSearchModelContext;
 }
 /** Base class for web search providers. */
 export declare abstract class SearchProvider {

package/dist/types/web/search/providers/openai-compatible.d.ts

@@ -0,0 +1,9 @@
+import type { SearchResponse } from "../types";
+import type { SearchParams } from "./base";
+import { SearchProvider } from "./base";
+export declare class OpenAICompatibleSearchProvider extends SearchProvider {
+    readonly id: "openai-compatible";
+    readonly label = "OpenAI-compatible";
+    isAvailable(): boolean;
+    search(params: SearchParams): Promise<SearchResponse>;
+}

package/dist/types/web/search/types.d.ts

@@ -4,9 +4,21 @@
  * Unified types for web search responses across supported providers.
  */
 /** Supported web search providers */
-export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng";
+export type SearchProviderId = "duckduckgo" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
+export type WebSearchMode = "on" | "off" | "auto";
+export interface ActiveSearchModelContext {
+    provider: string;
+    modelId: string;
+    wireModelId?: string;
+    api: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    webSearch?: WebSearchMode;
+}
+export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "tavily", "parallel", "kagi", "synthetic", "searxng"];
 export declare function isSearchProviderId(value: string): value is SearchProviderId;
-export declare function isSearchProviderPreference(value: string): value is SearchProviderId | "auto";
+export declare function isConfigurableSearchProviderId(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number];
+export declare function isSearchProviderPreference(value: string): value is (typeof CONFIGURABLE_SEARCH_PROVIDER_IDS)[number] | "auto";
 /** Source returned by search (all providers) */
 export interface SearchSource {
     title: string;

package/package.json

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

package/scripts/build-binary.ts

@@ -5,6 +5,12 @@ import * as path from "node:path";
 const packageDir = path.join(import.meta.dir, "..");
 const outputPath = path.join(packageDir, "dist", "gjc");
 const nativeDir = path.join(packageDir, "..", "natives", "native");
+// Lazy native tokenizer entrypoint. `agent-core/compaction` loads this from
+// the explicit native entrypoint instead of a package-name dynamic require of
+// `@gajae-code/natives`, because those fail inside Bun standalone `$bunfs`.
+// Listing the module here makes the absolute target path exist in the compiled
+// bunfs.
+const nativeTokenizerEntrypoint = "../natives/native/index.js";
 
 function shouldAdhocSignDarwinBinary(): boolean {
 	return process.platform === "darwin";
@@ -66,6 +72,7 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
+					nativeTokenizerEntrypoint,
 					"--outfile",
 					"dist/gjc",
 				],

package/src/async/job-manager.ts

@@ -13,6 +13,14 @@ export interface AsyncJob {
 	type: "bash" | "task";
 	status: "running" | "completed" | "failed" | "cancelled" | "paused";
 	startTime: number;
+
+	/**
+	 * Wall-clock ms when the job left the `running` state (completed, failed,
+	 * cancelled, or paused). Undefined while running. Frozen on the first
+	 * terminal/pause transition so elapsed-time renderers stop counting once a
+	 * job is no longer active instead of growing forever against `Date.now()`.
+	 */
+	endTime?: number;
 	label: string;
 	abortController: AbortController;
 	promise: Promise<void>;
@@ -28,6 +36,16 @@ export interface AsyncJob {
 	ownerId?: string;
 }
 
+/**
+ * Elapsed wall-clock ms for a job, frozen once it stops running. While the job
+ * is active (`endTime` undefined) this counts against `now`; after it stops it
+ * returns the fixed `endTime - startTime` span so status renderers do not keep
+ * incrementing a completed job's timer.
+ */
+export function jobElapsedMs(job: Pick<AsyncJob, "startTime" | "endTime">, now: number = Date.now()): number {
+	return Math.max(0, (job.endTime ?? now) - job.startTime);
+}
+
 export interface AsyncJobMetadata {
 	subagent?: {
 		id: string;
@@ -80,6 +98,12 @@ export interface SubagentRecord {
 	/** False for ephemeral sessions (no persistent artifacts dir). */
 	resumable: boolean;
 	queued?: { ownerId?: string; seq: number; message?: string; createdAt: number };
+	/** Resolved model the subagent was asked to use, e.g. "openai-codex/gpt-5.5". */
+	requestedModel?: string;
+	/** Model actually used after auth fallback (#985); equals requestedModel when no fallback. */
+	effectiveModel?: string;
+	/** True when the requested model lacked credentials and the subagent fell back to the parent model. */
+	modelFellBack?: boolean;
 }
 
 /** Lightweight, manager-owned resume payload. The async layer treats `data` as opaque. */
@@ -368,6 +392,7 @@ export class AsyncJobManager {
 					// delivery and no eviction scheduling: a paused subagent stays
 					// listed and resumable from its sessionFile.
 					job.status = "paused";
+					this.#freezeEndTime(job);
 					if (outcome.note) job.resultText = outcome.note;
 					this.#markRecordPaused(id);
 					this.#drainResumeQueue();
@@ -375,6 +400,7 @@ export class AsyncJobManager {
 				}
 
 				job.status = "completed";
+				this.#freezeEndTime(job);
 				job.resultText = outcome.text;
 				this.#enqueueDelivery(id, outcome.text);
 				this.#runLifecycle(id, "terminal");
@@ -393,6 +419,7 @@ export class AsyncJobManager {
 				this.#runLifecycle(id, "terminal");
 				const errorText = error instanceof Error ? error.message : String(error);
 				job.status = "failed";
+				this.#freezeEndTime(job);
 				job.errorText = errorText;
 				this.#enqueueDelivery(id, errorText);
 				this.#scheduleEviction(id);
@@ -428,10 +455,22 @@ export class AsyncJobManager {
 		if (job.status !== "running") return false;
 		this.#runLifecycle(id, "cancel");
 		job.status = "cancelled";
+		this.#freezeEndTime(job);
 		job.abortController.abort();
 		return true;
 	}
 
+	/**
+	 * Freeze the wall-clock instant a job stopped running. Idempotent: the
+	 * first stop (completed/failed/cancelled/paused) wins so elapsed-time
+	 * renderers report a stable duration instead of counting against
+	 * `Date.now()` forever. A resumed subagent registers a brand-new job with
+	 * its own `startTime`, so a paused job's frozen `endTime` is never reused.
+	 */
+	#freezeEndTime(job: AsyncJob): void {
+		job.endTime ??= Date.now();
+	}
+
 	#runLifecycle(jobId: string, phase: "cancel" | "terminal" | "evict"): void {
 		const fired = this.#lifecyclePhases.get(jobId) ?? new Set<"cancel" | "terminal" | "evict">();
 		if (fired.has(phase)) return;
@@ -503,6 +542,18 @@ export class AsyncJobManager {
 		this.#subagentRecords.set(record.subagentId, record);
 	}
 
+	/** Patch model metadata onto an existing subagent record (best-effort; no-op if unknown). */
+	updateSubagentModel(
+		subagentId: string,
+		model: { requestedModel?: string; effectiveModel?: string; modelFellBack?: boolean },
+	): void {
+		const record = this.#subagentRecords.get(subagentId);
+		if (!record) return;
+		record.requestedModel = model.requestedModel;
+		record.effectiveModel = model.effectiveModel;
+		record.modelFellBack = model.modelFellBack;
+	}
+
 	getSubagentRecord(subagentId: string, filter?: AsyncJobFilter): SubagentRecord | undefined {
 		const rec = this.#subagentRecords.get(subagentId.trim());
 		if (!rec) return undefined;
@@ -978,6 +1029,7 @@ export class AsyncJobManager {
 		for (const job of this.getRunningJobs(filter)) {
 			this.#runLifecycle(job.id, "cancel");
 			job.status = "cancelled";
+			this.#freezeEndTime(job);
 			job.abortController.abort();
 			this.#scheduleEviction(job.id);
 		}