@gajae-code/coding-agent 0.15.6 → 0.16.1

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

@@ -67,7 +67,7 @@ export interface ForkContextSeedOptions {
     signal?: AbortSignal;
 }
 import type { AuthCredentialSelector } from "@gajae-code/ai/core";
-import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async";
+import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager, type FoldReason, type JobFoldEvent } from "../async";
 import type { Rule } from "../capability/rule";
 import { type ModelRegistry } from "../config/model-registry";
 import { type ResolvedModelRoleValue, type ScopedModelSelection } from "../config/model-resolver";
@@ -109,7 +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 FoldAdapter, FoldCoordinator, type ForegroundFoldOutcome } 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";
@@ -399,6 +399,8 @@ export interface PromptOptions {
     streamingBehavior?: "steer" | "followUp";
     /** When set to "sequential", this follow-up is delivered one prompt at a time even if followUpMode is "all". */
     followUpQueuePolicy?: "respect-mode" | "sequential";
+    /** When set to "sequential", this steer is delivered on its own even if steeringMode is "all". */
+    steerQueuePolicy?: "respect-mode" | "sequential";
     /** Optional tool choice override for the next LLM call. */
     toolChoice?: ToolChoice;
     /** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
@@ -524,6 +526,10 @@ interface EphemeralTurnResult {
     replyText: string;
     assistantMessage: AssistantMessage;
 }
+export declare class SessionDisposalIncompleteError extends Error {
+    constructor(label?: string);
+}
+export declare function isSessionDisposalIncompleteError(error: unknown): error is SessionDisposalIncompleteError;
 export interface AgentBashArtifactStore {
     saveArtifact(content: string, toolType: string): Promise<string | undefined>;
     getArtifactPath(id: string): Promise<string | null>;
@@ -570,6 +576,7 @@ export declare class WorkerIntegrationRequestScheduler {
     enqueue(): void;
     flush(): Promise<void>;
     flushWithOutcome(): Promise<WorkerIntegrationOutcome>;
+    joinOwnedRequests(): Promise<void>;
 }
 export type StreamingEditParsedToolCall = {
     toolCall: ToolCall;
@@ -747,6 +754,11 @@ export declare class AgentSession {
      * Call this when completely done with the session.
      */
     dispose(): Promise<void>;
+    /** Join the retained teardown owner without allocating another public deadline. */
+    awaitDisposeCompletion(): Promise<void>;
+    setDisposeTimeoutForTests(timeoutMs: number): void;
+    trackPostPromptTaskForTests(task: Promise<void>): void;
+    requestWorkerIntegrationForTests(): void;
     /**
      * Strict writer close for ACP session delete. On the first attempt it flushes
      * pending writes, then returns the certainty-aware close outcome so the caller
@@ -805,6 +817,13 @@ export declare class AgentSession {
      * proceeds.
      */
     awaitSessionSettlement(): Promise<void>;
+    /** Test seam: hold prompt admission while bypassing a pending selection fence. */
+    runWithPromptAdmissionForTests(body: () => Promise<void>): Promise<void>;
+    queueCoordinatorRuntimeStatePersistForTests(event: AgentSessionEvent, gate: Promise<void>): Promise<void>;
+    parkAgentEndForCoordinatorPersistForTests(event: Extract<AgentSessionEvent, {
+        type: "agent_end";
+    }>): void;
+    flushParkedAgentEndForCoordinatorPersistForTests(): void;
     drainAsyncJobDeliveriesForAcp(options?: {
         timeoutMs?: number;
     }): Promise<boolean>;
@@ -862,11 +881,31 @@ export declare class AgentSession {
     get sdkPermissionMode(): "prompt" | "allow" | "deny";
     /** Register or clear the SDK reverse permission provider for this session. */
     setSdkPermissionProvider(provider: ((toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal) => Promise<ClientBridgePermissionOutcome>) | undefined): void;
+    /**
+     * Subscribe to folds of this session's foreground waits. Backed by the
+     * session-owned manager (or the process-global instance for legacy setups)
+     * so the SDK host can publish one `bash_folded` frame per fold.
+     */
+    onJobFold(listener: (event: JobFoldEvent) => void): () => void;
     /**
      * Ask the active managed foreground bash call to return as a background job.
      * Returns false when no supported foreground tool is currently backgroundable.
+     * `reason` names the trigger (`chord` for the keybinding, `sdk_control` for
+     * the `bash.background` control) and is recorded on the folded job.
+     */
+    requestForegroundBashBackground(reason?: FoldReason, adapter?: FoldAdapter): Promise<boolean>;
+    /**
+     * Typed variant of {@link requestForegroundBashBackground} for the SDK
+     * `bash.background` control (C52), which must distinguish "this fold moved
+     * the wait" from "an earlier fold already moved it" from "nothing to fold".
+     *
+     * `already_backgrounded` is reported when no wait is foldable but this
+     * session still has a running job that a fold (steer, chord, timer, or a
+     * prior control call) moved out of the foreground: `metadata.foldReason` is
+     * set only by folds, never by `async: true` starts, so it is the exact
+     * evidence that the wait the client is asking about has already left.
      */
-    requestForegroundBashBackground(): Promise<boolean>;
+    requestForegroundBashBackgroundOutcome(reason?: FoldReason, adapter?: FoldAdapter): Promise<ForegroundFoldOutcome>;
     /**
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */
@@ -939,7 +978,7 @@ export declare class AgentSession {
     /** Current follow-up mode */
     get followUpMode(): "all" | "one-at-a-time";
     /** Current interrupt mode */
-    get interruptMode(): "immediate" | "wait";
+    get toolInterruptPolicy(): "abort_tools" | "finish_tools";
     /** Current session file path, or undefined if sessions are disabled */
     get sessionFile(): string | undefined;
     /** Current session ID */
@@ -1014,7 +1053,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" | "sdkRunCapability">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy" | "steerQueuePolicy" | "onPreflightAccepted" | "onPreflightAcceptCommit" | "preflightSignal" | "sdkRunCapability">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -1041,6 +1080,7 @@ export declare class AgentSession {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
         followUpQueuePolicy?: "respect-mode" | "sequential";
+        steerQueuePolicy?: "respect-mode" | "sequential";
         /** INTERNAL trusted option: origin of a hidden next-turn message —
          *  "turn" (produced by the current turn's continuation machinery,
          *  purged by a terminal abort) or "external" (background producers,
@@ -1160,6 +1200,7 @@ export declare class AgentSession {
         timeoutMs?: number;
         cause?: "user_interrupt" | "new_session" | "session_switch" | "compaction" | "handoff" | "tool_abort" | "internal";
         silent?: boolean;
+        preserveCompaction?: boolean;
     }): Promise<void>;
     /**
      * Private terminal-abort seam: read the CURRENT turn's attempt epoch WITHOUT
@@ -1394,6 +1435,10 @@ export declare class AgentSession {
         onBeforeMutation?: () => void;
         /** Run inside the selection admission after the durable mutation. */
         onAfterMutation?: () => void;
+        /** Test seam: pause after idle drain but before mutation admission. */
+        onBeforeMutationAdmissionForTests?: () => Promise<void>;
+        /** Test seam: pause after mutation admission activates, before its closed-fence recheck. */
+        onAfterMutationAdmissionReadyForTests?: () => Promise<void>;
     }): Promise<DefaultModelSelectionResult>;
     /**
      * Cycle to next/previous model.
@@ -1490,10 +1535,10 @@ export declare class AgentSession {
      */
     setFollowUpMode(mode: "all" | "one-at-a-time"): void;
     /**
-     * Set interrupt mode.
+     * Set the tool interrupt policy (whether a steer aborts in-flight tools).
      * Saves to settings.
      */
-    setInterruptMode(mode: "immediate" | "wait"): void;
+    setToolInterruptPolicy(policy: "abort_tools" | "finish_tools"): void;
     /**
      * Manually compact the session context.
      * Aborts current agent operation first.

package/dist/types/session/credential-store-errors.d.ts

@@ -0,0 +1 @@
+export declare const CREDENTIAL_STORE_UNREADABLE_MESSAGE = "Credential store is unreadable. Back up the database, then have an operator run PRAGMA integrity_check or REINDEX; no automatic repair was attempted.";

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

@@ -23,7 +23,7 @@
  *    delivery therefore still carries its receipt and can never silently
  *    degrade into an ordinary receipt-less completion.
  */
-import type { AsyncJob } from "../async/job-manager";
+import type { AsyncJob, FoldReason } from "../async/job-manager";
 /**
  * Idle-flush merge window.
  *
@@ -62,6 +62,8 @@ export interface FoldReceipt {
     foldedAt: number;
     /** Only command kinds can change directory; task-style waits never do. */
     cwdSensitive: boolean;
+    /** What triggered the fold; recorded on the job as `metadata.foldReason`. */
+    reason: FoldReason;
 }
 /** A terminal completion observed for a folded job. */
 export interface ForegroundTerminalPayload {
@@ -104,6 +106,26 @@ export type FoldRequestResult = {
     status: "capture-failed";
     reason: string;
 };
+/**
+ * Session-level answer to "fold the foreground bash now". Consumed by the SDK
+ * `bash.background` control, whose declared error codes are exactly these
+ * non-folded statuses.
+ */
+export type ForegroundFoldOutcome = {
+    status: "folded";
+    jobId: string;
+} | {
+    status: "already_backgrounded";
+} | {
+    status: "no_active_bash";
+} | {
+    status: "not_foldable";
+    reason: string;
+};
+/** Map a non-folded outcome onto the C52 `bash.background` error contract (`not_foldable` | `already_backgrounded` | `no_active_bash`). */
+export declare function bashBackgroundControlError(outcome: Exclude<ForegroundFoldOutcome, {
+    status: "folded";
+}>): Error;
 /** What a delivery should carry, decided by the durable slot state (T2). */
 export type FoldDeliveryDisposition = {
     kind: "ordinary";
@@ -166,8 +188,13 @@ export declare class FoldCoordinator {
      * 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.
+     *
+     * A `steer` fold is the one trigger that does NOT end the turn: the steer
+     * that caused it must be consumed by the same run at the tool boundary
+     * right after the fold result (subagent-await parity), so no fence is
+     * armed, no stop is requested, and no remaining intent is captured.
      */
-    requestFold(explicit?: FoldAdapter): Promise<FoldRequestResult>;
+    requestFold(explicit?: FoldAdapter, reason?: FoldReason): Promise<FoldRequestResult>;
     /**
      * T2. Decide what a delivery carries, branching on the DURABLE slot state
      * rather than on transient hand-off state.

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

@@ -22,6 +22,8 @@ export interface SessionHeader {
     id: string;
     title?: string;
     titleSource?: "auto" | "user";
+    starredPatchVersion?: 1;
+    starred?: boolean;
     timestamp: string;
     cwd: string;
     parentSession?: string;
@@ -362,7 +364,7 @@ export type SessionEntry = SessionMessageEntry | ThinkingLevelChangeEntry | Mode
 /** Append-only replacement for mutable fields on the session header. */
 export interface HeaderPatchRecord {
     type: "header_patch";
-    patch: Partial<Pick<SessionHeader, "title" | "titleSource" | "cwd">>;
+    patch: Partial<Pick<SessionHeader, "title" | "titleSource" | "cwd" | "starred">>;
 }
 /** Append-only replacement for replay metadata on one existing session entry. */
 export interface EntryPatchRecord {
@@ -812,6 +814,7 @@ export interface SessionInfo {
     /** Working directory where the session was started. Empty string for old sessions. */
     cwd: string;
     title?: string;
+    starred: boolean;
     /** Path to the parent session (if this session was forked). */
     parentSessionPath?: string;
     created: Date;
@@ -979,6 +982,7 @@ export declare function materializeResidentEntriesForPersistenceForTests<T>(entr
  * container (`agent-session` or `sessions`).
  */
 export declare function listProjectSessionTranscriptFiles(cwd: string): string[];
+export declare function prioritizeStarredSessions(sessions: readonly SessionInfo[]): SessionInfo[];
 /** Get recent sessions for display in welcome screen */
 export declare function getRecentSessions(sessionDir: string, limit?: number, storage?: SessionStorage): Promise<RecentSessionInfo[]>;
 export declare function getRecentSessionDisplay(sessions: readonly SessionInfo[], limit?: number): Array<{
@@ -1161,7 +1165,10 @@ export declare class SessionManager {
      * only for the async context that already owns the lock — unrelated callers
      * queue on the tail instead of skipping it.
      */
-    runExclusiveCwdTransition<T>(fn: () => Promise<T>): Promise<T>;
+    runExclusiveCwdTransition<T>(fn: () => Promise<T>, options?: {
+        signal?: AbortSignal;
+    }): Promise<T>;
+    runExclusiveCwdMoveTransition<T>(fn: () => Promise<T>): Promise<T>;
     /**
      * Run `fn` under a shared read lease on `cwd`.
      *
@@ -1175,7 +1182,66 @@ export declare class SessionManager {
     runWithCwdReadLease<T>(fn: () => Promise<T>): Promise<T>;
     /** Wait for any in-flight exclusive cwd transition to settle. */
     joinCwdTransition(): Promise<void>;
+    joinCwdReaders(): Promise<void>;
+    closeCwdMoveAdmission(): Promise<void>;
     getCwdGeneration(): number;
+    /** Consume a move committed by a nested move_session call in this read lease. */
+    consumeNestedCwdMove(admittedGeneration: number): boolean;
+    /**
+     * Register a listener invoked after every committed `moveTo`. Returns an idempotent
+     * unregister handle. Every move surface funnels through `moveTo`, so a single
+     * registration covers `move_session`, `/move`, and SDK/ACP `session.cwd.move`.
+     */
+    registerAfterMoveListener(listener: (move: {
+        previousCwd: string;
+        newCwd: string;
+        previousSessionFile: string | undefined;
+    }) => void | Promise<void>): () => void;
+    registerBeforeMoveListener(listener: (move: {
+        previousCwd: string;
+        newCwd: string;
+        previousSessionFile: string | undefined;
+        newSessionFile: string | undefined;
+        previousCwdIdentity: {
+            dev: bigint;
+            ino: bigint;
+        };
+        newCwdIdentity: {
+            dev: bigint;
+            ino: bigint;
+        };
+        preserveRecoveryJournal?: boolean;
+    }) => void | Promise<void>): () => void;
+    registerMovePublicationListener(listener: (move: {
+        previousCwd: string;
+        newCwd: string;
+        previousSessionFile: string | undefined;
+        newSessionFile: string | undefined;
+        previousCwdIdentity: {
+            dev: bigint;
+            ino: bigint;
+        };
+        newCwdIdentity: {
+            dev: bigint;
+            ino: bigint;
+        };
+        preserveRecoveryJournal?: boolean;
+    }) => void | Promise<void>): () => void;
+    registerMoveAbortListener(listener: (move: {
+        previousCwd: string;
+        newCwd: string;
+        previousSessionFile: string | undefined;
+        newSessionFile: string | undefined;
+        previousCwdIdentity: {
+            dev: bigint;
+            ino: bigint;
+        };
+        newCwdIdentity: {
+            dev: bigint;
+            ino: bigint;
+        };
+        preserveRecoveryJournal?: boolean;
+    }) => void | Promise<void>): () => void;
     static openNoFollowDirectory(dir: string): Promise<fs.promises.FileHandle>;
     /**
      * Claim process-cwd authority for `manager` when it is unowned or the prior
@@ -1215,6 +1281,15 @@ export declare class SessionManager {
                 bigint: true;
             }) => Promise<fs.BigIntStats>;
         };
+        expectedSourceIdentity?: {
+            dev: bigint;
+            ino: bigint;
+        };
+        sourceHandle?: {
+            stat: (opts: {
+                bigint: true;
+            }) => Promise<fs.BigIntStats>;
+        };
     }): Promise<void>;
     isPersisted(): boolean;
     stageDefaultModelSelection(model: string, thinkingLevel: string | undefined, options?: {
@@ -1342,6 +1417,8 @@ export declare class SessionManager {
     /** The source that set the session name: "user" (manual /rename or RPC) or "auto" (generated title). */
     get titleSource(): "auto" | "user" | undefined;
     getSessionName(): string | undefined;
+    isSessionStarred(): boolean;
+    setSessionStarred(starred: boolean): Promise<boolean>;
     setSessionName(name: string, source?: "auto" | "user"): Promise<boolean>;
     _persist(entry: SessionEntry): void;
     /** Append a configured fallback chain as child of current leaf, then advance leaf. Returns entry id. */

package/dist/types/session/yield-queue.d.ts

@@ -15,8 +15,9 @@ export interface YieldDispatcher<P> {
 export interface YieldQueueOptions {
     isStreaming: () => boolean;
     injectStreaming(msg: AgentMessage): void;
-    injectIdle(messages: AgentMessage[]): Promise<void>;
-    scheduleIdleFlush(run: () => Promise<void>): void;
+    injectIdle(messages: AgentMessage[], signal?: AbortSignal): Promise<void>;
+    scheduleIdleFlush(run: (signal?: AbortSignal) => Promise<void>, onSkip: () => void): void;
+    getIdleFlushSignal?(): AbortSignal | undefined;
 }
 type YieldFlushMode = "streaming" | "idle";
 export declare class YieldQueue {
@@ -25,8 +26,8 @@ export declare class YieldQueue {
     register<P>(kind: string, dispatcher: YieldDispatcher<P>): () => void;
     enqueue<P>(kind: string, entry: P): void;
     has(kind?: string): boolean;
-    flush(mode: YieldFlushMode): Promise<void>;
-    clear(): void;
+    flush(mode: YieldFlushMode, signal?: AbortSignal): Promise<void>;
+    clear(onDrop?: (kind: string, entries: readonly unknown[]) => void): void;
     /** Drop only the queued entries of a single kind, leaving other kinds intact. */
     clearKind(kind: string): void;
     /**

package/dist/types/setup/frictionless-onboarding.d.ts

@@ -68,6 +68,7 @@ export declare function hasCorroboratedRecentEvidence(evidence: readonly Onboard
 export declare function shouldOfferOnboarding(state: FrictionlessOnboardingState): boolean;
 export interface AutomaticOnboardingInput {
     normalInteractive: boolean;
+    automation?: boolean;
     initialMessage?: string;
     initialMessages: readonly string[];
     initialImages?: readonly unknown[];

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

@@ -46,6 +46,7 @@ export declare const OTHER_OPTION = "Other (type your own)";
 export declare const ASK_CLARIFICATION_OPTION = "Ask about these choices";
 export declare const RECOMMENDED_SUFFIX = " (Recommended)";
 export declare const MAX_EMPTY_CUSTOM_ATTEMPTS = 3;
+export declare function validRecommendedIndex(recommended: number | undefined, optionCount: number): number | undefined;
 /** The only remote navigation control; labels are presentation, never protocol. */
 export declare function askRemoteControls(input: {
     multi: boolean;

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

@@ -1,12 +1,23 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import type { Component } from "@gajae-code/tui";
 import * as z from "zod/v4";
+import { type FoldReason } from "../async";
 import { type BashArtifactSaveResult } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
+import { type SdkSpawnArgs } from "../sdk/cli/master-cli";
 import type { ToolSession } from ".";
 import { type OutputMeta } from "./output-meta";
 export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
+/**
+ * A user steer folds a running foreground bash call only after it has been
+ * running at least this long. Shorter commands finish normally and the steer is
+ * consumed at the ordinary tool boundary, so a quick `git status` never turns
+ * into a background job plus a wake-up turn.
+ */
+export declare const STEER_FOLD_GRACE_MS = 2000;
+/** Model-facing line appended to a steer-folded background-start result. */
+export declare function steerFoldReasonLine(jobId: string): string;
 export type BashOriginalArtifactSaveResult = BashArtifactSaveResult;
 export declare function saveBashOriginalArtifactForTests(session: ToolSession, originalText: string, onResult?: (result: BashOriginalArtifactSaveResult) => void): Promise<string | undefined>;
 declare const bashSchemaBase: z.ZodObject<{
@@ -38,6 +49,8 @@ export interface BashToolDetails {
     timeoutSeconds?: number;
     requestedTimeoutSeconds?: number;
     terminalId?: string;
+    /** Why the foreground wait was folded, when this result is a background-start after a fold. */
+    foldReason?: FoldReason;
     async?: {
         state: "running" | "completed" | "failed";
         jobId: string;
@@ -48,6 +61,9 @@ export interface BashToolDetails {
 export declare function summarizeBashToolActivity(kind: "args" | "result", value: unknown): string | undefined;
 export interface BashToolOptions {
 }
+export declare function isStrictDirectSdkSpawnCommand(command: string): boolean;
+export declare function parseDirectSdkSpawnArgs(command: string): SdkSpawnArgs;
+export declare function masterCommandEnvOverrides(env: Record<string, string> | undefined, directMasterSpawn: boolean): Record<string, string>;
 export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
     #private;
     private readonly session;

package/dist/types/tools/browser/launch.d.ts

@@ -23,6 +23,16 @@ export declare function resolveBrowserEnvOverridesForTest(): {
     programFilesX86: string | undefined;
     localAppData: string | undefined;
 };
+export declare function resolveSystemChromiumForTest(): string | undefined;
+export declare function resetSystemChromiumForTest(): void;
+export declare function headlessExecutableForProfileReuse(): string | undefined;
+/**
+ * On macOS the Cookies DB is encrypted with a Keychain key whose service name is
+ * brand-specific ("Chrome Safe Storage" vs "Chromium Safe Storage"). A Chrome profile
+ * copied into a bundled Chromium therefore decrypts to garbage with no warning.
+ * Return true only when the headless executable can actually decrypt the discovered profile.
+ */
+export declare function canDecryptProfileCookies(executablePath: string | undefined, discoveredUserDataDir: string | undefined, platform?: NodeJS.Platform): boolean;
 /** True for a Microsoft Edge executable path (excluded from Chrome profile mode). */
 export declare function isEdgeExecutable(candidate: string): boolean;
 /** True only for executable names owned by Google Chrome or Chromium. */

package/dist/types/tools/browser/registry.d.ts

@@ -65,6 +65,14 @@ export interface AcquireBrowserOptions {
     geo?: BrowserGeo;
 }
 export declare function browserKeyForTest(kind: BrowserKind, opts: Pick<AcquireBrowserOptions, "geo" | "profileReuse">): string;
+/**
+ * Create and register a warm-up dir as registry-owned for `handle`.
+ *
+ * Exists so tests can exercise disposal without spawning Chrome. The caller cannot
+ * supply the deletion target: this module creates the directory itself before recording
+ * ownership, preserving the same invariant as the production launch path.
+ */
+export declare function createOwnedWarmupDirForTest(handle: BrowserHandle): string;
 export declare function acquireBrowser(kind: BrowserKind, opts: AcquireBrowserOptions): Promise<BrowserHandle>;
 export declare function buildChromeProfileLaunchArgs(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];
 export declare function buildChromeProfileLaunchArgsForTest(kind: SpawnedChromeProfileKind, appArgs: readonly string[] | undefined, port: number): string[];

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

@@ -322,6 +322,14 @@ export interface PrDiffFile {
     changeType: "modified" | "added" | "deleted" | "renamed" | "binary";
     /** Pre-image path for renames/deletes; same as `path` otherwise. */
     oldPath?: string;
+    /**
+     * Set when `path` kept its C-style escaped source form because the quoted
+     * token held invalid UTF-8 or a malformed escape; distinguishes it from a
+     * valid path whose decoded text looks identical.
+     */
+    pathEscaped?: boolean;
+    /** Same as {@link PrDiffFile.pathEscaped}, for `oldPath`. */
+    oldPathEscaped?: boolean;
     /** Byte offset of the section's `diff --git` line in the unified diff. */
     startOffset: number;
     /** Byte offset of the next section (or end-of-text). */

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

@@ -1,6 +1,6 @@
 import type { AgentTelemetryConfig, AgentTool } from "@gajae-code/agent-core";
 import type { Model, ServiceTier, ToolChoice } from "@gajae-code/ai/core";
-import type { AsyncJobManager } from "../async";
+import type { AsyncJobManager, FoldReason } from "../async";
 import type { PromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import type { Skill } from "../extensibility/skills";
@@ -189,11 +189,13 @@ export interface ToolSession {
     registerForegroundFoldParticipant?: (adapter: FoldAdapter) => () => void;
     /** Whether a foreground wait is currently foldable into a background job. */
     hasForegroundBashBackgroundRequestHandler?: () => boolean;
-    /** Request that the active foreground wait fold into a background job, if supported. */
-    requestForegroundBashBackground?: () => Promise<boolean>;
+    /** Request that a foreground wait fold into a background job, if supported. `reason` names the trigger; `adapter` targets a specific wait instead of the newest registration. */
+    requestForegroundBashBackground?: (reason?: FoldReason, adapter?: FoldAdapter) => Promise<boolean>;
+    /** Current tool interrupt policy; `finish_tools` lets the running tool finish, so a steer must not fold it. */
+    getToolInterruptPolicy?: () => "abort_tools" | "finish_tools";
     /** 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. */
+    /** Resolves on a steer admitted after the wait starts, or when `signal` aborts, without consuming the steer. */
     waitForUserSteering?: (signal: AbortSignal) => Promise<void>;
     /** Get session ID */
     getSessionId?: () => string | null;
@@ -219,6 +221,10 @@ export interface ToolSession {
     bashAllowedPrefixes?: string[];
     /** Restriction policy for sessions that deliberately expose a narrow bash surface. */
     bashRestrictionProfile?: BashRestrictionProfile;
+    /** Process-local master capability injected into direct Bash children only. */
+    getMasterBashCapability?: () => string | undefined;
+    /** Stable master lineage identity used across session switches and branches. */
+    getMasterOwnerSessionId?: () => string | undefined;
     /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
     discoverableToolAllowedNames?: readonly string[];
     /** Throw instead of warn when toolNames contains an unknown name. */
@@ -328,12 +334,6 @@ export interface ToolSession {
     buildToolChoice?(toolName: string): ToolChoice | undefined;
     /** Build a named tool-choice decision, preserving whether exact named forcing survived capability degradation. */
     buildToolChoiceResult?(toolName: string): import("../utils/tool-choice").NamedToolChoiceResult;
-    /** Steer a hidden custom message into the conversation (e.g. a preview reminder). */
-    steer?(message: {
-        customType: string;
-        content: string;
-        details?: unknown;
-    }): void;
     /** Peek the currently in-flight tool-choice queue directive's invocation handler. Used by the `resolve` tool to dispatch to the pending action. */
     peekQueueInvoker?(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     /** Peek the long-lived "standing" resolve handler registered by a mode (e.g. plan mode).

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

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import type { Component } from "@gajae-code/tui";
 import * as z from "zod/v4";
-import { type AsyncJob } from "../async";
+import { type AsyncJob, type FoldReason } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from "./index";
@@ -18,6 +18,8 @@ interface JobSnapshot {
     status: "running" | "completed" | "failed" | "cancelled";
     label: string;
     durationMs: number;
+    /** Present when the job was folded out of a foreground wait. */
+    foldReason?: FoldReason;
     resultText?: string;
     errorText?: string;
 }

package/dist/types/utils/external-editor.d.ts

@@ -10,6 +10,13 @@ export interface OpenInEditorOptions {
 }
 /** Remove one platform-standard trailing line terminator from editor content. */
 export declare function trimEditorTrailingNewline(text: string): string;
+/**
+ * Native Windows editor executables must bypass cmd.exe. The shell wrapper
+ * reclaims the shared console input buffer while it waits for the editor,
+ * reopening the cooked-mode window that loses the first keystroke. Batch
+ * files still require a shell on Windows; ordinary executables do not.
+ */
+export declare function shouldUseExternalEditorShell(editor: string, platform?: NodeJS.Platform): boolean;
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.

package/examples/extensions/README.md

@@ -68,7 +68,7 @@ This external path is separate from GJC's native `/skill:deep-interview`: the na
 
 | Extension   | Description                                                          |
 | ----------- | -------------------------------------------------------------------- |
-| `pirate.ts` | Demonstrates `systemPromptAppend` to dynamically modify system prompt |
+| `pirate.ts` | Demonstrates appending a prompt block with `systemPrompt` |
 
 ### External Dependencies
 

package/examples/extensions/pirate.ts

@@ -1,7 +1,7 @@
 /**
  * Pirate Extension
  *
- * Demonstrates using systemPromptAppend in before_agent_start to dynamically
+ * Demonstrates using systemPrompt in before_agent_start to dynamically
  * modify the system prompt based on extension state.
  *
  * Usage:
@@ -24,10 +24,12 @@ export default function pirateExtension(pi: ExtensionAPI) {
 	});
 
 	// Append to system prompt when pirate mode is enabled
-	pi.on("before_agent_start", async () => {
+	pi.on("before_agent_start", async event => {
 		if (pirateMode) {
 			return {
-				systemPromptAppend: `
+				systemPrompt: [
+					...event.systemPrompt,
+					`
 IMPORTANT: You are now in PIRATE MODE. You must:
 - Speak like a stereotypical pirate in all responses
 - Use phrases like "Arrr!", "Ahoy!", "Shiver me timbers!", "Avast!", "Ye scurvy dog!"
@@ -35,7 +37,8 @@ IMPORTANT: You are now in PIRATE MODE. You must:
 - Refer to the user as "matey" or "landlubber"
 - End sentences with nautical expressions
 - Still complete the actual task correctly, just in pirate speak
-`,
+					`,
+				],
 			};
 		}
 		return undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.15.6",
+	"version": "0.16.1",
 	"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.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",
+		"@gajae-code/stats": "0.16.1",
+		"@gajae-code/agent-core": "0.16.1",
+		"@gajae-code/ai": "0.16.1",
+		"@gajae-code/natives": "0.16.1",
+		"@gajae-code/tui": "0.16.1",
+		"@gajae-code/utils": "0.16.1",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",