@gajae-code/coding-agent 0.15.4 → 0.15.6

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

@@ -109,6 +109,7 @@ import { type ConfiguredFallbackChain, type FallbackChainRuntimeState } from "./
 export { DefaultModelSelectionRecoveryError } from "./default-model-selection";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
+import { type FoldAdapter, FoldCoordinator } from "./fold-coordinator";
 import type { MemoryGuardRestoreResult } from "./memory-guard-checkpoint-participant";
 import { type CustomMessage } from "./messages";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, PreparedNewSession, RecoveryHydrationContext, RecoveryHydrationPromotionFence, SessionContext, SessionManagerCloseOutcome, SessionMemoryStats } from "./session-manager";
@@ -426,6 +427,8 @@ export interface PromptOptions {
     }) => void;
     /** Optional invocation-scoped cancellation fence used before an accepted skill starts execution. */
     preflightSignal?: AbortSignal;
+    /** Internal host capability; ordinary package callers cannot construct the branded value. */
+    sdkRunCapability?: unknown;
 }
 /** Result from a handoff operation. */
 export interface HandoffResult {
@@ -551,6 +554,14 @@ export type BeforeAgentStartContributor = (event: {
     images?: ImageContent[];
     sessionId: string | undefined;
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
+export type WorkerIntegrationOutcome = {
+    status: "completed";
+} | {
+    status: "failed";
+    error: string;
+} | {
+    status: "timed_out";
+};
 export declare class WorkerIntegrationRequestScheduler {
     #private;
     readonly request: (signal: AbortSignal) => Promise<void>;
@@ -558,6 +569,7 @@ export declare class WorkerIntegrationRequestScheduler {
     constructor(request: (signal: AbortSignal) => Promise<void>, timeoutMs?: number);
     enqueue(): void;
     flush(): Promise<void>;
+    flushWithOutcome(): Promise<WorkerIntegrationOutcome>;
 }
 export type StreamingEditParsedToolCall = {
     toolCall: ToolCall;
@@ -835,7 +847,9 @@ export declare class AgentSession {
      * handler, so Ctrl+B-style folding fails closed instead of aborting or
      * shell-suspending arbitrary work.
      */
-    registerForegroundBashBackgroundRequestHandler(handler: () => void): () => void;
+    registerForegroundFoldParticipant(adapter: FoldAdapter): () => void;
+    /** The session-owned fold coordinator, for delivery-side receipt lookup. */
+    get foldCoordinator(): FoldCoordinator;
     /**
      * Returns whether a managed foreground bash call is currently backgroundable.
      * UI key handlers use this to avoid consuming normal editor shortcuts when
@@ -852,7 +866,7 @@ export declare class AgentSession {
      * Ask the active managed foreground bash call to return as a background job.
      * Returns false when no supported foreground tool is currently backgroundable.
      */
-    requestForegroundBashBackground(): boolean;
+    requestForegroundBashBackground(): Promise<boolean>;
     /**
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */
@@ -945,7 +959,7 @@ export declare class AgentSession {
     /** Live SDK configuration values exposed through the session query surface. */
     getSdkConfigItems(): Record<string, string>;
     setPlanModeState(state: PlanModeState | undefined): void;
-    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted" | "onPreflightAcceptCommit" | "onSkillPrepared" | "preflightSignal">): Promise<{
+    invokeSkill(name: string, args?: string, options?: Pick<PromptOptions, "onPreflightAccepted" | "onPreflightAcceptCommit" | "onSkillPrepared" | "preflightSignal" | "sdkRunCapability">): Promise<{
         name: string;
         path: string;
         args?: string;
@@ -1000,7 +1014,7 @@ export declare class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     prompt(text: string, options?: PromptOptions): Promise<void>;
-    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit" | "preflightSignal">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit" | "preflightSignal" | "sdkRunCapability">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -1060,7 +1074,7 @@ export declare class AgentSession {
             startsOwnRun: boolean;
         }) => void;
         preflightSignal?: AbortSignal;
-        sdkRunToken?: string;
+        sdkRunCapability?: unknown;
     }): Promise<void>;
     /**
      * Clear queued messages and return them.

package/dist/types/session/fold-coordinator.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Session-owned fold/wake coordinator.
+ *
+ * Folding a running foreground wait is a lifecycle handoff across three
+ * independently scheduled domains — the tool observer, the job owner, and
+ * agent-turn admission — so it needs ONE linearization point. That is this
+ * coordinator: a synchronous prologue claims the fold and arms the steering
+ * fence with no `await` in between, and only then does an async tail capture and
+ * persist the receipt.
+ *
+ * Two invariants are load-bearing and easy to get wrong:
+ *
+ * 1. **Identity is the `AsyncJob` instance, acquired once.** Job ids and
+ *    generations are manager-local, so two managers can mint the same
+ *    `bg_1`/`job:1` pair. Slots are therefore keyed by the object itself,
+ *    obtained exactly once through the registration-bound
+ *    {@link FoldAdapter.getJob} and retained for the rest of the transaction.
+ *    Nothing in the fold path may consult an ambient, singleton, or
+ *    endpoint-resolved manager.
+ * 2. **A delivery callback can run more than once.** The async job manager
+ *    re-pushes the SAME delivery object on retry, so the receipt is attached to
+ *    a carrier keyed by that object BEFORE the slot is released. A retried
+ *    delivery therefore still carries its receipt and can never silently
+ *    degrade into an ordinary receipt-less completion.
+ */
+import type { AsyncJob } from "../async/job-manager";
+/**
+ * Idle-flush merge window.
+ *
+ * Completions that land within this window coalesce into ONE wake turn. The
+ * previous 1ms debounce meant staggered completions each bought their own full
+ * LLM turn. Deliberately a fixed internal constant, not a setting: the contract
+ * is one merge window, and a per-user knob would let wake behavior differ
+ * between sessions.
+ */
+export declare const FOLD_WAKE_MERGE_WINDOW_MS = 800;
+/** The wait kinds that can be folded. `task`/`subagent` awaits are a non-goal. */
+export type FoldWaitKind = "bash-managed" | "client-terminal" | "bash-pty";
+/** Outcome of settling the foreground caller. Exactly one party may settle it. */
+export type ForegroundSettleOutcome = "resolved" | "already-settled";
+/**
+ * How a folded job's output is retrieved later. Deliberately a structured
+ * handle over already-implemented paths rather than an invented URI scheme:
+ * there is no `job://` resolver, and inventing one would make the reference
+ * unresolvable in exactly the degraded case it exists for.
+ */
+export interface JobOutputRetrieval {
+    jobId: string;
+    generation: string;
+    /** Human/model-facing retrieval instruction naming a real mechanism. */
+    instruction: string;
+}
+/** Durable record captured at fold time and replayed into the wake turn. */
+export interface FoldReceipt {
+    jobId: string;
+    jobGeneration: string;
+    kind: FoldWaitKind;
+    label: string;
+    outputRef: JobOutputRetrieval;
+    /** What the interrupted turn still intended to do, so the wake can finish it. */
+    remainingIntent: string | undefined;
+    foldedAt: number;
+    /** Only command kinds can change directory; task-style waits never do. */
+    cwdSensitive: boolean;
+}
+/** A terminal completion observed for a folded job. */
+export interface ForegroundTerminalPayload {
+    jobId: string;
+    generation: string;
+    text: string;
+}
+/**
+ * Per-wait fold capability. `getJob` is bound at registration over the manager
+ * that registered THIS job, which is what makes cross-manager identity safe.
+ */
+export interface FoldAdapter {
+    readonly kind: FoldWaitKind;
+    readonly jobId: string;
+    readonly jobGeneration: string;
+    readonly label: string;
+    readonly cwdSensitive: boolean;
+    /** Signal for the foreground wait; aborting capture must roll back the fold. */
+    readonly signal?: AbortSignal;
+    /** True only when the adapter was created by a model-owned Agent turn. */
+    readonly originatingTurn?: boolean;
+    readonly outputRef: JobOutputRetrieval;
+    /** Registration-bound resolver: the job for this adapter, or undefined once evicted or reused. */
+    readonly getJob: () => AsyncJob | undefined;
+    /** Settle the foreground caller with the fold result. Idempotent. */
+    readonly detachObserver: (receipt: FoldReceipt) => ForegroundSettleOutcome;
+    /** Hand a parked completion back to a still-attached observer. Idempotent. */
+    readonly resolveForegroundObserver: (payload: ForegroundTerminalPayload) => ForegroundSettleOutcome;
+}
+export type FoldRequestResult = {
+    status: "folded";
+    receipt: FoldReceipt;
+} | {
+    status: "unavailable";
+    reason: string;
+} | {
+    status: "already-terminal";
+    reason: string;
+} | {
+    status: "capture-failed";
+    reason: string;
+};
+/** What a delivery should carry, decided by the durable slot state (T2). */
+export type FoldDeliveryDisposition = {
+    kind: "ordinary";
+} | {
+    kind: "parked";
+} | {
+    kind: "receipt";
+    receipt: FoldReceipt;
+    text: string;
+};
+export interface FoldCoordinatorDeps {
+    /**
+     * Fence old-turn steering admission and return the release handle. Armed
+     * synchronously inside the prologue because the agent loop polls steering
+     * upstream of its pause checkpoint; fencing there keeps queued steering
+     * intact instead of draining it.
+     */
+    armSteeringFence: () => () => void;
+    /** Whether this fold belongs to a currently running Agent turn. */
+    hasActiveTurn?: () => boolean;
+    /** Arm the cooperative stop so the turn ends after the fold result, never via abort. */
+    requestStop: () => void;
+    /** Capture what the interrupted turn still intended to accomplish. */
+    captureRemainingIntent: () => Promise<string | undefined> | string | undefined;
+    /**
+     * Push a parked completion into the wake path. The delivery seam parks a
+     * completion that arrives before the receipt exists; when the fold later
+     * replays it (A6), THIS is what makes the wake happen rather than relying on
+     * an unrelated idle rearm to rescue it.
+     */
+    deliverParked: (job: AsyncJob, disposition: {
+        kind: "receipt";
+        receipt: FoldReceipt;
+        text: string;
+    }) => void;
+}
+/** Why a slot is being retired, which decides whether retiring is safe. */
+export type FoldRetireReason = "cancel" | "evict";
+/**
+ * Render a fold receipt for the wake turn.
+ *
+ * Carries the job id, a real retrieval handle, and the captured remaining
+ * intent, so the wake turn can finish the ORIGINAL task instead of only
+ * reporting that a command ended. The cwd caveat is included only for wait
+ * kinds that can actually change directory.
+ */
+export declare function describeFoldReceipt(receipt: FoldReceipt): string;
+export declare class FoldCoordinator {
+    #private;
+    constructor(deps: FoldCoordinatorDeps);
+    /** Register a foldable wait. The most recently registered wait is the default target. */
+    registerParticipant(adapter: FoldAdapter): () => void;
+    /** Whether any wait is currently foldable, for the key-availability gate. */
+    hasFoldableParticipant(): boolean;
+    /** Deterministic target: newest registration wins, so the chord folds what the user is watching. */
+    resolveTarget(): FoldAdapter | undefined;
+    /**
+     * T1. Synchronous prologue then async durability tail.
+     *
+     * Nothing awaits before the slot is reserved and the fence is armed, so a
+     * completion or a steering submission that races the capture cannot slip
+     * past into the old turn.
+     */
+    requestFold(explicit?: FoldAdapter): Promise<FoldRequestResult>;
+    /**
+     * T2. Decide what a delivery carries, branching on the DURABLE slot state
+     * rather than on transient hand-off state.
+     *
+     * `present` attaches the receipt to the retry-stable carrier BEFORE clearing
+     * the slot, so a retried invocation still finds it.
+     */
+    onDelivery(job: AsyncJob, text: string): FoldDeliveryDisposition;
+    /**
+     * Retirement. T-R2: never drop a slot that holds an undelivered payload or
+     * that a still-possible delivery could consume.
+     *
+     * - `cancel` retires freely, because a cancelled job enqueues no delivery at
+     *   all, so no later consumer can arrive.
+     * - `evict` only retires when the job can no longer deliver. An evicted
+     *   record still delivers with its retained job object, so a completed or
+     *   failed job keeps its slot.
+     */
+    retire(job: AsyncJob, reason: FoldRetireReason): boolean;
+    /**
+     * Claim the single completion notice for a job.
+     *
+     * Returns true exactly once per job. A delivery can be retried with the same
+     * object, so an unguarded notice would repeat for one completion.
+     */
+    claimCompletionNotice(job: AsyncJob): boolean;
+    /** Claim the receipt-bearing queue entry once across manager delivery retries. */
+    claimCompletionDelivery(job: AsyncJob): boolean;
+    /** Test/diagnostic view of the durable slot state for a job. */
+    slotStateFor(job: AsyncJob): "none" | "reserved-empty" | "reserved-parked" | "present" | "carried";
+}

package/dist/types/session/internal/managed-session-storage.d.ts

@@ -65,9 +65,8 @@ export interface ManagedFileSnapshot {
     };
 }
 /**
- * Descriptor identity of one managed file object. Deliberately excludes the
- * content sha256: append receipts must bind the post-operation object without
- * re-reading the whole payload.
+ * Descriptor identity of one managed file object. Append receipts include a
+ * content digest when the append implementation has already computed it.
  */
 export interface ManagedFileIdentity {
     dev: bigint;
@@ -76,6 +75,7 @@ export interface ManagedFileIdentity {
     size: number;
     mtimeNs: bigint;
     ctimeNs: bigint;
+    sha256?: string;
 }
 /**
  * Post-operation evidence for one managed append. `descriptor` is the
@@ -91,6 +91,7 @@ export interface ManagedAppendReceipt {
 export interface ManagedBoundedAppendExpectation {
     readonly dev: string;
     readonly ino: string;
+    readonly nlink: string;
     readonly size: string;
     readonly mtimeNs: string;
     readonly ctimeNs: string;

package/dist/types/session/sdk-run-capability-internal.d.ts

@@ -0,0 +1,7 @@
+declare const sdkRunTokenBrand: unique symbol;
+export interface SdkRunCapability {
+    readonly [sdkRunTokenBrand]: string;
+}
+export declare function createSdkRunCapability(token: string): SdkRunCapability;
+export declare function readSdkRunCapability(value: unknown): string | undefined;
+export {};

package/dist/types/session/sdk-run-capability.d.ts

@@ -0,0 +1,2 @@
+export type { SdkRunCapability } from "./sdk-run-capability-internal";
+export { readSdkRunCapability } from "./sdk-run-capability-internal";

package/dist/types/telemetry/control.d.ts

@@ -0,0 +1,11 @@
+/** Process-wide emergency stop; it cannot be enabled by project dotenv files. */
+export declare const TELEMETRY_KILL_SWITCH_ENV: "GJC_DISABLE_TELEMETRY";
+export interface TelemetryStatus {
+    enabled: boolean;
+    disabledByKillSwitch: boolean;
+    reason: "enabled" | "setting_disabled" | "kill_switch";
+}
+export interface TelemetrySettingsReader {
+    get(path: "telemetry.enabled"): boolean;
+}
+export declare function getTelemetryStatus(settings: TelemetrySettingsReader): TelemetryStatus;

package/dist/types/telemetry/events.d.ts

@@ -0,0 +1,20 @@
+export declare const TELEMETRY_SCHEMA_VERSION: 1;
+export declare const TELEMETRY_INSTALL_ID_FILE: "telemetry-install-id";
+export declare const TELEMETRY_EVENT_NAMES: readonly ["update_check_started", "update_check_completed", "update_install_started", "update_install_completed", "update_install_failed"];
+export type TelemetryEventName = (typeof TELEMETRY_EVENT_NAMES)[number];
+export interface TelemetryEvent {
+    schemaVersion: typeof TELEMETRY_SCHEMA_VERSION;
+    event: TelemetryEventName;
+    installId: string;
+    occurredAt: string;
+    channel?: "stable" | "nightly";
+    result?: "available" | "up_to_date" | "installed" | "failed" | "skipped";
+    installMethod?: "bun" | "npm" | "binary" | "migrate";
+}
+/**
+ * Serialize only the versioned telemetry allowlist. Unknown fields are never
+ * emitted; forbidden fields anywhere in the input fail closed.
+ */
+export declare function serializeTelemetryEvent(input: unknown): string;
+/** Load or create a random UUIDv4 that is not derived from machine data. */
+export declare function getTelemetryInstallId(filePath?: string): Promise<string>;

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

@@ -0,0 +1,3 @@
+export * from "./control";
+export * from "./events";
+export * from "./transport";

package/dist/types/telemetry/transport.d.ts

@@ -0,0 +1,22 @@
+import { getTelemetryStatus } from "./control";
+import { type TelemetryEvent, type TelemetryEventName } from "./events";
+export declare const TELEMETRY_ENDPOINT: "https://telemetry.gajae.dev/v1/events";
+export declare const TELEMETRY_MAX_IN_FLIGHT: 2;
+export declare const TELEMETRY_TIMEOUT_MS: 1500;
+export declare const TELEMETRY_FLUSH_TIMEOUT_MS: 2000;
+interface TelemetryTransportDependencies {
+    fetchImpl?: (input: string | URL, init?: RequestInit) => Promise<Response>;
+    endpoint?: string;
+}
+export type TelemetryDetails = Pick<TelemetryEvent, "channel" | "result" | "installMethod">;
+/**
+ * Best-effort transport. The caller only schedules work; disabled telemetry,
+ * queue saturation, network errors, and non-2xx responses are all ignored.
+ */
+export declare function sendTelemetryEvent(settings: Parameters<typeof getTelemetryStatus>[0], event: TelemetryEvent, deps?: TelemetryTransportDependencies): Promise<void>;
+export declare function resetTelemetryTransportForTest(): Promise<void>;
+/** Schedule an event without making telemetry part of the caller's lifecycle. */
+export declare function recordTelemetryEvent(event: TelemetryEventName, details: TelemetryDetails): Promise<void>;
+/** Wait briefly for accepted events so explicit process exits do not drop them. */
+export declare function flushTelemetryEvents(timeoutMs?: 2000): Promise<void>;
+export {};

package/dist/types/tools/bash-interactive.d.ts

@@ -6,6 +6,24 @@ export interface BashInteractiveResult extends OutputSummary {
     cancelled: boolean;
     timedOut: boolean;
 }
+/** Live controls handed to the caller once the PTY run owns its session. */
+export interface InteractivePtyControls {
+    /**
+     * Detach the overlay and settle the foreground call with `foldResult`, leaving
+     * the process running and still writing into the sink. Idempotent.
+     */
+    detachObserver: (foldResult: BashInteractiveResult) => "resolved" | "already-settled";
+    /**
+     * Resolves with the run's real summary when the process actually ends,
+     * regardless of whether the foreground was folded. A folded run is delivered
+     * from this, so its result can never be silently dropped.
+     */
+    terminalCompletion: Promise<BashInteractiveResult>;
+    /** Kill the owned process during owner teardown; the observer never calls this. */
+    kill: () => void;
+    /** Stop forwarding the foreground abort signal after ownership transfers on fold. */
+    detachForegroundCancellation: () => void;
+}
 export declare function runInteractiveBashPty(ui: NonNullable<AgentToolContext["ui"]>, options: {
     command: string;
     cwd: string;
@@ -18,4 +36,9 @@ export declare function runInteractiveBashPty(ui: NonNullable<AgentToolContext["
     spillThreshold?: number;
     headBytes?: number;
     settings?: Settings;
+    /** Receives live controls once the session is running; used to register a fold. */
+    onControls?: (controls: InteractivePtyControls) => void;
+    onFoldKey?: () => boolean;
+    onDismiss?: () => void;
+    onOutput?: (chunk: string) => void;
 }): Promise<BashInteractiveResult>;

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

@@ -12,6 +12,7 @@ import type { AgentRegistry } from "../registry/agent-registry";
 import type { ForkContextSeed, ForkContextSeedOptions, PurgeQueuedCustomMessagesResult } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
+import type { FoldAdapter } from "../session/fold-coordinator";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import type { SkillActiveEntry } from "../skill-state/active-state";
@@ -184,12 +185,12 @@ export interface ToolSession {
     assertEvalExecutionAllowed?: () => void;
     /** Track tool-owned eval work so session disposal can await/abort it like direct session eval runs. */
     trackEvalExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
-    /** Register a safe request handler that asks a managed foreground bash call to fold into a background job. */
-    registerForegroundBashBackgroundRequestHandler?: (handler: () => void) => () => void;
-    /** Whether a managed foreground bash call is currently foldable into a background job. */
+    /** Register a foldable foreground wait so the fold chord can move it into a background job. */
+    registerForegroundFoldParticipant?: (adapter: FoldAdapter) => () => void;
+    /** Whether a foreground wait is currently foldable into a background job. */
     hasForegroundBashBackgroundRequestHandler?: () => boolean;
-    /** Request that the active managed foreground bash call fold into a background job, if supported. */
-    requestForegroundBashBackground?: () => boolean;
+    /** Request that the active foreground wait fold into a background job, if supported. */
+    requestForegroundBashBackground?: () => Promise<boolean>;
     /** Get the session-owned or inherited async job manager. */
     getAsyncJobManager?: () => AsyncJobManager | undefined;
     /** Resolves when the session queues user steering (or `signal` aborts) without consuming it; wait-style tools use this to end their observation early. */

package/dist/types/tools/path-utils.d.ts

@@ -8,12 +8,11 @@ export declare function splitPathAndSel(rawPath: string): {
 /**
  * Variant of {@link splitPathAndSel} for internal URLs (`scheme://...`).
  *
- * Artifact authorities are generated identifiers, so their complete tail is
- * unambiguously a selector and malformed selectors can be rejected before
- * resolving the artifact. Other resources may legitimately use colons in
- * their identities, so they only lose strict, recognized selector suffixes.
- * Skill authorities additionally use the active registry to distinguish a
- * skill name from its selector without making path-utils depend on skills.
+ * Selector-capable internal authorities use identifier-shaped resource names,
+ * so an authority-only `:<tail>` is an explicit read selector even when the
+ * selector is malformed. Skill authorities are the exception: namespaced
+ * skill names already contain a colon, so the active registry gets first
+ * refusal and the fallback recognizes a later colon as the selector boundary.
  */
 export declare function splitInternalUrlSel(rawPath: string, options?: {
     activeSkillNames?: readonly string[];

package/dist/types/tools/tmux-self-injection-guard.d.ts

@@ -0,0 +1,15 @@
+export interface TmuxSelfInjectionResult {
+    block: boolean;
+    reason?: string;
+}
+export type TmuxPaneResolver = (options: {
+    socketArgs: string[];
+    target: string;
+    env: Record<string, string>;
+}) => Promise<string | undefined>;
+export interface TmuxSelfInjectionOptions {
+    env?: Record<string, string | undefined>;
+    cwd?: string;
+    resolvePaneId?: TmuxPaneResolver;
+}
+export declare function checkTmuxSelfInjection(command: string, options?: TmuxSelfInjectionOptions, depth?: number): Promise<TmuxSelfInjectionResult>;

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

@@ -17,7 +17,10 @@ export declare const SEARXNG_BEARER_CREDENTIAL_PREFIX = "gjc-searxng-bearer:";
 /**
  * Shared web search parameters passed to providers.
  *
- * `authStorage` is the **only** credential source providers may consult.
+ * `authStorage` is the credential source for canonical providers. Native
+ * active-model search may instead use `activeModelContext.resolveCredentials`,
+ * which is supplied by ModelRegistry so rotating config credentials and
+ * generated headers are refreshed before the request.
  * Opening a sibling SQLite handle or calling provider-direct refresh helpers
  * (e.g. `refreshOpenAIOpenAI code backendToken`, `refreshGoogleCloudToken`) is prohibited:
  * it races the broker's per-credential refresh and POSTs the broker sentinel
@@ -72,8 +75,8 @@ export interface SearchParams {
     codeExecution?: Record<string, unknown>;
     urlContext?: Record<string, unknown>;
     /**
-     * The single source of truth for credentials. Providers MUST consult this
-     * handle exclusively (`getApiKey` for bearer-style auth, `getOAuthAccess`
+     * The canonical source of truth for credentials. Providers MUST consult this
+     * handle (`getApiKey` for bearer-style auth, `getOAuthAccess`
      * when identity metadata is required). Do not open `AgentStorage` or any
      * `AuthCredentialStore` directly — that bypasses the broker pipeline and
      * the per-credential single-flight refresh.
@@ -102,7 +105,9 @@ export declare abstract class SearchProvider {
      */
     abstract isAvailable(authStorage: AuthStorage, settings?: SearchProviderSettings): Promise<boolean> | boolean;
     /**
-     * Execute a search. Credentials MUST be resolved through `params.authStorage`.
+     * Execute a search. Canonical credentials MUST be resolved through
+     * `params.authStorage`; active-model credentials MUST use the injected
+     * resolver when one is present.
      */
     abstract search(params: SearchParams): Promise<SearchResponse>;
 }

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

@@ -5,7 +5,7 @@
  * Endpoint: POST https://api.x.ai/v1/responses
  */
 import type { AuthStorage } from "@gajae-code/ai/core";
-import type { SearchCitation, SearchResponse } from "../../../web/search/types";
+import type { ActiveSearchModelContext, SearchCitation, SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
 declare const XAI_SEARCH_MODES: readonly ["web", "x", "web_and_x"];
@@ -31,6 +31,7 @@ export interface XaiSearchParams {
     signal?: AbortSignal;
     authStorage: AuthStorage;
     sessionId?: string;
+    activeModelContext?: ActiveSearchModelContext;
 }
 /** Test seam: the xAI search base URL as resolved from trusted env. */
 export declare function resolveXaiSearchBaseUrlForTest(): string;

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

@@ -6,6 +6,16 @@
 /** Supported web search providers */
 export type SearchProviderId = "duckduckgo" | "insane" | "exa" | "brave" | "jina" | "kimi" | "zai" | "anthropic" | "perplexity" | "gemini" | "codex" | "xai" | "tavily" | "parallel" | "kagi" | "synthetic" | "searxng" | "openai-compatible";
 export type WebSearchMode = "on" | "off" | "auto";
+/** Credentials and request headers resolved for the active model. */
+export interface ActiveSearchModelCredentials {
+    apiKey?: string;
+    headers?: Record<string, string>;
+}
+/** Refresh-aware resolver supplied by the model registry for native search. */
+export type ActiveSearchModelCredentialResolver = (options: {
+    sessionId?: string;
+    signal?: AbortSignal;
+}) => Promise<ActiveSearchModelCredentials>;
 export interface ActiveSearchModelContext {
     provider: string;
     modelId: string;
@@ -13,6 +23,10 @@ export interface ActiveSearchModelContext {
     api: string;
     baseUrl?: string;
     headers?: Record<string, string>;
+    /** Resolve the active model key and current headers before each native search. */
+    resolveCredentials?: ActiveSearchModelCredentialResolver;
+    /** True when registry-owned auth or transport overrides this active model. */
+    ownerAuthOverride?: boolean;
     webSearch?: WebSearchMode;
 }
 export declare const CONFIGURABLE_SEARCH_PROVIDER_IDS: readonly ["duckduckgo", "insane", "exa", "brave", "jina", "kimi", "zai", "anthropic", "perplexity", "gemini", "codex", "xai", "tavily", "parallel", "kagi", "synthetic", "searxng"];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.15.4",
+	"version": "0.15.6",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -56,12 +56,12 @@
 		"@agentclientprotocol/sdk": "1.3.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.15.4",
-		"@gajae-code/agent-core": "0.15.4",
-		"@gajae-code/ai": "0.15.4",
-		"@gajae-code/natives": "0.15.4",
-		"@gajae-code/tui": "0.15.4",
-		"@gajae-code/utils": "0.15.4",
+		"@gajae-code/stats": "0.15.6",
+		"@gajae-code/agent-core": "0.15.6",
+		"@gajae-code/ai": "0.15.6",
+		"@gajae-code/natives": "0.15.6",
+		"@gajae-code/tui": "0.15.6",
+		"@gajae-code/utils": "0.15.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -128,6 +128,8 @@
 		"./slash-commands/helpers/mcp": null,
 		"./session/session-manager-internal": null,
 		"./session/session-manager-internal.js": null,
+		"./session/sdk-run-capability": null,
+		"./session/sdk-run-capability.js": null,
 		"./sdk": {
 			"types": "./dist/types/sdk/index.d.ts",
 			"import": "./src/sdk/index.ts"
@@ -275,6 +277,7 @@
 			"types": "./dist/types/commit/utils/*.d.ts",
 			"import": "./src/commit/utils/*.ts"
 		},
+		"./config/internal/*": null,
 		"./config/*": {
 			"types": "./dist/types/config/*.d.ts",
 			"import": "./src/config/*.ts"

package/scripts/generate-hotkeys-docs.ts

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import {
 	defaultClipboardPasteImageKeysForPlatform,
+	defaultForegroundFoldKeysForPlatform,
 	defaultMessageQueueKeysForPlatform,
 	KEYBINDINGS,
 } from "../src/config/keybindings";
@@ -27,6 +28,9 @@ function defaultKeys(
 			case "app.clipboard.pasteImage":
 				keys = defaultClipboardPasteImageKeysForPlatform(platform);
 				break;
+			case "app.tool.backgroundFold":
+				keys = defaultForegroundFoldKeysForPlatform(platform);
+				break;
 			default:
 				keys = value.defaultKeys;
 		}

package/scripts/generate-sdk-operation-inventory.ts

@@ -127,11 +127,11 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"internal ACP lifecycle quiescence plumbing, not a user-facing control seam",
 	"agent_session:getToolByName": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getToolForExecution": "internal accessor/plumbing, not a user-facing control seam",
-	"agent_session:registerForegroundBashBackgroundRequestHandler":
-		"internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:registerForegroundFoldParticipant": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:hasForegroundBashBackgroundRequestHandler":
 		"internal accessor/plumbing, not a user-facing control seam",
-	"agent_session:requestForegroundBashBackground": "internal accessor/plumbing, not a user-facing control seam",
+	"agent_session:requestForegroundBashBackground": "internal accessor/plumbing, not a user-facing SDK control seam",
+
 	"agent_session:getSelectedMCPToolNames": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:isToolDiscoveryEnabled": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:getDiscoverableToolSearchIndex": "internal accessor/plumbing, not a user-facing control seam",