@gajae-code/coding-agent 0.16.3 → 0.16.6

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

@@ -62,6 +62,8 @@ export interface CreateAgentSessionOptions {
     cwd?: string;
     /** Global config directory. Default: ~/.gjc/agent */
     agentDir?: string;
+    /** Resolver-owned classification for `agentDir`; required when authority must survive HOME/config refreshes. */
+    profileAuthority?: "default" | "custom";
     /** Spawns to allow. Default: "*" */
     spawns?: string;
     /** Auth storage for credentials. Default: discoverAuthStorage(agentDir) */
@@ -336,7 +338,7 @@ export declare function discoverSkills(_cwd?: string, _agentDir?: string, _setti
  * Discover context files (AGENTS.md) walking up from cwd.
  * Returns files sorted by depth (farther from cwd first, so closer files appear last/more prominent).
  */
-export declare function discoverContextFiles(cwd?: string, _agentDir?: string): Promise<Array<{
+export declare function discoverContextFiles(cwd?: string, agentDir?: string): Promise<Array<{
     path: string;
     content: string;
     depth?: number;
@@ -361,6 +363,8 @@ export interface BuildSystemPromptOptions {
         content: string;
     }>;
     cwd?: string;
+    agentDir?: string;
+    profileAuthority?: "default" | "custom";
     appendPrompt?: string;
     repeatToolDescriptions?: boolean;
 }

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;
@@ -819,6 +826,8 @@ export declare class AgentSession {
     awaitSessionSettlement(): Promise<void>;
     /** Test seam: hold prompt admission while bypassing a pending selection fence. */
     runWithPromptAdmissionForTests(body: () => Promise<void>): Promise<void>;
+    /** Test seam: await all currently admitted coordinator sidecar writes. */
+    awaitCoordinatorRuntimeStatePersistenceForTests(): Promise<void>;
     queueCoordinatorRuntimeStatePersistForTests(event: AgentSessionEvent, gate: Promise<void>): Promise<void>;
     parkAgentEndForCoordinatorPersistForTests(event: Extract<AgentSessionEvent, {
         type: "agent_end";
@@ -1176,6 +1185,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/session/fallback-chain-controller.d.ts

@@ -95,5 +95,20 @@ export declare function cappedExponentialWithFullJitter(baseDelayMs: number, max
  * A missing, NaN, or infinite hint collapses to "no usable hint".
  */
 export declare function compactionRetryDelay(baseDelayMs: number, maxDelayMs: number, attempt: number, retryAfterMs: number | undefined): number;
+export interface CompactionCandidateFailure {
+    readonly model: string;
+    readonly message: string;
+}
+/**
+ * Error for an auto-compaction run whose every candidate failed.
+ *
+ * The candidate chain starts at the session model and ends on a same-provider
+ * largest-context fallback, so surfacing only the final error named a model
+ * the user never chose and hid that their own model had already failed the
+ * same way. The message leads with the first failure (the one the user can act
+ * on), then lists every candidate that was tried with its own error. `cause`
+ * is the final error so callers that classify by type keep the same object.
+ */
+export declare function describeCompactionCandidateFailures(failures: readonly CompactionCandidateFailure[], lastError: unknown): Error;
 /** Retry-After is intentionally uncapped. */
 export declare function effectiveFallbackDelay(baseDelayMs: number, maxDelayMs: number, attemptK: number, retryAfterMs: number | undefined, random?: () => number): number;

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

@@ -6,6 +6,13 @@ export declare const MANAGED_ARTIFACT_MAX_FILES = 50000;
 export declare const MANAGED_ARTIFACT_MAX_FILE_BYTES: number;
 export declare const MANAGED_ARTIFACT_MAX_TOTAL_BYTES: number;
 export declare const MANAGED_ARTIFACT_COPY_BATCH_SIZE = 256;
+/** A pre-mutation append fence rejection: no bytes from this append were written. */
+export declare class ManagedAppendIdentityMismatchError extends Error {
+    readonly code = "managed_append_identity_mismatch";
+    readonly relativePath: string;
+    readonly operatorMessage = "Session was resumed by another process; this resume did not run. Retry, or resume a different session.";
+    constructor(relativePath: string);
+}
 export declare class ManagedPublishError extends Error {
     readonly classification: "destination_conflict" | "atomic_unavailable" | "invalid_request" | "durability_not_provable" | "identity_mismatch" | "io_error" | "durability_failed";
     readonly diagnostic: string;

package/dist/types/session/messages.d.ts

@@ -82,6 +82,7 @@ export interface BashExecutionMessage {
     command: string;
     output: string;
     exitCode: number | undefined;
+    signal?: string;
     cancelled: boolean;
     truncated: boolean;
     meta?: OutputMeta;

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

@@ -9,7 +9,7 @@ import type { ManagedLegacyLocalMigrationSource } from "../internal-urls/local-p
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutResult, BlobStore } from "./blob-store";
 import { type ManagedMigrationPolicy } from "./internal/managed-session-scope";
-import { type ManagedBoundedAppendExpectation, type ManagedDirectoryRoot, type ManagedFileIdentity, ManagedSessionDescendantStore } from "./internal/managed-session-storage";
+import { ManagedAppendIdentityMismatchError, type ManagedBoundedAppendExpectation, type ManagedDirectoryRoot, type ManagedFileIdentity, ManagedSessionDescendantStore } from "./internal/managed-session-storage";
 import { type BaseAnchor, BoundedLabelsPinsStore, type CommittedTail, type DescriptorSnapshot, type DictionaryPartitionCommit, FixedCacheAccount, type MetadataDeltaValue, type ParentBucketCommit, type ReducerState, type ReopenClassification, SessionMemoryAccountant } from "./internal/session-memory-sidecar";
 import { type MemoryGuardCreateCheckpointInput, type MemoryGuardParticipantIngressLease, type MemoryGuardRestoreInput, type MemoryGuardRestoreResult, type MemoryGuardSessionManagerCheckpointV1 } from "./memory-guard-checkpoint-participant";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
@@ -1291,6 +1291,8 @@ export declare class SessionManager {
             }) => Promise<fs.BigIntStats>;
         };
     }): Promise<void>;
+    /** Ownership loss remains observable even when an agent event listener aborts the turn. */
+    getAppendIdentityMismatch(): ManagedAppendIdentityMismatchError | undefined;
     isPersisted(): boolean;
     stageDefaultModelSelection(model: string, thinkingLevel: string | undefined, options?: {
         readonly appendThinkingLevel: boolean;

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

@@ -0,0 +1,112 @@
+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 daemonTarget: PaseoDaemonTarget;
+        readonly daemonHost: 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 | undefined>;
+/**
+ * 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 sessionListContainsLiveSession(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/skill-state/canonical-skills.d.ts

@@ -1,3 +1,7 @@
 /** Native-free canonical GJC workflow skill identifiers. */
 export declare const CANONICAL_GJC_WORKFLOW_SKILLS: readonly ["deep-interview", "ralplan", "ultragoal", "autoresearch"];
 export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
+/** Case-insensitive, Win32-path-equivalent key used for skill collision checks. */
+export declare function getSkillFilesystemIdentity(name: string): string;
+/** Whether a name resolves to a bundled workflow under portable filesystem semantics. */
+export declare function isCanonicalGjcWorkflowSkillFilesystemAlias(name: string): boolean;

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

@@ -15,6 +15,10 @@ export declare function resolvePromptInput(input: string | undefined, descriptio
 export interface LoadContextFilesOptions {
     /** Working directory to start walking up from. Default: getProjectDir() */
     cwd?: string;
+    /** Agent directory backing native user-scope context and system prompt files. */
+    agentDir?: string;
+    /** Resolver-owned classification for `agentDir`; preserve it across HOME/config refreshes. */
+    profileAuthority?: "default" | "custom";
 }
 export interface ProjectContextFilesResult {
     contextFiles: Array<{
@@ -64,10 +68,16 @@ 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() */
     cwd?: string;
+    /** Agent directory backing native user-scope prompt discovery. */
+    agentDir?: string;
+    /** Resolver-owned classification for `agentDir`; preserve it across HOME/config refreshes. */
+    profileAuthority?: "default" | "custom";
     /** Pre-loaded context files (skips discovery if provided). */
     contextFiles?: Array<{
         path: string;

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

@@ -95,6 +95,9 @@ export interface ExecutorOptions {
     authStorage?: AuthStorage;
     modelRegistry?: ModelRegistry;
     settings?: Settings;
+    /** Parent session's selected agent directory and immutable resolver-owned authority. */
+    agentDir?: string;
+    profileAuthority?: "default" | "custom";
     /** Parent session's registry; shared by child sessions for IRC routing and roster visibility. */
     agentRegistry?: AgentRegistry;
     /**
@@ -114,7 +117,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/bash.d.ts

@@ -19,6 +19,7 @@ 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 suffixPrefixOverlap(source: string, target: string): number;
 export declare function saveBashOriginalArtifactForTests(session: ToolSession, originalText: string, onResult?: (result: BashOriginalArtifactSaveResult) => void): Promise<string | undefined>;
 declare const bashSchemaBase: z.ZodObject<{
     command: z.ZodString;

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

@@ -78,9 +78,10 @@ export interface CacheLookupOptions<T> {
      * must bypass persistent cache reads/writes.
      */
     authKey?: string | null;
-    fetchFresh: () => Promise<FreshResult<T>>;
+    fetchFresh: (signal?: AbortSignal) => Promise<FreshResult<T>>;
     settings?: Settings | undefined;
     now?: number;
+    signal?: AbortSignal;
 }
 export type CacheStatus = "miss" | "fresh" | "stale" | "disabled";
 export interface CacheLookupResult<T> {

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

@@ -152,6 +152,8 @@ export interface ToolSession {
      * Runtime discovery only; never threaded into capability loading.
      */
     home?: string;
+    /** Resolver-owned classification for the session's selected agent directory. */
+    profileAuthority?: "default" | "custom";
     skills?: Skill[];
     /** Currently executing skill prompt, when this tool session is inside one. */
     getActiveSkillState?: () => Pick<SkillActiveEntry, "skill" | "session_id"> | undefined;
@@ -197,6 +199,14 @@ export interface ToolSession {
     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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.16.3",
+	"version": "0.16.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.16.3",
-		"@gajae-code/agent-core": "0.16.3",
-		"@gajae-code/ai": "0.16.3",
-		"@gajae-code/natives": "0.16.3",
-		"@gajae-code/tui": "0.16.3",
-		"@gajae-code/utils": "0.16.3",
+		"@gajae-code/stats": "0.16.6",
+		"@gajae-code/agent-core": "0.16.6",
+		"@gajae-code/ai": "0.16.6",
+		"@gajae-code/natives": "0.16.6",
+		"@gajae-code/tui": "0.16.6",
+		"@gajae-code/utils": "0.16.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
@@ -130,6 +130,8 @@
 		"./session/session-manager-internal.js": null,
 		"./session/sdk-run-capability": null,
 		"./session/sdk-run-capability.js": null,
+		"./extensibility/extensions/function-hooks-internal": null,
+		"./extensibility/extensions/function-hooks-internal.js": null,
 		"./sdk": {
 			"types": "./dist/types/sdk/index.d.ts",
 			"import": "./src/sdk/index.ts"

package/scripts/capture-status-line-custom-editor-showcase.ts

@@ -0,0 +1,151 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+	renderStatusLineCustomEditorShowcase,
+	STATUS_LINE_CUSTOM_EDITOR_SHOWCASE_ENTRIES,
+	type StatusLineCustomEditorShowcaseEntry,
+} from "../test/fixtures/tui/status-line-custom-editor-showcase";
+import { ansiToHtml } from "./capture-sticky-viewport-showcase";
+
+const CANONICAL_COMMAND =
+	"bun packages/coding-agent/scripts/capture-status-line-custom-editor-showcase.ts --out .gjc/qa/status-line-custom-editor-<run>";
+const CAPTURE_TOOL_VERSION = "status-line-custom-editor-showcase-v1";
+const SOURCE_PATHS = [
+	"packages/coding-agent/src/modes/components/settings-selector.ts",
+	"packages/coding-agent/src/modes/components/tool-status-header.ts",
+	"packages/coding-agent/src/modes/controllers/selector-controller.ts",
+	"packages/tui/src/components/settings-list.ts",
+	"packages/coding-agent/test/fixtures/tui/status-line-custom-editor-showcase.ts",
+	"packages/coding-agent/scripts/verify-status-line-custom-editor-showcase.ts",
+] as const;
+
+interface ArtifactFile {
+	path: string;
+	sha256: string;
+	byte_length: number;
+}
+
+interface ManifestEntry {
+	key: string;
+	stateId: string;
+	viewport: { columns: number; rows: number };
+	renderMode: string;
+	simulatedStatusbarRows: number;
+	files: ArtifactFile[];
+}
+
+function usage(): never {
+	throw new Error(`Usage: ${CANONICAL_COMMAND}`);
+}
+
+function outputPath(args: string[]): string {
+	if (args.length !== 2 || args[0] !== "--out" || !args[1]) usage();
+	return args[1];
+}
+
+function json(value: unknown): string {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+
+function sha256(value: string): string {
+	return new Bun.CryptoHasher("sha256").update(value).digest("hex");
+}
+
+function commandOutput(command: string[]): string | undefined {
+	const result = Bun.spawnSync({ cmd: command, stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) return undefined;
+	const output = result.stdout.toString().trim();
+	return output || undefined;
+}
+
+async function sourceHash(): Promise<string> {
+	const entries = await Promise.all(
+		SOURCE_PATHS.map(async sourcePath => `${sourcePath}:${sha256(await Bun.file(sourcePath).text())}`),
+	);
+	return `sha256:${sha256(entries.join("\n"))}`;
+}
+
+function entryKey(entry: StatusLineCustomEditorShowcaseEntry): string {
+	return `${entry.stateId}/${entry.columns}x${entry.rows}/${entry.renderMode}`;
+}
+
+function simulatedStatusbarRows(text: string): number {
+	const lines = Bun.stripANSI(text).split("\n");
+	const heading = lines.findIndex(line => line.includes("Simulated statusbar"));
+	if (heading < 0) return 0;
+	let end = heading + 1;
+	while (end < lines.length && lines[end]?.trim() && !lines[end]?.includes("Warning:")) end++;
+	return Math.max(0, end - heading - 1);
+}
+
+async function writeArtifact(root: string, relativePath: string, content: string): Promise<ArtifactFile> {
+	const fullPath = path.join(root, relativePath);
+	await fs.mkdir(path.dirname(fullPath), { recursive: true });
+	await Bun.write(fullPath, content);
+	return { path: relativePath, sha256: sha256(content), byte_length: Buffer.byteLength(content) };
+}
+
+async function main(): Promise<void> {
+	const root = outputPath(process.argv.slice(2));
+	const sourceHead = commandOutput(["git", "rev-parse", "HEAD"]);
+	if (!sourceHead) throw new Error("Could not resolve source HEAD");
+	const captureActor = commandOutput(["gh", "api", "user", "--jq", ".login"]) ?? "unauthenticated";
+	const digest = await sourceHash();
+	const independentReviewPath = path.join(root, "independent-review.json");
+	const existingIndependentReview = (await Bun.file(independentReviewPath).exists())
+		? await Bun.file(independentReviewPath).text()
+		: undefined;
+	await fs.rm(root, { recursive: true, force: true });
+	await fs.mkdir(root, { recursive: true });
+	if (existingIndependentReview !== undefined) {
+		await Bun.write(independentReviewPath, existingIndependentReview);
+	}
+	const entries: ManifestEntry[] = [];
+	for (const entry of STATUS_LINE_CUSTOM_EDITOR_SHOWCASE_ENTRIES) {
+		const key = entryKey(entry);
+		const dir = key.replace(/[^a-zA-Z0-9._/-]/g, "_");
+		const terminalAnsi = await renderStatusLineCustomEditorShowcase(entry);
+		const renderedRows = terminalAnsi.split("\n").length;
+		if (renderedRows > entry.rows) {
+			throw new Error(`${key}: rendered ${renderedRows} rows for a ${entry.rows}-row viewport`);
+		}
+		const statusbarRows = simulatedStatusbarRows(terminalAnsi);
+		const terminalPlain = Bun.stripANSI(terminalAnsi);
+		const html = ansiToHtml(terminalAnsi);
+		const metadata = json({
+			tool: CAPTURE_TOOL_VERSION,
+			command: CANONICAL_COMMAND,
+			stateId: entry.stateId,
+			viewport: { columns: entry.columns, rows: entry.rows },
+			renderMode: entry.renderMode,
+			fixedClock: "2026-01-01T00:00:00.000Z",
+			simulatedStatusbarRows: statusbarRows,
+			wrappingPolicy: statusbarRows > 2 ? "two-row" : "single-row",
+		});
+		const files = [
+			await writeArtifact(root, `${dir}/terminal.txt`, terminalPlain),
+			await writeArtifact(root, `${dir}/terminal-ansi.txt`, terminalAnsi),
+			await writeArtifact(root, `${dir}/terminal.html`, html),
+			await writeArtifact(root, `${dir}/metadata.json`, metadata),
+		];
+		entries.push({
+			key,
+			stateId: entry.stateId,
+			viewport: { columns: entry.columns, rows: entry.rows },
+			renderMode: entry.renderMode,
+			simulatedStatusbarRows: statusbarRows,
+			files,
+		});
+	}
+	await writeArtifact(
+		root,
+		"manifest.json",
+		json({ tool: CAPTURE_TOOL_VERSION, sourceHead, sourceHash: digest, captureActor, entries }),
+	);
+	process.stdout.write(`Captured ${entries.length} status-line custom editor showcase entries at ${root}\n`);
+}
+
+void main().catch(error => {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(1);
+});