@gajae-code/coding-agent 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## [Unreleased]
 
+## [0.5.2] - 2026-06-15
+
+### Fixed
+
+- Prevented `gjc --tmux` partial-launch diagnostics from throwing when stderr is already closed during shutdown.
+- Fixed v0.5.1-style macOS/Linux standalone binaries crashing before the first model request with `Cannot find module '@gajae-code/natives' from '/$bunfs/root/gjc-*'` when pre-prompt context maintenance invokes the native tokenizer.
+- Mapped the retired `codex-standard` model profile name to `codex-medium` during profile activation, **as a fallback only** so a user-defined profile literally named `codex-standard` is never shadowed, letting stale `modelProfile.default: codex-standard` configs reach activation instead of blocking startup after the rebuilt profile catalog.
+- Fixed interactive goal-mode auto-continuation looping `Error: Agent is already processing…` (`AgentBusyError`) while the session is busy. A wedged/orphaned subagent turn — or an in-progress compaction — can leave the session non-idle while the interactive loop is back at `getUserInput()`; the 800 ms continuation timer then fired `prompt()`, threw `AgentBusyError`, surfaced it via `showError`, and re-armed — spamming the error roughly every 800 ms. The continuation now skips and re-arms while `isStreaming`/`isCompacting`, firing only once the session returns to idle.
+- Fixed the built-in `minimax-eco`/`minimax-medium`/`minimax-pro` model profiles 400ing on activation because every role pinned the non-existent `minimax-code/minimax-v3`. All three profiles now pin `minimax-code/minimax-m3`, the canonical `minimax-code` default already present in the bundled models catalog (#656).
+- Fixed the native Stop hook letting a deep-interview run terminalize through the ordinary stop path without crystallizing its distilled interview state. A deep-interview mode-state that would release the Stop block (e.g. `active:true` with a `complete`/`completed`/`inactive` phase) is now held until it has actually persisted a final spec — a `spec_path` that still resolves to a real `.gjc/specs/` artifact — and the public-safe diagnostic points the agent at `gjc deep-interview --write --stage final` (optionally `--handoff ralplan`). The guard is scoped to deep-interview only: explicit abort/cancel phases (`failed`/`cancelled`/`canceled`) and the `active:false` demotion/clear outcome remain legitimate terminals, and no other workflow's stop behavior changes (#674).
+
+### Added
+
+- Added three bundled dark TUI migration themes — `claude-code`, `codex`, and `opencode` — whose palettes mirror the Claude Code, OpenAI Codex CLI, and opencode TUIs for easy eye-migration. They join the crustacean defaults (`red-claw` dark, `blue-crab` light) as selectable built-ins via Settings or `/theme`; defaults are unchanged and the new themes keep GJC's default symbol identity. A built-in inventory test now validates every bundled theme against the required `THEME_COLOR_KEYS` token set, name/key equality, var resolution, dark classification, and brand-vs-semantic token separation.
+- Documented and regression-guarded the `gjc --tmux` scroll/mouse profile so WSL/Linux launches are not left guessing about mouse-wheel scrolling. The GJC-managed tmux session already applies `mouse on` (plus `set-clipboard on` and a readable copy-mode `mode-style`) scoped to the GJC session only, on macOS/Linux/WSL alike (only native `win32` skips the tmux launch); a new launch-path test asserts a WSL/Linux `--tmux` launch issues session-scoped `set-option ... mouse on` (never global `set -g`) and that `GJC_MOUSE=off` opts out without dropping the ownership tags. `docs/environment-variables.md` now documents the `--tmux` startup env vars (`GJC_LAUNCH_POLICY`, `GJC_TMUX_SESSION`, `GJC_TMUX_COMMAND`, `GJC_TMUX_PROFILE`, `GJC_MOUSE`) and the WSL/Windows Terminal scroll behavior (tmux copy-mode wheel scroll vs. native scrollback, copy-mode keyboard fallback, and that GJC never modifies tmux sessions you started yourself), and `gjc --help` surfaces `GJC_TMUX_PROFILE`/`GJC_MOUSE` (#650).
+- Added a subagent-scoped `task.serviceTier` setting (default `"inherit"`) so the service tier / fast mode applied to task-tool subagents can be controlled independently of the main session. `"inherit"` keeps the current behavior (the main session tier is copied into each subagent's isolated settings snapshot), while any explicit value (`none`, `priority`, `openai-only`, `claude-only`, …) overrides only the subagent sessions, which already read `serviceTier` from their own settings. Implemented in `createSubagentSettings` with a focused test covering inherit and explicit-override behavior (#664).
+
+## [0.5.1] - 2026-06-14
+
+### Added
+
+- `gjc --mode rpc` registers each live session in a cross-process registry (`<agent-dir>/rpc-sessions/<id>.json`) on start and removes it on shutdown, so other processes can enumerate running RPC sessions. The Python `gjc_rpc` client exposes `list_sessions()` / `RpcClient.list_sessions()` returning typed `SessionHandle`s and reaps records whose owning process is gone (issue 10; foundation for reattach/issue 09).
+- `gjc --mode rpc --listen <socket-path>` runs a persistent Unix-domain-socket RPC server: the `AgentSession` outlives client disconnects (no stdin-EOF teardown) and a client can disconnect and reconnect to the same live session over the socket. The session is registered with `transport: "socket"` and the socket path as its `endpoint`, so it is discoverable/attachable via the registry. The stdio path is unchanged (frame output routes through a swappable sink shared by both transports) (issue 09).
+
+### Fixed
+
+- Subagent/job status panels now freeze a job's elapsed timer the moment it stops running (`completed`/`failed`/`cancelled`/`paused`) instead of counting up against `Date.now()` forever. `AsyncJob` records an `endTime` on the first terminal/pause transition and a shared `jobElapsedMs` helper backs the `subagent` panel, the `job` tool, `/jobs`, and the command-controller job line, so a finished subagent stops at its real duration while siblings keep ticking.
+- RPC control-plane hardening (from dogfooding `gjc --mode rpc`): `dispatchRpcCommand` now wraps the command switch so failures return a correlated response carrying the request `id` and the real command name, instead of dropping the id and mislabeling handler exceptions as `parse`; `set_thinking_level`/`set_steering_mode`/`set_follow_up_mode`/`set_interrupt_mode` validate their inputs and reject out-of-contract values instead of silently corrupting session state; `negotiate_unattended` rejects unknown scopes/action classes with `invalid_unattended_declaration` and merges the mandatory `prompt` scope plus its `command.prompt` action floor into the accepted grant (so prompt/`workflow_gate_response` are never locked out); and read-only/control RPC commands no longer consume the unattended `max_tool_calls` budget while wall-time enforcement is preserved. `docs/rpc.md`'s first `workflow_gate` example now matches the canonical `RpcWorkflowGate` shape.
+- RPC mode no longer head-of-line-blocks control/cancellation commands behind a long-running command: the stdin loop now dispatches ordered commands through a serial chain (so causal order is preserved — e.g. `get_state` after `bash` still observes the bash result) without blocking the reader, and routes `abort`/`abort_bash`/`abort_retry` on an immediate fast lane so they reach in-flight work. `abort_bash` can now cancel a running `bash`, and a slow `compact`/`handoff`/`login` no longer freezes the whole control plane. Shutdown drains in-flight commands (bounded) so their responses are still emitted on stdin EOF.
+- Counted active prompts and agent-initiated custom messages in pre-prompt context maintenance so background task notifications trigger compaction before they can overflow the next model request.
+- Bounded monitor task-notification payloads to a compact tail window while preserving full background job output for job inspection.
+
+### Changed
+
+- Expanded coordinator MCP coordination status into a canonical polling snapshot for sessions, session states, turns, questions, reports, and bounded event summaries, and documented that Hermes/coordinator consumption is polling/await rather than push subscription.
+
 ## [0.5.0] - 2026-06-13
 
 ### Fixed

package/README.md

@@ -34,4 +34,4 @@ Switching backends mid-session is honoured on the next system-prompt rebuild and
 
 ## Red-claw TUI theme
 
-The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals and the bundled `blue-crab` theme for light-appearance terminals, with matching welcome/icon assets. Explicit user theme settings still win; set `theme.dark: red-claw` and `theme.light: blue-crab` in `~/.gjc/agent/config.yml` to pin them.
+The interactive TUI defaults to the bundled `red-claw` crustacean theme for dark terminals and the bundled `blue-crab` theme for light-appearance terminals, with matching welcome/icon assets. Three additional bundled migration themes — `claude-code`, `codex`, and `opencode` — mirror the look of those tools for easy eye-migration and are selectable from Settings or `/theme`. Explicit user theme settings still win; set `theme.dark: red-claw` and `theme.light: blue-crab` in `~/.gjc/agent/config.yml` to pin them.

package/dist/types/async/job-manager.d.ts

@@ -4,6 +4,13 @@ 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>;
@@ -18,6 +25,13 @@ 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 declare function jobElapsedMs(job: Pick<AsyncJob, "startTime" | "endTime">, now?: number): number;
 export interface AsyncJobMetadata {
     subagent?: {
         id: string;
@@ -77,6 +91,12 @@ export interface SubagentRecord {
         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. */
 export interface ResumeDescriptor {
@@ -184,6 +204,12 @@ export declare class AsyncJobManager {
     };
     /** Register or replace the canonical record for a subagent. */
     registerSubagentRecord(record: SubagentRecord): void;
+    /** 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;
     getSubagentRecord(subagentId: string, filter?: AsyncJobFilter): SubagentRecord | undefined;
     getSubagentRecords(filter?: AsyncJobFilter): SubagentRecord[];
     registerLiveHandle(subagentId: string, handle: SubagentLiveHandle): void;

package/dist/types/cli/args.d.ts

@@ -24,6 +24,7 @@ export interface Args {
     mode?: Mode;
     noSession?: boolean;
     sessionDir?: string;
+    rpcListen?: string;
     providerSessionId?: string;
     fork?: string;
     models?: string[];

package/dist/types/cli/list-models.d.ts

@@ -1,4 +1,5 @@
 import type { ModelRegistry } from "../config/model-registry";
+import { type ExtensionFactory } from "../extensibility/extensions";
 /**
  * List available models, optionally filtered by search pattern
  */
@@ -11,6 +12,11 @@ export interface RunListModelsOptions {
     cwd: string;
     /** CLI-supplied extension paths (e.g. from `-e <path>`). */
     additionalExtensionPaths?: string[];
+    /** In-process extension factories to load without filesystem discovery. */
+    extensionFactories?: Array<{
+        factory: ExtensionFactory;
+        name: string;
+    }>;
     /** Extension paths configured under `extensions:` in user settings. */
     settingsExtensions?: string[];
     /** Disabled extension ids from settings (`disabledExtensions`). */

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

@@ -1,4 +1,9 @@
-export type SetupComponent = "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
+/**
+ * Setup CLI command handler.
+ *
+ * Handles `gjc setup [component]` to install the normal defaults or optional feature dependencies.
+ */
+export type SetupComponent = "credentials" | "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {
@@ -27,6 +32,8 @@ export interface SetupCommandArgs {
         gjcCommand?: string;
         target?: string;
         profileDir?: string;
+        yes?: boolean;
+        dryRun?: boolean;
     };
 }
 /**

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

@@ -0,0 +1,26 @@
+import { Command } from "@gajae-code/utils/cli";
+export default class Gc extends Command {
+    static description: string;
+    static strict: boolean;
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+        prune: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+        force: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+        "dry-run": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -93,6 +93,13 @@ export default class Setup extends Command {
         "models-path": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        yes: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+        };
+        "dry-run": import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
     };
     run(): Promise<void>;
 }

package/dist/types/config/file-lock-gc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GC adapter for config file-locks (`<file>.lock` dirs holding `{pid, timestamp}`).
+ */
+import type { GcStoreAdapter } from "../gjc-runtime/gc-runtime";
+export declare const fileLocksGcAdapter: GcStoreAdapter;

package/dist/types/config/file-lock.d.ts

@@ -3,4 +3,33 @@ export interface FileLockOptions {
     retries?: number;
     retryDelayMs?: number;
 }
+/** @internal */
+export declare function readFileLockInfoForGc(lockDir: string): Promise<{
+    pid: number;
+    timestamp: number;
+} | null>;
+/** Owner identity stamped into a `<file>.lock/info` record. */
+export interface FileLockOwnerToken {
+    pid: number;
+    timestamp: number;
+}
+/** Outcome of a guarded GC removal attempt (`removeFileLockDirForGc`). */
+export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
+/**
+ * @internal
+ * Fail-closed removal of a dead lock dir for GC. Re-reads the on-disk owner
+ * token as close to the unlink as possible and only deletes the dir when it
+ * STILL holds the exact `{pid, timestamp}` identity the caller observed dead.
+ *
+ * Closes the prune-time TOCTOU window (#606): between GC's dead re-read/probe
+ * and the unlink, a live process can reclaim a stale lock at the same path
+ * (`acquireLock` rms the stale dir, then re-`mkdir`s and rewrites `info` with a
+ * fresh pid+timestamp). Deleting by path alone would reap that LIVE lock. Any
+ * mismatch (`owner_changed`) or absent/unreadable info (`missing` — e.g. a
+ * fresh acquirer between `mkdir` and `writeLockInfo`) refuses the delete and
+ * leaves the dir intact. POSIX has no atomic compare-and-delete for a
+ * directory, so the residual read->unlink window cannot be fully eliminated,
+ * but the reclaim-after-stale scenario the issue describes is now guarded.
+ */
+export declare function removeFileLockDirForGc(lockDir: string, expected: FileLockOwnerToken): Promise<FileLockGcRemoval>;
 export declare function withFileLock<T>(filePath: string, fn: () => Promise<T>, options?: FileLockOptions): Promise<T>;

package/dist/types/config/model-registry.d.ts

@@ -2,6 +2,7 @@ import { type Api, type AssistantMessageEventStream, type CacheRetention, type C
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
 import { type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage } from "../session/auth-storage";
+import type { ActiveSearchModelContext, WebSearchMode } from "../web/search/types";
 import { type ConfigError, ConfigFile } from "./config-file";
 import { type CanonicalModelIndex, type CanonicalModelRecord, type CanonicalModelVariant, type ModelEquivalenceConfig } from "./model-equivalence";
 import { type ModelProfileDefinition } from "./model-profiles";
@@ -87,6 +88,7 @@ export declare const ModelsConfigFile: ConfigFile<{
             supportsStrictMode?: boolean | undefined;
             toolStrictMode?: "all_strict" | "none" | undefined;
         } | undefined;
+        webSearch?: "auto" | "off" | "on" | undefined;
         authHeader?: boolean | undefined;
         auth?: "apiKey" | "none" | "oauth" | undefined;
         discovery?: {
@@ -364,6 +366,8 @@ export declare class ModelRegistry {
      * Get the base URL associated with a provider, if any model defines one.
      */
     getProviderBaseUrl(provider: string): string | undefined;
+    getProviderWebSearchMode(provider: string): WebSearchMode | undefined;
+    getActiveSearchModelContext(model: Model<Api>): ActiveSearchModelContext;
     /**
      * Get API key for a model.
      */

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

@@ -333,6 +333,11 @@ export declare const ModelsConfigSchema: z.ZodObject<{
                 none: "none";
             }>>;
         }, z.core.$strip>>;
+        webSearch: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            off: "off";
+            on: "on";
+        }>>;
         authHeader: z.ZodOptional<z.ZodBoolean>;
         auth: z.ZodOptional<z.ZodEnum<{
             apiKey: "apiKey";

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

@@ -86,6 +86,9 @@ interface EnumDef<T extends readonly string[]> {
 interface ArrayDef<T> {
     type: "array";
     default: T[];
+    items?: {
+        enum: readonly string[];
+    };
     ui?: UiBase;
 }
 interface RecordDef<T> {
@@ -956,6 +959,53 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "task.serviceTier": {
+        readonly type: "enum";
+        readonly values: readonly ["inherit", "none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+        readonly default: "inherit";
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "Subagent Service Tier";
+            readonly description: 'Service tier applied to task-tool subagents only. "inherit" copies the main session tier; any explicit value overrides it for subagents without touching the main session.';
+            readonly options: readonly [{
+                readonly value: "inherit";
+                readonly label: "Inherit";
+                readonly description: "Use the main session's service tier (default)";
+            }, {
+                readonly value: "none";
+                readonly label: "None";
+                readonly description: "Omit service_tier for subagents";
+            }, {
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Use provider default tier selection (OpenAI)";
+            }, {
+                readonly value: "default";
+                readonly label: "Default";
+                readonly description: "Standard priority processing (OpenAI)";
+            }, {
+                readonly value: "flex";
+                readonly label: "Flex";
+                readonly description: "Flexible capacity tier when available (OpenAI)";
+            }, {
+                readonly value: "scale";
+                readonly label: "Scale";
+                readonly description: "Scale Tier credits when available (OpenAI)";
+            }, {
+                readonly value: "priority";
+                readonly label: "Priority";
+                readonly description: "Priority on every supported provider (OpenAI `service_tier`, Anthropic fast mode)";
+            }, {
+                readonly value: "openai-only";
+                readonly label: "Priority (OpenAI only)";
+                readonly description: "Priority on OpenAI/OpenAI-Codex requests; ignored elsewhere";
+            }, {
+                readonly value: "claude-only";
+                readonly label: "Priority (Claude only)";
+                readonly description: "Anthropic fast mode on direct Claude requests; ignored elsewhere (incl. Bedrock/Vertex)";
+            }];
+        };
+    };
     readonly "retry.enabled": {
         readonly type: "boolean";
         readonly default: true;
@@ -2411,6 +2461,18 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the web_search tool for web searching";
         };
     };
+    readonly "web_search.fallback": {
+        readonly type: "array";
+        readonly default: string[];
+        readonly items: {
+            readonly enum: readonly ["duckduckgo", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "tavily", "parallel", "kagi", "synthetic", "searxng"];
+        };
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "Web Search Fallback";
+            readonly description: "Ordered fallback web search providers after the active model native provider";
+        };
+    };
     readonly "browser.enabled": {
         readonly type: "boolean";
         readonly default: true;

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_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"];
+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"];
 export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/defaults/gjc/extensions/grok-build/index.d.ts

@@ -0,0 +1 @@
+export { default } from "../grok-cli-vendor/src/index.js";

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/index.d.ts

@@ -0,0 +1 @@
+export { default } from './provider/register.js';

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/models/catalog.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Model definitions for Grok CLI's API.
+ */
+export interface GrokCliModelConfig {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    input: ('text' | 'image')[];
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+    /** Models that don't support reasoning.effort get a thinkingLevelMap. */
+    thinkingLevelMap?: Record<string, string | null>;
+}
+export declare function supportsReasoningEffort(modelId: string): boolean;
+/**
+ * Resolve the active model list. If `GJC_GROK_CLI_MODELS` is set,
+ * it filters/reorders the fallback list; unknown IDs get sensible defaults.
+ */
+export declare function resolveModels(): GrokCliModelConfig[];

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/payload/sanitize.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Payload sanitization for xAI's Responses API via cli-chat-proxy.grok.com.
+ *
+ * xAI's endpoint has quirks compared to stock OpenAI:
+ *   - Replayed or encrypted `reasoning` items in input cause 400 errors.
+ *   - `reasoning.effort` is only supported on a subset of models.
+ *   - Empty-string content items cause validation failures.
+ *   - `function_call_output.output` cannot contain image arrays.
+ *   - `image_url` parts must be normalized to `input_image` with data URIs.
+ *   - Local image paths must be resolved to base64 data URIs.
+ *   - xAI rejects `role: "developer"` and `role: "system"` in the input
+ *     array; these must be moved to top-level `instructions`.
+ *   - xAI uses `text.format` instead of OpenAI's `response_format`.
+ *   - xAI uses `prompt_cache_key` for conversation caching.
+ *   - xAI doesn't support `prompt_cache_retention`.
+ *
+ * Additional Grok CLI-specific behavior:
+ *   - Adds x-grok-* headers for client identification
+ *   - Uses prompt_cache_key for session affinity
+ */
+/**
+ * Sanitize a provider request payload for xAI's Responses API via
+ * cli-chat-proxy.grok.com.
+ *
+ * Returns the modified payload.  Mutates the input in place for efficiency.
+ */
+export declare function sanitizePayload(params: Record<string, unknown>, modelId: string, sessionId: string | undefined, cwd: string): Record<string, unknown>;

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/provider/billing.d.ts

@@ -0,0 +1,8 @@
+interface BillingUsage {
+    monthlyLimit: number;
+    used: number;
+    billingPeriodEnd: string;
+}
+export declare function fetchBillingUsage(token: string): Promise<BillingUsage>;
+export declare function formatQuota(usage: BillingUsage | undefined): string[];
+export {};

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/provider/register.d.ts

@@ -0,0 +1,5 @@
+/**
+ * GJC Grok Build provider — SuperGrok OAuth + cli-chat-proxy models.
+ */
+import type { ExtensionAPI } from '@gajae-code/coding-agent';
+export default function registerGrokCli(api: ExtensionAPI): void;

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/provider/stream.d.ts

@@ -0,0 +1,10 @@
+import type { Api, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from '@gajae-code/ai';
+/**
+ * Stream function that adds Grok CLI-specific headers to requests.
+ *
+ * GJC Grok Build extension sends cli-chat-proxy headers (see agent.models.grok-cli.yml):
+ *   - x-grok-conv-id: <session/conversation ID>
+ *   - x-grok-model-override: <model ID>
+ *   - x-xai-token-auth: xai-grok-cli
+ */
+export declare function streamGrokCli(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/provider/usage.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from '@gajae-code/coding-agent';
+export declare function registerUsageCommand(api: Pick<ExtensionAPI, 'registerCommand'>): void;

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/shared/base-url.d.ts

@@ -0,0 +1,2 @@
+export declare function getBaseUrl(): string;
+export declare function isGrokBuildBaseUrlOverrideIgnored(): boolean;

package/dist/types/defaults/gjc/extensions/grok-cli-vendor/src/shared/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Typed error for xAI OAuth failures.
+ *
+ * Codes allow the login flow and stream handlers to distinguish
+ * retryable failures (network) from fatal ones (revoked refresh token).
+ */
+export declare class XaiOAuthError extends Error {
+    readonly code: string;
+    readonly reloginRequired: boolean;
+    constructor(message: string, code: string, reloginRequired?: boolean);
+}
+/** Well-known error codes. */
+export declare const XaiErrorCode: {
+    /** OIDC discovery failed (network, invalid response). */
+    readonly DISCOVERY_FAILED: 'discovery_failed';
+    /** Discovery endpoint returned a non-xAI origin. */
+    readonly DISCOVERY_INVALID_ORIGIN: 'discovery_invalid_origin';
+    /** Authorization was denied or errored in the browser. */
+    readonly AUTHORIZATION_FAILED: 'authorization_failed';
+    /** CSRF state mismatch between request and callback. */
+    readonly STATE_MISMATCH: 'state_mismatch';
+    /** Callback did not include an authorization code. */
+    readonly CODE_MISSING: 'code_missing';
+    /** Token exchange failed (network, invalid response). */
+    readonly TOKEN_EXCHANGE_FAILED: 'token_exchange_failed';
+    /** Token exchange returned an invalid payload. */
+    readonly TOKEN_EXCHANGE_INVALID: 'token_exchange_invalid';
+    /** Refresh token is missing or empty. */
+    readonly REFRESH_MISSING: 'refresh_missing';
+    /** Token refresh failed (expired, revoked). */
+    readonly REFRESH_FAILED: 'refresh_failed';
+    /** No credentials stored. */
+    readonly AUTH_MISSING: 'auth_missing';
+    /** Loopback callback server could not bind. */
+    readonly CALLBACK_BIND_FAILED: 'callback_bind_failed';
+    /** Loopback callback timed out. */
+    readonly CALLBACK_TIMEOUT: 'callback_timeout';
+};

package/dist/types/defaults/gjc-grok-cli.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionFactory } from "../extensibility/extensions/types";
+export declare const BUNDLED_GROK_BUILD_EXTENSION_ID = "bundled:grok-build";
+export declare function getBundledGrokBuildExtensionFactory(): ExtensionFactory;
+export declare function getBundledGrokCliModelDefaults(): string;
+export declare function assertBundledGrokCliDefaults(): Promise<void>;

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

@@ -3,6 +3,7 @@
  */
 export type { SlashCommandInfo, SlashCommandLocation, SlashCommandSource } from "../slash-commands";
 export { discoverAndLoadExtensions, ExtensionRuntimeNotInitializedError, loadExtensionFromFactory, loadExtensions, } from "./loader";
+export * from "./prefix-command-bridge";
 export * from "./runner";
 export * from "./types";
 export * from "./wrapper";

package/dist/types/extensibility/extensions/prefix-command-bridge.d.ts

@@ -0,0 +1,35 @@
+import { type ExecResult } from "../../exec/exec";
+import type { ExtensionContext, InputEvent, InputEventResult } from "./types";
+export declare const OOO_BRIDGE_RECURSION_ENV = "_OUROBOROS_GJC_BRIDGE_DEPTH";
+export declare const OOO_BRIDGE_CONTINUE_EXIT_CODE = 78;
+export declare const OOO_BRIDGE_TIMEOUT_ENV = "OUROBOROS_GJC_BRIDGE_TIMEOUT_MS";
+export interface ExactPrefixCommandBridgeOptions {
+    /** Bare command prefix to intercept, without trailing whitespace. */
+    prefix: string;
+    /** Command executable to run when the prefix matches. */
+    command: string;
+    /** Arguments inserted before the intercepted input text. */
+    args?: string[];
+    /** Environment variable used as the recursion-depth guard. */
+    recursionEnv?: string;
+    /** Exit code that maps to extension pass-through instead of handled input. */
+    continueExitCode?: number;
+    /** Optional dispatch timeout in milliseconds. */
+    timeout?: number;
+    /** Dispatch implementation. Defaults to the shared command executor in the extension context cwd. */
+    dispatch?: (command: string, args: string[], ctx: ExtensionContext, options: {
+        timeout?: number;
+    }) => Promise<ExecResult>;
+}
+/**
+ * Build an extension `input` handler for an exact-prefix command bridge.
+ *
+ * Matching input is passed to `command` as `args + [event.text]`. A zero exit code
+ * handles the input, `continueExitCode` returns pass-through, and any other
+ * non-zero exit code surfaces an error and handles the input so the failed
+ * command is not forwarded to the model. The recursion
+ * guard prevents extension-originated or nested dispatch from re-entering the
+ * bridge while the child command runs.
+ */
+export declare function createExactPrefixCommandBridge(options: ExactPrefixCommandBridgeOptions): (event: InputEvent, ctx: ExtensionContext) => Promise<InputEventResult>;
+export declare function createOuroborosOooBridge(): (event: InputEvent, ctx: ExtensionContext) => Promise<InputEventResult>;