@gajae-code/coding-agent 0.16.1 → 0.16.4

package/dist/types/runtime-mcp/transports/stdio.d.ts

@@ -23,7 +23,3 @@ export declare class StdioTransport implements MCPTransport {
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
     close(): Promise<void>;
 }
-/**
- * Create and connect a stdio transport.
- */
-export declare function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport>;

package/dist/types/runtime-mcp/types.d.ts

@@ -78,6 +78,20 @@ export interface MCPServerConfigBase {
     };
 }
 /** Stdio server configuration */
+export interface MCPStdioSpawnLaunch {
+    command: string;
+    args: readonly string[];
+    cwd: string;
+    /** Transport-supplied registrar for retryable cleanup before preparation allocates resources. */
+    registerCleanup?: (cleanup: () => Promise<void>) => void;
+}
+export interface MCPStdioPreparedLaunch extends MCPStdioSpawnLaunch {
+    /**
+     * Per-attempt cleanup run after confirmed child exit or failed spawn. The same
+     * callback may already have been registered during preparation.
+     */
+    afterProcessExit?: () => Promise<void>;
+}
 export interface MCPStdioServerConfig extends MCPServerConfigBase {
     type?: "stdio";
     command: string;
@@ -91,6 +105,14 @@ export interface MCPStdioServerConfig extends MCPServerConfigBase {
      */
     noInheritEnv?: boolean;
     cwd?: string;
+    /** Internal trusted-boundary preparation of immutable per-spawn authority. */
+    prepareSpawn?: (launch: MCPStdioSpawnLaunch) => Promise<MCPStdioPreparedLaunch>;
+    /** Internal trusted-boundary check run immediately before process creation. */
+    spawnGuard?: (launch: MCPStdioSpawnLaunch) => Promise<void>;
+    /** Internal cleanup run only after the owned stdio child is confirmed exited. */
+    afterProcessExit?: () => Promise<void>;
+    /** Test seam for deterministic mutation after the guard and before process creation. */
+    afterSpawnGuardForTest?: () => Promise<void>;
 }
 /** HTTP server configuration (Streamable HTTP transport) */
 export interface MCPHttpServerConfig extends MCPServerConfigBase {

package/dist/types/sdk/bus/chat-daemon-runtime.d.ts

@@ -36,6 +36,18 @@ export interface ChatDaemonRuntimeDeps {
     createSlackProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["slack"]>) => SlackProviderClient;
     routerDeps?: SessionRouterDeps;
 }
+/**
+ * Chat notifications in lean mode are an answer surface, not a mirror of the
+ * session protocol. Lifecycle, identity, and activity frames remain available
+ * to verbose consumers, while finalized answers and action-needed events are
+ * delivered in lean mode.
+ */
+export declare function shouldPublishChatFrame(frame: Record<string, unknown>, verbosity: "lean" | "verbose" | undefined): boolean;
+/**
+ * A final answer's message ref identifies its one rendered message even when
+ * the SDK transport delivers an unpositioned duplicate frame.
+ */
+export declare function publicationIdForFinalChatAnswer(sessionId: string, frame: Record<string, unknown>): string | undefined;
 /**
  * Worker-owned session discovery and event fanout. It connects only through the
  * public SDK transport and retains SDK credentials solely in live client objects.

package/dist/types/sdk/bus/slack-live-provider.d.ts

@@ -59,6 +59,12 @@ export declare class SlackLiveProvider implements SlackProviderClient, SlackDiag
         clientMsgId: string;
         signal?: AbortSignal;
     }): Promise<SlackPostedMessage>;
+    addReaction(input: {
+        channel: string;
+        timestamp: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     findMessageByClientMsgId(input: {
         channel: string;
         clientMsgId: string;

package/dist/types/sdk/bus/slack-provider.d.ts

@@ -52,6 +52,12 @@ export interface SlackProviderClient {
         threadTs?: string;
         signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
+    addReaction?(input: {
+        channel: string;
+        timestamp: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Prove that an operator-supplied timestamp addresses a real message in the
      * requested channel. Adoption of an existing root is refused when a client
@@ -87,6 +93,12 @@ export declare class SlackProvider {
         threadTs?: string;
         signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
+    addReaction(input: {
+        channel: string;
+        timestamp: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /** Fail-closed root verification: a client without this capability can never confirm a root. */
     findMessageByTimestamp(input: {
         channel: string;

package/dist/types/sdk/cli/rows.d.ts

@@ -75,6 +75,13 @@ export interface SdkTailEnvelopeV1 {
     gap?: SdkRetentionGapV1;
     items: SdkTailItemV1[];
 }
+export declare function tailItemKey(item: SdkTailItemV1): string;
+/** Holds positioned live frames until the checkpoint can stamp their authoritative revision. */
+export declare class TailRevisionBuffer {
+    #private;
+    push(item: SdkTailItemV1): SdkTailItemV1[];
+    resolve(revision: number): SdkTailItemV1[];
+}
 /** Recursively removes secret-shaped fields (defense in depth for DTO output). */
 export declare function stripSecretFields(value: unknown): unknown;
 /**

package/dist/types/sdk/host/events.d.ts

@@ -26,6 +26,7 @@ export declare class SessionEventStream {
         generation?: number;
         ringSize?: number;
         resyncQueryIds?: string[];
+        revisionProvider?: () => number | undefined;
     });
     get generation(): number;
     get sequence(): number;

package/dist/types/sdk/host/host.d.ts

@@ -34,6 +34,8 @@ export type SessionActivationGate = (input: {
 export interface SessionSdkHostOptions extends HostEndpointAdapters {
     control?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
     query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
+    /** Supplies the durable transcript revision stamped on ordinary emitted events. */
+    eventRevision?: () => number | undefined;
     /** Test/lifecycle seam invoked synchronously before fire-and-forget dispatch. */
     onFrameAdmitted?: (connectionId: string, frame: SdkFrame) => void;
     /** Synchronously rejects external input while a runtime is being replaced. */

package/dist/types/sdk/host/session-runtime.d.ts

@@ -1,5 +1,6 @@
 import { type Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
+import type { AgentEndEvent } from "../../extensibility/shared-events";
 import { type MasterRoleAttestationV2, SessionIndex, type SessionLocatorV2 } from "../broker/session-index";
 import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import { type ReceiptState } from "../receipt-state";
@@ -24,6 +25,16 @@ export declare function verifyMasterCapabilityFrame(input: {
     nonce: string;
     attestationEpoch: string;
 };
+/**
+ * Normalize an agent-loop stop reason into the published terminal outcome.
+ *
+ * Only reached for a boundary that actually terminalizes an owned invocation,
+ * so every result is a `stopped` disposition: a failed run publishes its own
+ * correlated `agent_failed` frame with the sanitized cause instead.
+ */
+export declare function terminalStoppedOutcome(stopReason: AgentEndEvent["stopReason"], maintenanceOutcome: string | undefined): Extract<SdkPromptTerminalOutcome, {
+    kind: "stopped";
+}>;
 /** Transport-neutral endpoint contract consumed by the SDK session runtime. */
 export interface SessionSdkTransport {
     readonly sessionId: string;
@@ -167,6 +178,18 @@ export declare class SessionSdkSessionRuntime {
     get generation(): number;
     getProviderDefinitions(capability: string): unknown | undefined;
     emitEvent(frame: SdkFrame): void;
+    /**
+     * Deliver a frame to specific connections without recording it.
+     *
+     * Deliberately not `emitEvent`: that assigns a ring position and broadcasts to
+     * every authenticated socket. Streamed turn content is high-frequency and
+     * unbounded in size, so a count-bounded ring would evict the lifecycle events
+     * clients depend on -- including the `agent_end` that settles their prompt --
+     * and broadcasting would hand every subscriber a stream only the submitter
+     * asked for. Delivery failure is ignored: a disconnected consumer must never
+     * disturb the turn producing the content.
+     */
+    sendFrameTo(connectionIds: Iterable<string>, frame: SdkFrame): void;
     publish(frame: SdkFrame): void;
     startHost(): Promise<"started" | "already">;
     startTransport(): Promise<{

package/dist/types/sdk/session-api-key.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AgentLoop calls `getApiKey(provider)` before `streamFn`.
+ * Resolve/stream already use `getApiKey(model)`. If those two lookups diverge,
+ * the child dies locally (~8ms, 0 tokens, sanitized "Agent run failed.")
+ * and never reaches the working model-scoped path (#5081).
+ */
+export type SessionApiKeyModel = {
+    provider: string;
+    baseUrl?: string;
+};
+export type SessionApiKeyRegistry = {
+    getApiKey(model: SessionApiKeyModel, sessionId?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | undefined>;
+    getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<string | undefined>;
+};
+export type SessionApiKeyResolution = {
+    apiKey: string;
+    credentialSessionId: string | undefined;
+};
+export type SessionApiKeyCredentialType = "api_key" | "oauth" | undefined;
+export declare function isStableSessionApiKeyCredentialType(previous: SessionApiKeyCredentialType, replacement: SessionApiKeyCredentialType): boolean;
+export declare function resolveLiveSessionApiKeyModel(live: SessionApiKeyModel | undefined, captured: SessionApiKeyModel | undefined, provider: string): SessionApiKeyModel | undefined;
+export declare function lookupSessionApiKey(registry: SessionApiKeyRegistry, provider: string, sessionId: string | undefined, model: SessionApiKeyModel | undefined, allowUnscopedRetry?: boolean, signal?: AbortSignal): Promise<SessionApiKeyResolution>;

package/dist/types/sdk/transport/serve-cli.d.ts

@@ -7,7 +7,7 @@ type BrokerSessionRow = {
     ambiguous: boolean;
 };
 /** Exhausts strict broker `session.list` pages into one full session snapshot. */
-export declare function listBrokerSessions(broker: SdkClient): Promise<BrokerSessionRow[]>;
+export declare function listBrokerSessions(broker: SdkClient, explicitSessionId?: string): Promise<BrokerSessionRow[]>;
 /** Selects the session to serve through broker `session.list` truth (C10); exported for tests. */
 export declare function selectBrokerSession(sessions: BrokerSessionRow[], explicitSessionId: string | undefined): string;
 /**

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

@@ -241,6 +241,13 @@ export interface AgentSessionConfig {
     skills?: Skill[];
     /** Skill loading warnings (already captured by SDK) */
     skillWarnings?: SkillWarning[];
+    /** Re-enumerate filesystem and marketplace skills after plugin lifecycle changes. */
+    reloadSkills?: (cwd: string) => Promise<{
+        skills: Skill[];
+        warnings: SkillWarning[];
+    }>;
+    /** Publish a successfully committed skill catalog to SDK/process snapshots. */
+    onSkillsReloaded?: (skills: Skill[], warnings: SkillWarning[]) => void;
     /** Custom commands (TypeScript slash commands) */
     customCommands?: LoadedCustomCommand[];
     skillsSettings?: SkillsSettings;
@@ -1176,6 +1183,8 @@ export declare class AgentSession {
      * they must not survive a move out of it.
      */
     replaceSkills(skills: Skill[]): Promise<void>;
+    /** Refresh the live registered-skill catalog after install/remove/reload. */
+    reloadSkills(cwd?: string): Promise<void>;
     /**
      * Retire the cached workspace tree after a rescope so the next turn re-scans
      * at the new cwd instead of re-presenting the abandoned launcher root.

package/dist/types/setup/paseo/announce.d.ts

@@ -0,0 +1,111 @@
+export { resolvePaseoHome } from "./setup-deps";
+export type PaseoDaemonTarget = {
+    readonly kind: "ipc";
+    readonly socketPath: string;
+} | {
+    readonly kind: "tcp";
+    readonly host: string;
+    readonly port: number;
+};
+/** Why an announcement did nothing. Each reason is a distinct, actionable state. */
+export type PaseoAnnounceSkip = "no-paseo-config" | "no-provider" | "cli-missing" | "daemon-unreachable" | "unsupported-daemon-target" | "daemon-auth-required" | "session-not-live";
+export type PaseoAnnounceOutcome = {
+    readonly kind: "imported";
+    readonly providerKey: string;
+} | {
+    readonly kind: "already-imported";
+    readonly providerKey: string;
+} | {
+    readonly kind: "skipped";
+    readonly reason: PaseoAnnounceSkip;
+} | {
+    readonly kind: "failed";
+    readonly detail: string;
+};
+export interface PaseoAnnounceDependencies {
+    /** `~/.paseo/config.json` (or the `$PASEO_HOME` equivalent). */
+    readonly configJson: string;
+    /** `~/.paseo` (or `$PASEO_HOME`). */
+    readonly paseoHome: string;
+    readonly env: NodeJS.ProcessEnv;
+    /** Parsed JSON, or `undefined` when the file is absent or unreadable. */
+    readJson(file: string): Promise<unknown>;
+    /** Absolute path of the `paseo` CLI, or `undefined` when it is not installed. */
+    resolveCli(): string | undefined;
+    probeDaemon(target: PaseoDaemonTarget): Promise<boolean>;
+    /** True only when the broker index reports this session id as live in `cwd`. */
+    isSessionLive(sessionId: string, cwd: string): Promise<boolean>;
+    runImport(input: {
+        readonly cli: string;
+        readonly providerKey: string;
+        readonly cwd: string;
+        readonly sessionId: string;
+        readonly signal?: AbortSignal;
+    }): Promise<PaseoAnnounceOutcome>;
+}
+/**
+ * Pick the Paseo provider entry to import under.
+ *
+ * `gjc setup paseo` writes `gjc`, and `--mpreset <name>` writes `gjc-<name>`, so
+ * the base key is preferred and a preset provider is only used when it is the
+ * only one installed. A disabled entry is never selected: Paseo would refuse to
+ * launch it.
+ */
+export declare function selectProviderKey(config: unknown): string | undefined;
+/**
+ * Parse one Paseo listener spelling into a connectable target.
+ *
+ * Mirrors the spellings Paseo's own CLI accepts: `unix://`/`pipe://` prefixes, a
+ * bare absolute path, a bare port, `tcp://host:port`, and plain `host:port`.
+ */
+export declare function parseDaemonListen(raw: string): PaseoDaemonTarget | undefined;
+/**
+ * Resolve where the daemon listens, in the same precedence Paseo's CLI uses:
+ * environment override, then the running daemon's own pid file, then the
+ * configured listener, then Paseo's default.
+ */
+export declare function resolveDaemonTarget(config: unknown, deps: Pick<PaseoAnnounceDependencies, "env" | "paseoHome" | "readJson">): Promise<PaseoDaemonTarget>;
+/**
+ * Turn a non-zero `paseo import` into an outcome.
+ *
+ * Two of Paseo's refusals are not failures:
+ *
+ * - an already-known session is exactly the state we wanted to reach;
+ * - a password-protected daemon (`Cannot connect to daemon ...: Password
+ *   required`) is a configuration the user chose. The socket probe cannot see
+ *   it -- the TCP connect succeeds -- so it can only be recognized here, and
+ *   reporting it would put an error on screen at every single launch for
+ *   something GJC must not fix on its own. Exporting `PASEO_PASSWORD` makes it
+ *   work, since the CLI inherits this process's environment.
+ */
+export declare function classifyImportFailure(providerKey: string, detail: string): PaseoAnnounceOutcome;
+/**
+ * Run the full announcement once.
+ *
+ * The order is load-bearing: every cheap filesystem check runs before the socket
+ * probe, and the socket probe runs before anything spawns the Paseo CLI.
+ */
+export declare function announceSessionToPaseo(input: {
+    readonly sessionId: string;
+    readonly cwd: string;
+}, deps: PaseoAnnounceDependencies, signal?: AbortSignal): Promise<PaseoAnnounceOutcome>;
+/** Only a daemon that is not up yet, or a registration that has not landed yet, is worth retrying. */
+export declare function isRetryableOutcome(outcome: PaseoAnnounceOutcome): boolean;
+export interface PaseoAnnouncementHandle {
+    cancel(): void;
+}
+/**
+ * Announce the session, retrying only while Paseo is not ready to hear it.
+ *
+ * The user routinely opens Paseo after their terminal, so a single attempt at
+ * launch would silently never land. Retries are socket probes, not CLI spawns,
+ * and every timer is unref'd so the loop can never hold the process open.
+ */
+export declare function startPaseoAnnouncement(input: {
+    readonly sessionId: string;
+    readonly cwd: string;
+    isEnabled?: () => boolean;
+    onOutcome?: (outcome: PaseoAnnounceOutcome) => void;
+}, deps: PaseoAnnounceDependencies): PaseoAnnouncementHandle;
+export declare function sessionListContainsLiveSessionForTests(sessions: readonly unknown[], sessionId: string, cwd: string): boolean;
+export declare function createDefaultPaseoAnnounceDependencies(agentDir: string, env?: NodeJS.ProcessEnv): PaseoAnnounceDependencies;

package/dist/types/setup/paseo/setup-deps.d.ts

@@ -61,7 +61,8 @@ export interface PaseoSetupDependencies {
     runProviderLs(timeoutMs: number): Promise<PaseoLsOutcome>;
     now(): Date;
 }
-export declare function createDefaultPaseoPaths(agentDir?: string, home?: string): PaseoPaths;
+export declare function resolvePaseoHome(env?: NodeJS.ProcessEnv, home?: string): string;
+export declare function createDefaultPaseoPaths(agentDir?: string, home?: string, env?: NodeJS.ProcessEnv): PaseoPaths;
 /**
  * Parse `paseo provider ls --json`.
  *

package/dist/types/system-prompt.d.ts

@@ -64,6 +64,8 @@ export interface BuildSystemPromptOptions {
     pluginAppendices?: string;
     /** Repeat full tool descriptions in system prompt. Default: false */
     repeatToolDescriptions?: boolean;
+    /** Language guidance for internal technical reasoning. Default: off. */
+    reasoningLanguage?: "off" | "english";
     /** Skills settings for discovery. */
     skillsSettings?: SkillsSettings;
     /** Working directory. Default: getProjectDir() */

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

@@ -114,7 +114,8 @@ export interface ExecutorOptions {
     managedPersistence?: ManagedTaskPersistence;
     /**
      * The parent session's ENDPOINT-owned AsyncJobManager (resolved by the
-     * TaskTool via forEndpoint(sessionId) ?? instance()). Model metadata and
+     * TaskTool via its opaque async endpoint accessor, then the process-global
+     * fallback). Model metadata and
      * live-handle state for THIS subagent are recorded in the SAME manager the
      * task job runs in — with concurrent top-level sessions the process-global
      * instance belongs to a different session and would surface this subagent

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

@@ -58,6 +58,13 @@ interface ReadUrlCacheEntry {
     /** Offset of the preamble after `wrapUntrustedContent(output)` is persisted. */
     wrappedPreambleChars?: number;
 }
+export declare const READ_URL_CACHE_MAX_KEYS = 64;
+/** Test-only seam for deterministic module-global cache assertions. */
+export declare const readUrlCacheTestHooks: {
+    readonly size: number;
+    readonly retainedOutputChars: number;
+    reset(): void;
+};
 export declare function loadReadUrlCacheEntry(session: ToolSession, params: {
     path: string;
     raw?: boolean;

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

@@ -191,14 +191,20 @@ export interface ToolSession {
     hasForegroundBashBackgroundRequestHandler?: () => 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 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;
+    /**
+     * Opaque async-job ownership/lookup endpoint key. This is not a workflow or
+     * path identity: workflow/session consumers must use getSessionId(). Only
+     * AsyncJobManager ownership and endpoint-first lookup may use this accessor
+     * (subagent-inherited managers are registered under the parent's endpoint;
+     * review thread P1).
+     */
+    getAsyncEndpointId?: () => string | null;
     /** Get credential-selection session identity. */
     getCredentialSessionId?: () => string | null;
     /** Scope-held MCP facade for mcp:// resolution. */

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

@@ -122,6 +122,8 @@ export interface ToolScopeOptions {
     surfaceExactFilePaths?: boolean;
     /** Extra hint appended to "Path not found" when stat fails and the user supplied multiple paths. */
     multipathStatHint?: string;
+    /** Cancels internal-URL resolution and prevents further scope work. */
+    signal?: AbortSignal;
 }
 export interface ToolScopeResolution {
     searchPath: string;

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

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
+import type { grep as grepFn } from "@gajae-code/natives";
 import type { Component } from "@gajae-code/tui";
 import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -12,6 +13,7 @@ declare const searchSchema: z.ZodObject<{
     i: z.ZodOptional<z.ZodBoolean>;
     gitignore: z.ZodOptional<z.ZodBoolean>;
     skip: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, z.core.$strict>;
 export type SearchToolInput = z.infer<typeof searchSchema>;
 /** Maximum number of distinct files surfaced in a single response. The
@@ -56,6 +58,8 @@ export interface SearchToolOptions {
     context?: number;
     /** Per-call total match cap used by Cursor's native Pi grep frame. */
     totalMatchLimit?: number;
+    /** Test or remote override for the native grep implementation. */
+    grep?: typeof grepFn;
 }
 type SearchParams = z.infer<typeof searchSchema>;
 export declare class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
@@ -72,6 +76,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
         i: z.ZodOptional<z.ZodBoolean>;
         gitignore: z.ZodOptional<z.ZodBoolean>;
         skip: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     }, z.core.$strict>;
     readonly strict = true;
     constructor(session: ToolSession, options?: SearchToolOptions);
@@ -83,6 +88,7 @@ interface SearchRenderArgs {
     i?: boolean;
     gitignore?: boolean;
     skip?: number;
+    timeout?: number;
 }
 export declare const searchToolRenderer: {
     inline: boolean;

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

@@ -17,6 +17,10 @@ export declare function trimEditorTrailingNewline(text: string): string;
  * files still require a shell on Windows; ordinary executables do not.
  */
 export declare function shouldUseExternalEditorShell(editor: string, platform?: NodeJS.Platform): boolean;
+interface RawModeInput {
+    setRawMode?: (mode: boolean) => unknown;
+}
+export declare function prepareWindowsConsoleForExternalEditor(platform?: NodeJS.Platform, input?: RawModeInput): void;
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.
@@ -24,3 +28,4 @@ export declare function shouldUseExternalEditorShell(editor: string, platform?:
  * The caller is responsible for stopping/starting the TUI around this call.
  */
 export declare function openInEditor(editorCmd: string, content: string, options?: OpenInEditorOptions): Promise<string | null>;
+export {};

package/package.json

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