@gajae-code/coding-agent 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [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

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

@@ -8,6 +8,28 @@ export declare function readFileLockInfoForGc(lockDir: string): Promise<{
     pid: number;
     timestamp: number;
 } | null>;
-/** @internal */
-export declare function removeFileLockDirForGc(lockDir: string): Promise<void>;
+/** 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/gjc-runtime/state-writer.d.ts

@@ -1,4 +1,5 @@
-import * as fs from "node:fs/promises";
+import type { Stats } from "node:fs";
+import { type FileLockOptions } from "../config/file-lock";
 import type { SkillActiveEntry } from "../skill-state/active-state";
 import { type AuditEntry, type CanonicalGjcWorkflowSkill, type WorkflowStateMutationOwner } from "../skill-state/workflow-state-contract";
 /**
@@ -55,6 +56,12 @@ export interface StateWriterOptions {
     cwd?: string;
     receipt?: StateWriterReceiptContext;
     audit?: StateWriterAuditContext;
+    /**
+     * Cross-process lock tuning for read-modify-write paths that route through
+     * `withWorkflowStateLock` / `updateJsonAtomic`. Omit for the hardened
+     * `withFileLock` defaults.
+     */
+    lock?: FileLockOptions;
 }
 export interface DeleteIfOwnedOptions extends StateWriterOptions {
     predicate?: (current: unknown) => boolean | Promise<boolean>;
@@ -81,7 +88,7 @@ export interface GenericHardPruneTarget {
 export interface GenericHardPruneSelectorContext {
     path: string;
     category: WriterCategory | string;
-    stat: Awaited<ReturnType<typeof fs.stat>>;
+    stat: Stats;
     readJson: () => Promise<unknown>;
 }
 export type GenericHardPruneSelector = (context: GenericHardPruneSelectorContext) => boolean | Promise<boolean>;
@@ -109,8 +116,63 @@ export declare function detectWorkflowEnvelopeIntegrityMismatch(filePath: string
 export declare function writeJsonAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeWorkflowEnvelopeAtomic(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function writeTextAtomic(targetPath: string, text: string, options?: StateWriterOptions): Promise<string>;
+/**
+ * Serialize a read-modify-write (or any multi-step mutation) against concurrent
+ * writers of the same `.gjc/**` target. Uses the cross-process directory lock
+ * from `withFileLock`, keyed on the resolved file path, so separate CLI/agent
+ * processes (e.g. team-mode workers) cannot interleave one writer's read with
+ * another writer's write and silently drop the first mutation (issue #646).
+ *
+ * The lock is advisory: it only protects callers that route through it, so every
+ * read-modify-write of a given file MUST acquire this lock for the same resolved
+ * path. `atomicWrite`'s temp-file + rename crash-atomicity is preserved; this
+ * layers concurrency-atomicity on top without weakening it.
+ */
+export declare function withWorkflowStateLock<T>(targetPath: string, fn: () => Promise<T>, options?: StateWriterOptions): Promise<T>;
 export declare function updateJsonAtomic<T = unknown>(targetPath: string, mutator: (current: T | undefined) => T | Promise<T>, options?: StateWriterOptions): Promise<string>;
 export declare function appendJsonl(targetPath: string, entry: unknown, options?: StateWriterOptions): Promise<string>;
+export interface AppendJsonlIdempotentOptions extends StateWriterOptions {
+    /**
+     * Identity key for an entry. Two entries that produce the same non-`undefined`
+     * key are duplicates, so only the first is appended. Return `undefined` to opt a
+     * candidate out of dedup (it is always appended). Use `key` for the common case
+     * where identity reduces to a single string.
+     */
+    key?: (entry: unknown) => string | undefined;
+    /**
+     * Equivalence predicate: return `true` when `existing` already represents
+     * `candidate`, suppressing the append. Use when identity cannot be reduced to a
+     * single string key. When both `key` and `equals` are supplied, `equals` wins.
+     */
+    equals?: (candidate: unknown, existing: unknown) => boolean;
+}
+export interface AppendJsonlIdempotentResult {
+    path: string;
+    /** `true` when the entry was written; `false` when an equivalent entry already existed. */
+    appended: boolean;
+    /** The pre-existing entry that suppressed the append, when `appended` is `false`. */
+    duplicate?: unknown;
+}
+/**
+ * Append `entry` to a JSONL file only when no equivalent entry already exists —
+ * the shared idempotent append primitive (issue #660).
+ *
+ * `appendJsonl` is a pure append with no dedup, so every recurring "duplicate
+ * ledger row" bug (#638, #643, #645) had to be patched with bespoke per-call-site
+ * guards. This primitive centralizes the read-check-append cycle: a caller
+ * declares identity once via `key` or `equals` instead of re-deriving the lookup
+ * at each site.
+ *
+ * The read-then-append is serialized through the same cross-process workflow lock
+ * as `updateJsonAtomic`, so two concurrent idempotent appends cannot both observe
+ * "no duplicate" and both write (the #646 TOCTOU that a plain `appendJsonl`
+ * preceded by a manual existence check is still exposed to).
+ *
+ * Scope note: this dedups the *append* only. Call sites whose idempotency must
+ * also skip a coupled mutation — e.g. the plan/state rewrite in #643/#645 — still
+ * need a whole-operation guard; this primitive is the ledger-level half of that.
+ */
+export declare function appendJsonlIdempotent(targetPath: string, entry: unknown, options: AppendJsonlIdempotentOptions): Promise<AppendJsonlIdempotentResult>;
 export declare function appendText(targetPath: string, text: string, options?: StateWriterOptions): Promise<string>;
 export declare function createJsonNoClobber(targetPath: string, value: unknown, options?: StateWriterOptions): Promise<string>;
 export declare function deleteIfOwned(targetPath: string, predicateOrOptions?: ((current: unknown) => boolean | Promise<boolean>) | DeleteIfOwnedOptions): Promise<DeleteResult>;

package/dist/types/gjc-runtime/ultragoal-guard.d.ts

@@ -5,6 +5,15 @@ export interface UltragoalGuardDiagnostic {
     message: string;
     goalId?: string;
 }
+export interface UltragoalAskBlockDiagnostic {
+    active: boolean;
+    reason: string;
+    source: "absent" | "durable_state" | "durable_state_unreadable" | "ledger" | "goals_json";
+    goalsPath?: string;
+    ledgerPath?: string;
+    goalIds?: string[];
+    message: string;
+}
 export interface CurrentGoalLike {
     objective: string;
     status?: string;
@@ -19,6 +28,7 @@ export declare function readUltragoalVerificationState(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;
 }): Promise<UltragoalGuardDiagnostic>;
+export declare function isUltragoalAskBlocked(cwd: string): Promise<UltragoalAskBlockDiagnostic>;
 export declare function assertCanCompleteCurrentGoal(input: {
     cwd: string;
     currentGoal?: CurrentGoalLike | null;

package/dist/types/gjc-runtime/ultragoal-runtime.d.ts

@@ -68,6 +68,8 @@ export interface UltragoalStatusSummary {
     goals: UltragoalGoal[];
 }
 export interface UltragoalCommandResult {
+    reviewBlockerGoalIds?: string[];
+    createdReviewPlan?: boolean;
     status: number;
     stdout?: string;
     stderr?: string;
@@ -118,6 +120,17 @@ export declare function startNextUltragoalGoal(input: {
     goal?: UltragoalGoal;
     allComplete: boolean;
 }>;
+type SurfaceFamily = "web" | "cli" | "native" | "api-package" | "algorithm-math" | "unknown";
+export declare function normalizeSurfaceToken(value: string): string;
+export declare function surfaceFamily(value: string): SurfaceFamily;
+export interface ReplayProcessHandle {
+    readonly exited: Promise<number>;
+    kill(signal?: number | NodeJS.Signals): void;
+}
+export declare function waitForReplayProcessWithTimeout(process: ReplayProcessHandle, timeoutMs: number, graceMs?: number): Promise<number>;
+export declare function validateExecutorQaRedTeamEvidenceForReview(cwd: string, executorQa: Record<string, unknown>, options?: {
+    mode?: "review";
+}): Promise<void>;
 export declare function checkpointUltragoalGoal(input: {
     cwd: string;
     goalId: string;
@@ -159,5 +172,21 @@ export declare function recordUltragoalReviewBlockers(input: {
     evidence: string;
     gjcGoalJson?: string;
 }): Promise<UltragoalPlan>;
+type UltragoalReviewContractStrength = "strong" | "thin-derived";
+interface UltragoalReviewFinding extends JsonObject {
+    severity: "blocker";
+    message: string;
+}
+interface UltragoalReviewResult extends JsonObject {
+    verdict: "pass" | "fail" | "inconclusive: weak-contract";
+    contractStrength: UltragoalReviewContractStrength;
+    cleanPassEligible: boolean;
+    source: JsonObject;
+    findings: UltragoalReviewFinding[];
+    artifactValidationSummary: JsonObject;
+    weakContractCapApplied: boolean;
+    blockerGoalIds?: string[];
+}
+export declare function runUltragoalReview(cwd: string, args: readonly string[]): Promise<UltragoalReviewResult>;
 export declare function runNativeUltragoalCommand(args: string[], cwd?: string): Promise<UltragoalCommandResult>;
 export {};

package/dist/types/modes/components/provider-onboarding-selector.d.ts

@@ -1,5 +1,5 @@
 import { Container } from "@gajae-code/tui";
-export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "api-guide";
+export type ProviderOnboardingAction = "custom-provider-wizard" | "oauth-login" | "import-credentials" | "api-guide";
 export declare class ProviderOnboardingSelectorComponent extends Container {
     #private;
     constructor(onSelect: (action: ProviderOnboardingAction) => void, onCancel: () => void);

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

@@ -86,7 +86,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     retryLoader: Loader | undefined;
     autoCompactionEscapeHandler?: () => void;
     retryEscapeHandler?: () => void;
-    retryCountdownTimer?: ReturnType<typeof setInterval>;
+    retryCountdownTimer?: NodeJS.Timeout;
     unsubscribe?: () => void;
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;

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

@@ -12,7 +12,7 @@
  */
 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";
+import type { RpcCommand, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcHostToolCallRequest, RpcHostToolCancelRequest, RpcHostUriCancelRequest, RpcHostUriRequest, RpcResponse } from "./rpc-types";
 export type * from "./rpc-types";
 export type PendingExtensionRequest = {
     resolve: (response: RpcExtensionUIResponse) => void;
@@ -20,6 +20,61 @@ export type PendingExtensionRequest = {
 };
 type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
 export declare function shouldEmitRpcTitlesForTest(): boolean;
+/**
+ * Cancellation commands bypass the ordered serial chain because they must
+ * interrupt in-flight work — they cannot wait behind the very command they are
+ * meant to abort.
+ */
+export declare const RPC_CANCELLATION_COMMANDS: ReadonlySet<RpcCommand["type"]>;
+/**
+ * Safe read-only commands that bypass the ordered serial chain so they never
+ * head-of-line-block behind a long-running ordered command like
+ * `bash`/`compact`/`handoff`/`login` (#606, issue 13 — the partial fix only
+ * fast-laned cancellation).
+ *
+ * Every command listed here has a dispatch handler that is **fully synchronous
+ * and side-effect-free**: on the single-threaded event loop it runs to
+ * completion between the await points of any in-flight ordered command, reading
+ * live state without mutating it. Because such a read performs no causal write,
+ * jumping ahead of an earlier *queued* ordered command is observably harmless —
+ * there is no state change to reorder. Read payloads are additionally
+ * snapshotted inside the handler (e.g. `get_messages` returns a shallow copy of
+ * `session.messages`) so a fast-lane read can never serialize a half-mutated
+ * array that an ordered turn/compaction is rewriting in place.
+ *
+ * Deliberately excluded (kept ordered): every async/long command and every
+ * mutating command. In particular the control-flag setters (`set_thinking_level`,
+ * `cycle_thinking_level`, `set_steering_mode`, `set_follow_up_mode`,
+ * `set_interrupt_mode`, `set_auto_compaction`, `set_auto_retry`) stay ordered.
+ * Their handlers are synchronous, so fast-laning one ahead of an already-queued
+ * `prompt`/`bash` would apply the new mode *before* that earlier command runs —
+ * the earlier command would then observe the later setter's value, a
+ * causal-order (arrival-order) regression. Mutations therefore stay on the
+ * chain, and new command types default to ordered (fail-safe).
+ */
+export declare const RPC_SAFE_READ_CONTROL_COMMANDS: ReadonlySet<RpcCommand["type"]>;
+/** True when a command may bypass the ordered serial chain and run immediately. */
+export declare function isFastLaneRpcCommand(type: RpcCommand["type"]): boolean;
+/**
+ * Schedules inbound RPC commands: fast-lane commands run immediately while
+ * everything else runs through a serial chain so causal order is preserved. The
+ * read loop never blocks, which is what lets a fast-lane command reach a
+ * long-running ordered command instead of being head-of-line-blocked behind it.
+ */
+export declare function createRpcCommandScheduler(run: (command: RpcCommand) => Promise<void>, track: (task: Promise<void>) => void): {
+    dispatch: (command: RpcCommand) => void;
+};
+export declare class RpcListenRefusedError extends Error {
+    constructor(socketPath: string);
+}
+/**
+ * Probe whether a unix-domain socket path has a live server accepting
+ * connections. Returns `true` when a connection succeeds (a previous owner is
+ * still alive), and returns `false` only for known missing/stale endpoints
+ * (ENOENT / ECONNREFUSED). Unexpected probe failures fail closed as "alive" so
+ * `--listen` startup refuses to unlink a path it could not safely classify.
+ */
+export declare function isUnixSocketAlive(socketPath: string): Promise<boolean>;
 export declare function requestRpcEditor(pendingRequests: Map<string, PendingExtensionRequest>, output: RpcOutput, title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
     promptStyle?: boolean;
 }): Promise<string | undefined>;

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

@@ -14,10 +14,20 @@
  * Also implements the dispatch-facing {@link RpcUnattendedControlPlane} so the
  * RPC server can route `negotiate_unattended` + `workflow_gate_response` here.
  */
+import type { Model } from "@gajae-code/ai";
 import type { RpcCommand, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution, RpcWorkflowGateResponse } from "../../rpc/rpc-types";
 import type { RpcUnattendedControlPlane } from "./command-dispatch";
 import { type UnattendedAbortHooks, type UnattendedAuditEvent, UnattendedRunController } from "./unattended-run-controller";
 import { type GateStore, type OpenGateInput } from "./workflow-gate-broker";
+/**
+ * Derive an explicit `providerSupportsTokenCostMetrics` capability from the
+ * active model so unattended negotiation fails closed when token/cost usage
+ * cannot be accounted for (#606). Callers that omit a model — or whose model is
+ * configured to suppress streaming usage (`compat.supportsUsageInStreaming:
+ * false`) — get `false`, which the controller refuses with
+ * `unsupported_budget_metric`.
+ */
+export declare function modelSupportsTokenCostMetrics(model: Model | undefined): boolean;
 /** Minimal surface a skill runtime / ask tool uses to emit a gate and await its answer. */
 export interface WorkflowGateEmitter {
     /** True only when unattended mode has been negotiated. */