@gajae-code/coding-agent 0.16.3 → 0.16.4

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/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

@@ -197,6 +197,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.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.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.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",

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);
+});

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

@@ -11,6 +11,8 @@ const inventoryPath = process.env.GJC_SDK_OPERATION_INVENTORY
 
 /** Reviewed seams deliberately excluded from the public SDK operation surface. */
 const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
+	"agent_session:reloadSkills":
+		"internal marketplace lifecycle refresh for the session skill catalog; not an independent SDK ingress operation",
 	"agent_session:getTerminalTurnEpoch":
 		"internal terminal-abort bus seam (epoch only), threaded via terminalAbortSeams; not a user-facing SDK control seam",
 	"agent_session:cancelPendingPreflightForTerminalAbort":
@@ -119,6 +121,13 @@ const LOCKED_EXCLUSIONS: Readonly<Record<string, string>> = {
 		"test-only parked terminal flush seam, not a user-facing SDK control seam",
 	"agent_session:setCancelAndSubmitAbortOutcomeProviderForTests":
 		"test-only cancellation seam, not a user-facing SDK control seam",
+	"agent_session:awaitDisposeCompletion": "test-only disposal completion seam, not a user-facing SDK control seam",
+	"agent_session:setDisposeTimeoutForTests": "test-only disposal timeout seam, not a user-facing SDK control seam",
+	"agent_session:trackPostPromptTaskForTests": "test-only post-prompt task seam, not a user-facing SDK control seam",
+	"agent_session:requestWorkerIntegrationForTests":
+		"test-only worker integration seam, not a user-facing SDK control seam",
+	"agent_session:runWithPromptAdmissionForTests":
+		"test-only prompt admission seam, not a user-facing SDK control seam",
 	"agent_session:getAgentId": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:emitNotice": "internal accessor/plumbing, not a user-facing control seam",
 	"agent_session:subscribe": "internal accessor/plumbing, not a user-facing control seam",