@gajae-code/coding-agent 0.10.2 → 0.11.0

package/dist/types/coordinator-mcp/server.d.ts

@@ -1,5 +1,5 @@
 import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
-import { type OwnerIsolationProbe } from "../gjc-runtime/tmux-owner-isolation";
+import { SdkClient } from "../sdk/client/client";
 import { type CoordinatorModelProfileLoader } from "./model-preset";
 import { type CoordinatorMcpConfig } from "./policy";
 import { type SessionReaper } from "./session-reaper";
@@ -22,71 +22,28 @@ interface JsonRpcResponse {
         data?: unknown;
     };
 }
-interface SessionStartInput {
-    cwd: string;
-    prompt?: string;
-    mpreset?: string | null;
-    namespace: {
-        profile: string | null;
-        repo: string | null;
-    };
-    worktree: true;
-    sessionId: string;
-    launchId: string;
-    /** Canonical, coordinator-owned immutable readiness marker path. */
-    readinessMarkerFile: string;
-    /** @deprecated Compatibility alias for injected launch providers. */
-    readinessFile: string;
-}
-interface CommandResult {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-}
-type CommandRunner = (command: string[], stdinLine?: string) => Promise<CommandResult>;
 interface CoordinatorServices {
-    listSessions?: () => unknown[] | Promise<unknown[]>;
-    startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
-    commandRunner?: CommandRunner;
-    forceCloseSession?: (sessionName: string, env: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string) => Promise<unknown>;
-    ownerIsolationProbe?: OwnerIsolationProbe;
+    connectSdk?: (url: string, token: string) => Promise<SdkClient>;
+    getAgentDir?: () => string;
     resolveModelProfiles?: CoordinatorModelProfileLoader;
+    canonicalizePath?: (value: string) => Promise<string>;
 }
 interface CoordinatorMcpServerOptions {
     env?: NodeJS.ProcessEnv;
     services?: CoordinatorServices;
+    platform?: NodeJS.Platform;
 }
 interface LegacyHandlerOptions {
     env?: NodeJS.ProcessEnv;
-    createSession?: (input: SessionStartInput) => unknown;
 }
-/**
- * Append an authoritative `--mpreset <profile>` to the coordinator child launch
- * command so the spawned GJC session activates the selected profile from its
- * first turn. The profile name is validated against the merged registry before
- * reaching here; it is still shell-quoted as defense in depth.
- *
- * Precedence note: this matches `gjc --mpreset <profile>` semantics exactly, so
- * an explicit model-affecting flag already present in the operator-configured
- * `sessionCommand` (e.g. a `--model`/`--thinking` baked into the launch command)
- * follows the same CLI precedence as a direct `gjc --mpreset ... --model ...`
- * invocation. The effective profile recorded on the session is the
- * coordinator-resolved request, not a child-attested activation receipt; a
- * cross-process activation receipt is a possible future enhancement and is out
- * of scope for the per-session selection contract here.
- */
-export declare function buildCoordinatorSessionCommand(sessionCommand: string, mpreset: string | null | undefined): string;
 export declare const COORDINATOR_AWAIT_TURN_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_RUNTIME_PROMPT_ACK_TIMEOUT_MAX_MS: number;
-export declare const COORDINATOR_RUNTIME_READINESS_TIMEOUT_MAX_MS: number;
 export declare const COORDINATOR_EVENT_WATCH_TIMEOUT_MAX_MS = 30000;
 export declare const COORDINATOR_POLL_INTERVAL_MAX_MS = 10000;
 export declare function boundedAwaitTurnTimeoutMs(value: unknown): number;
 export declare function boundedRuntimePromptAckTimeoutMs(value: unknown): number;
-export declare function boundedRuntimeReadinessTimeoutMs(value: unknown): number;
 export declare function boundedEventWatchTimeoutMs(value: unknown): number;
 export declare function boundedPollIntervalMs(value: unknown): number;
-export declare function coordinatorOwnerIsolationProbe(runner: CommandRunner): Promise<OwnerIsolationProbe>;
 export declare function readCoordinatorArtifact(config: CoordinatorMcpConfig, args: {
     path: unknown;
 }): Promise<Record<string, unknown>>;
@@ -101,7 +58,7 @@ export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServe
     }) => Promise<{
         ok: boolean;
         reason?: string;
-        killed: boolean;
+        closed: boolean;
         active_turn_id?: string;
         detail?: string;
     }>;

package/dist/types/daemon/builtin.d.ts

@@ -1,16 +1,17 @@
 /**
  * Static built-in daemon controller map.
  *
- * Intentionally a static map keyed by daemon kind rather than a mutable plugin
- * registry: there is exactly one kind today (`telegram`). Promote to a richer
- * registry only when a second daemon kind exists.
+ * Controllers are deliberately static rather than a mutable plugin registry.
  */
 import type { Settings } from "../config/settings";
-import { type TelegramDaemonControlDeps } from "../notifications/telegram-daemon-control";
+import { type ChatDaemonControlDeps } from "../sdk/bus/chat-daemon-control";
+import { type TelegramDaemonControlDeps } from "../sdk/bus/telegram-daemon-control";
 import type { BuiltInDaemonController, DaemonKind } from "./control-types";
-export declare const BUILT_IN_DAEMON_KINDS: readonly ["telegram"];
+export declare const BUILT_IN_DAEMON_KINDS: readonly ["telegram", "discord", "slack"];
 export interface BuiltInDaemonControllerDeps {
     telegram?: TelegramDaemonControlDeps;
+    discord?: ChatDaemonControlDeps;
+    slack?: ChatDaemonControlDeps;
 }
 export declare function createBuiltInDaemonControllers(settings: Settings, deps?: BuiltInDaemonControllerDeps): Record<DaemonKind, BuiltInDaemonController>;
 /**

package/dist/types/daemon/control-types.d.ts

@@ -5,7 +5,7 @@
  * controller contract. There is exactly one daemon kind today (`telegram`);
  * a richer registry is intentionally deferred until a second kind exists.
  */
-export type DaemonKind = "telegram";
+export type DaemonKind = "telegram" | "discord" | "slack";
 export type DaemonAction = "list" | "status" | "stop" | "reload";
 export type DaemonHealth = "not_configured" | "stopped" | "running" | "stale" | "stopping" | "error";
 export interface DaemonRuntimeInfo {

package/dist/types/discovery/mcp-json.d.ts

@@ -1 +1,12 @@
-export {};
+import { type MCPServer } from "../capability/mcp";
+import type { LoadResult } from "../capability/types";
+export interface MCPJsonLoadResult extends LoadResult<MCPServer> {
+    disabledServers: string[];
+}
+/**
+ * Load MCP servers from a JSON file.
+ */
+export declare function loadMCPJsonFile(filePath: string, level: "user" | "project", options?: {
+    quiet?: boolean;
+    useCache?: boolean;
+}): Promise<MCPJsonLoadResult>;

package/dist/types/extensibility/custom-tools/types.d.ts

@@ -42,7 +42,7 @@ export interface CustomToolAPI {
     exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
     /** UI methods for user interaction (select, confirm, input, notify, custom) */
     ui: CustomToolUIContext;
-    /** Whether UI is available (false in print/RPC mode) */
+    /** Whether an interactive UI is available */
     hasUI: boolean;
     /** File logger for error/warning/debug messages */
     logger: typeof import("@gajae-code/utils").logger;

package/dist/types/extensibility/extensions/compact-handler.d.ts

@@ -3,7 +3,7 @@
  *
  * Extension-facing APIs accept `string | CompactOptions`, but `AgentSession.compact`
  * takes two positional arguments `(instructions, options)`. This helper splits the
- * union so the same adapter can be reused by print-mode, rpc-mode, and the executor.
+ * union so the same adapter can be reused by print, SDK, ACP, and executor callers.
  */
 import type { Model } from "@gajae-code/ai";
 import type { CompactOptions } from "./types";
@@ -15,7 +15,9 @@ interface SetModelCapableSession {
     modelRegistry: {
         getApiKey(model: Model): Promise<string | undefined>;
     };
-    setModel(model: Model): Promise<unknown>;
+    setModel(model: Model, role?: string, options?: {
+        cause?: string;
+    }): Promise<unknown>;
 }
 /**
  * Helper for wiring the `setModel` action of an {@link ExtensionContext}.

package/dist/types/extensibility/extensions/get-commands-handler.d.ts

@@ -2,8 +2,8 @@
  * Helper for wiring the `getCommands` action of {@link ExtensionAPI}.
  *
  * Centralizes the union over the three slash-command sources the runtime
- * exposes so the five wiring sites (interactive UI, ACP, RPC, print, child
- * task executor) cannot drift:
+ * exposes so the interactive UI, ACP, SDK, print, and child task executor wiring
+ * sites cannot drift:
  *   - extension-registered hook commands (`source: "extension"`)
  *   - prompt commands loaded as `LoadedCustomCommand` — user/project/bundled
  *     custom commands and MCP prompts (`source: "prompt"`)

package/dist/types/extensibility/extensions/loader.d.ts

@@ -1,4 +1,5 @@
 import type { ThinkingLevel } from "@gajae-code/agent-core";
+import type { UsageReport } from "@gajae-code/ai";
 import { EventBus } from "../../utils/event-bus";
 import type { Extension, ExtensionFactory, ExtensionRuntime as IExtensionRuntime, LoadExtensionsResult } from "./types";
 export declare class ExtensionRuntimeNotInitializedError extends Error {
@@ -16,7 +17,7 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
         sourceId: string;
     }>;
     sendMessage(): void;
-    sendUserMessage(): void;
+    sendUserMessage(): Promise<void>;
     appendEntry(): void;
     setLabel(): void;
     getActiveTools(): string[];
@@ -26,6 +27,14 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
     setModel(): Promise<boolean>;
     getThinkingLevel(): ThinkingLevel;
     setThinkingLevel(): void;
+    getThinkingVisibility(): "visible" | "hidden";
+    setThinkingVisibility(): void;
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    setThinkingLevelForControl(): Promise<void>;
+    setThinkingVisibilityForControl(): Promise<void>;
+    setModelTemporaryForControl(): Promise<boolean>;
+    fetchUsageReportsForControl(): Promise<UsageReport[] | null>;
+    getThinkingScopeForControl(): "session" | "global config";
     getSessionName(): string | undefined;
     setSessionName(): Promise<void>;
 }

package/dist/types/extensibility/extensions/runner.d.ts

@@ -68,8 +68,8 @@ export declare class ExtensionRunner {
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
      *
      * If {@link initialize} has not yet run, the event is buffered and replayed once
-     * initialize wires the runtime/UI context. This matters because mode controllers
-     * (interactive, RPC, ACP, print, subagent) call `initialize()` AFTER `createAgentSession`
+     * initialize wires the runtime/UI context. This matters because session frontends
+     * (interactive, ACP, print, and subagent) call `initialize()` AFTER `createAgentSession`
      * returns, but `AuthStorage` can fire `credential_disabled` during startup model probes
      * inside `createAgentSession()`. Without deferral, extension handlers would observe
      * `hasUI=false`, an unset model, and no-op runtime actions on exactly the headline
@@ -126,7 +126,7 @@ export declare class ExtensionRunner {
         }>;
     }>;
     /** Emit input event. Transforms chain, "handled" short-circuits. */
-    emitInput(text: string, images: ImageContent[] | undefined, source: "interactive" | "rpc" | "extension"): Promise<InputEventResult>;
+    emitInput(text: string, images: ImageContent[] | undefined, source: "interactive" | "sdk" | "extension"): Promise<InputEventResult>;
     emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
     emitBeforeProviderRequest(payload: unknown): Promise<BeforeProviderRequestEventResult>;
     emitAfterProviderResponse(response: ProviderResponseMetadata, _model?: Model): Promise<void>;

package/dist/types/extensibility/extensions/types.d.ts

@@ -9,7 +9,7 @@
  */
 import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@gajae-code/agent-core";
 import type { CompactionResult } from "@gajae-code/agent-core/compaction";
-import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, TSchema } from "@gajae-code/ai";
+import type { Api, AssistantMessageEvent, AssistantMessageEventStream, Context, ImageContent, Model, ProviderResponseMetadata, SimpleStreamOptions, Static, TextContent, TSchema, UsageReport } from "@gajae-code/ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
 import type * as piCodingAgent from "@gajae-code/coding-agent";
 import type { AutocompleteItem, Component, EditorTheme, KeyId, TUI } from "@gajae-code/tui";
@@ -20,8 +20,9 @@ import type { PythonResult } from "../../eval/py/executor";
 import type { BashResult } from "../../exec/bash-executor";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { CustomEditor } from "../../modes/components/custom-editor";
-import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/unattended-session";
+import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/workflow-gate-broker";
 import type { Theme } from "../../modes/theme/theme";
+import type { ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
 import type { BashToolDetails, BashToolInput, FindToolDetails, FindToolInput, ReadToolDetails, ReadToolInput, SearchToolDetails, SearchToolInput, WriteToolInput } from "../../tools";
@@ -54,7 +55,7 @@ export interface ExtensionUIDialogOptions {
     /**
      * For interactive TUI select dialogs, render the focused option across
      * multiple rows instead of truncating it. This is a select-only rendering
-     * hint; non-TUI bridges (RPC, ACP) drop it and do not serialize it.
+     * hint; non-TUI clients (SDK, ACP) drop it and do not serialize it.
      */
     wrapFocused?: boolean;
     /**
@@ -68,7 +69,7 @@ export interface ExtensionUIDialogOptions {
      * inline: selecting it keeps the title and option list on screen and opens
      * a free-text input below the list. Submitting calls `onSubmit` with the
      * typed text and resolves the select with `optionLabel`; Escape returns to
-     * option selection. Non-TUI bridges (RPC, ACP) drop it; callers must keep
+     * option selection. Non-TUI clients (SDK, ACP) drop it; callers must keep
      * a fallback path for selects that resolve `optionLabel` without invoking
      * `onSubmit`.
      */
@@ -104,7 +105,7 @@ export type ExtensionUiComponentFactory = (tui: TUI, theme: Theme) => ExtensionU
 export type ExtensionWidgetContent = string[] | ExtensionUiComponentFactory | undefined;
 /**
  * UI context for extensions to request interactive UI.
- * Each mode (interactive, RPC, print) provides its own implementation.
+ * Interactive, SDK, and headless callers provide their own implementation.
  */
 export interface ExtensionUIContext {
     /** Show a selector and return the user's choice. */
@@ -175,6 +176,13 @@ export interface ExtensionUIContext {
     /** Set tool output expansion state. */
     setToolsExpanded(expanded: boolean): void;
 }
+export interface ExtensionTranscriptEntry {
+    id: string;
+    role: string;
+    textSummary: string;
+    ts: string;
+    body?: string;
+}
 export interface ContextUsage {
     /** Context tokens, or null if unknown (e.g. right after compaction, before next LLM response). */
     tokens: number | null;
@@ -204,7 +212,7 @@ export interface ExtensionContext {
     getContextUsage(): ContextUsage | undefined;
     /** Compact the session context (interactive mode shows UI). */
     compact(instructionsOrOptions?: string | CompactOptions): Promise<void>;
-    /** Whether UI is available (false in print/RPC mode) */
+    /** Whether an interactive UI is available */
     hasUI: boolean;
     /** Current working directory */
     cwd: string;
@@ -222,17 +230,60 @@ export interface ExtensionContext {
     abort(): void;
     /** Whether there are queued messages waiting */
     hasPendingMessages(): boolean;
+    /** Typed pending-message counts per queue (steering, follow-up, next-turn). */
+    getPendingMessageCounts(): {
+        steering: number;
+        followUp: number;
+        nextTurn: number;
+    };
+    /** Read-only session data exposed to extensions and the SDK host. */
+    getTranscript(): ExtensionTranscriptEntry[];
+    getTranscriptBody(entryId: string): string | undefined;
+    getGoalState(): unknown;
+    getTodoState(): unknown;
+    getQueuedMessages(): unknown[];
+    getActiveTools(): string[];
+    getAllTools(): string[];
+    /** Session control seams used by the SDK host. */
+    cycleModel(): Promise<{
+        model: Model;
+        thinkingLevel: ThinkingLevel | undefined;
+    } | undefined>;
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    setQueueMode(kind: "steering" | "follow_up" | "interrupt", mode: unknown): boolean;
+    getSkillState(): unknown;
+    getConfigItems(): unknown;
+    getBranchCandidates(): unknown;
+    getExtensions(): unknown;
+    getArtifact(id: string): Uint8Array | string | undefined | Promise<Uint8Array | string | undefined>;
+    getArtifactRange?(id: string, offset: number, length: number): {
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined | Promise<{
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined>;
+    getJobs(): unknown;
+    /** Typed skill and mode controls exposed to the SDK host. */
+    invokeSkill?(name: string, args?: string): Promise<unknown>;
+    setPlanMode?(on: boolean): unknown;
+    operateGoal?(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
+    /** Typed nonvisual session controls exposed to the SDK host. */
+    sdkControl?(operation: string, input: Record<string, unknown>): unknown | Promise<unknown>;
+    /** Install a permission callback backed by a live SDK reverse provider lease. */
+    setSdkPermissionProvider?(provider: ((toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal) => Promise<ClientBridgePermissionOutcome>) | undefined): void;
+    /** Names of session SDK seams actually installed by the active runtime. */
+    sdkBindings?(): readonly string[];
     /** Gracefully shutdown and exit. */
     shutdown(): void;
     /** Get the current effective system prompt. */
     getSystemPrompt(): string[];
     /** @deprecated Use hasPendingMessages() instead */
     hasQueuedMessages(): boolean;
-    /**
-     * Unattended workflow-gate bridge. Present only when the session runs in
-     * unattended/RPC mode; `undefined` in interactive/TUI mode (notify-only).
-     */
+    /** SDK workflow-gate bridge, when a session has a remote gate responder. */
     workflowGate?: WorkflowGateEmitter;
+    /** Clear the active conversation while preserving the saved session identity. */
+    clearContext(): Promise<boolean>;
 }
 /**
  * Extended context for command handlers.
@@ -419,12 +470,12 @@ export interface UserPythonEvent {
     /** Current working directory */
     cwd: string;
 }
-/** Fired when the user submits input (interactive mode only). */
+/** Fired when input enters through an interactive, SDK, or extension source. */
 export interface InputEvent {
     type: "input";
     text: string;
     images?: ImageContent[];
-    source: "interactive" | "rpc" | "extension";
+    source: "interactive" | "sdk" | "extension";
 }
 interface ToolCallEventBase {
     type: "tool_call";
@@ -662,7 +713,8 @@ export interface ExtensionAPI {
     /** Send a user message to the agent, or queue it when deliverAs is set. */
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
-    }): void;
+        onPreflightAccepted?: () => void;
+    }): Promise<void>;
     /** Append a custom entry to the session for state persistence (not sent to LLM). */
     appendEntry<T = unknown>(customType: string, data?: T): void;
     /** Execute a shell command. */
@@ -680,7 +732,23 @@ export interface ExtensionAPI {
     /** Get current thinking level. */
     getThinkingLevel(): ThinkingLevel | undefined;
     /** Set thinking level for the current session. */
-    setThinkingLevel(level: ThinkingLevel): void;
+    setThinkingLevel(level: ThinkingLevel, persist?: boolean): void;
+    /** Get whether thinking output is visible in the current session. */
+    getThinkingVisibility(): "visible" | "hidden";
+    /** Set whether thinking output is visible for the current session. */
+    setThinkingVisibility(visibility: "visible" | "hidden", persist?: boolean): void;
+    /** Cycle the current model's available thinking levels. */
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    /** Set thinking level from a session or durable global control surface. */
+    setThinkingLevelForControl(level: ThinkingLevel, persist: boolean): Promise<void>;
+    /** Set thinking visibility from a session or durable global control surface. */
+    setThinkingVisibilityForControl(visibility: "visible" | "hidden", persist: boolean): Promise<void>;
+    /** Set the model for this session only. Returns false when it is unavailable. */
+    setModelTemporaryForControl(model: Model, expectedSessionId?: string): Promise<boolean>;
+    /** Fetch provider usage through the session's canonical provider resolution. */
+    fetchUsageReportsForControl(): Promise<UsageReport[] | null>;
+    /** Report whether the current effort follows global config or a session override. */
+    getThinkingScopeForControl(): "session" | "global config";
     /** Get the current session name. */
     getSessionName(): string | undefined;
     /** Set the session name. Persists to the session file. */
@@ -816,15 +884,24 @@ options?: {
 }) => void;
 export type SendUserMessageHandler = (content: string | (TextContent | ImageContent)[], options?: {
     deliverAs?: "steer" | "followUp";
-}) => void;
+    onPreflightAccepted?: () => void;
+}) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
 export type GetActiveToolsHandler = () => string[];
 export type GetAllToolsHandler = () => string[];
 export type GetCommandsHandler = () => SlashCommandInfo[];
 export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 export type SetModelHandler = (model: Model) => Promise<boolean>;
+export type CycleThinkingLevelHandler = () => ThinkingLevel | undefined;
+export type SetThinkingLevelForControlHandler = (level: ThinkingLevel, persist: boolean) => Promise<void>;
+export type SetThinkingVisibilityForControlHandler = (visibility: "visible" | "hidden", persist: boolean) => Promise<void>;
+export type SetModelTemporaryForControlHandler = (model: Model, expectedSessionId?: string) => Promise<boolean>;
+export type FetchUsageReportsForControlHandler = () => Promise<UsageReport[] | null>;
+export type GetThinkingScopeForControlHandler = () => "session" | "global config";
 export type GetThinkingLevelHandler = () => ThinkingLevel | undefined;
 export type SetThinkingLevelHandler = (level: ThinkingLevel, persist?: boolean) => void;
+export type GetThinkingVisibilityHandler = () => "visible" | "hidden";
+export type SetThinkingVisibilityHandler = (visibility: "visible" | "hidden", persist?: boolean) => void;
 /** Shared state created by loader, used during registration and runtime. */
 export interface ExtensionRuntimeState {
     flagValues: Map<string, boolean | string>;
@@ -848,6 +925,14 @@ export interface ExtensionActions {
     setModel: SetModelHandler;
     getThinkingLevel: GetThinkingLevelHandler;
     setThinkingLevel: SetThinkingLevelHandler;
+    getThinkingVisibility: GetThinkingVisibilityHandler;
+    setThinkingVisibility: SetThinkingVisibilityHandler;
+    cycleThinkingLevel: CycleThinkingLevelHandler;
+    setThinkingLevelForControl: SetThinkingLevelForControlHandler;
+    setThinkingVisibilityForControl: SetThinkingVisibilityForControlHandler;
+    setModelTemporaryForControl: SetModelTemporaryForControlHandler;
+    fetchUsageReportsForControl: FetchUsageReportsForControlHandler;
+    getThinkingScopeForControl: GetThinkingScopeForControlHandler;
     getSessionName: () => string | undefined;
     setSessionName: (name: string) => Promise<void>;
 }
@@ -857,12 +942,52 @@ export interface ExtensionContextActions {
     isIdle: () => boolean;
     abort: () => void;
     hasPendingMessages: () => boolean;
+    /** Typed pending-message counts per queue; optional for embedders without a counted queue. */
+    getPendingMessageCounts?: () => {
+        steering: number;
+        followUp: number;
+        nextTurn: number;
+    };
+    getTranscript?: () => ExtensionTranscriptEntry[];
+    getTranscriptBody?: (entryId: string) => string | undefined;
+    getGoalState?: () => unknown;
+    getTodoState?: () => unknown;
+    getQueuedMessages?: () => unknown[];
+    getActiveTools?: () => string[];
+    getAllTools?: () => string[];
     shutdown: () => void;
     getContextUsage: () => ContextUsage | undefined;
     compact: (instructionsOrOptions?: string | CompactOptions) => Promise<void>;
     getSystemPrompt: () => string[];
-    /** Unattended workflow-gate bridge (present only in unattended/RPC mode). */
+    /** SDK workflow-gate bridge, when a session has a remote gate responder. */
     getWorkflowGate?: () => WorkflowGateEmitter | undefined;
+    /** Clear the active conversation while preserving the saved session identity. */
+    clearContext?: () => Promise<boolean>;
+    /** Session control and query seams exposed to the per-session SDK host. */
+    cycleModel?: () => Promise<{
+        model: Model;
+        thinkingLevel: ThinkingLevel | undefined;
+    } | undefined>;
+    cycleThinkingLevel?: () => ThinkingLevel | undefined;
+    setQueueMode?: (kind: "steering" | "follow_up" | "interrupt", mode: unknown) => boolean;
+    getSkillState?: () => unknown;
+    getConfigItems?: () => unknown;
+    getBranchCandidates?: () => unknown;
+    getExtensions?: () => unknown;
+    getArtifact?: (id: string) => Uint8Array | string | undefined | Promise<Uint8Array | string | undefined>;
+    getArtifactRange?: (id: string, offset: number, length: number) => {
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined | Promise<{
+        bytes: Uint8Array;
+        totalBytes: number;
+    } | undefined>;
+    getJobs?: () => unknown;
+    setSdkPermissionProvider?: (provider: ((toolCall: ClientBridgePermissionToolCall, options: ClientBridgePermissionOption[], signal?: AbortSignal) => Promise<ClientBridgePermissionOutcome>) | undefined) => void;
+    sdkControl?: (operation: string, input: Record<string, unknown>) => unknown | Promise<unknown>;
+    invokeSkill?: (name: string, args?: string) => Promise<unknown>;
+    setPlanMode?: (on: boolean) => unknown;
+    operateGoal?: (op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string) => Promise<unknown>;
 }
 /** Actions for ExtensionCommandContext (ctx.* in command handlers). */
 export interface ExtensionCommandContextActions {

package/dist/types/extensibility/hooks/types.d.ts

@@ -11,7 +11,7 @@ import type { AgentEndEvent, AgentStartEvent, AutoCompactionEndEvent, AutoCompac
 export type { ExecOptions, ExecResult } from "../../exec/exec";
 /**
  * UI context for hooks to request interactive UI from the harness.
- * Each mode (interactive, RPC, print) provides its own implementation.
+ * Interactive and headless callers provide their own implementation.
  */
 export interface HookUIContext {
     /**

package/dist/types/gjc-runtime/launch-tmux.d.ts

@@ -1,8 +1,9 @@
 import type { Args } from "../cli/args";
 import { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, type GjcTmuxProfileCommand } from "./tmux-common";
 import { type OwnerIsolationProbeSync } from "./tmux-owner-isolation";
-export { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
-export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
+import { buildWindowsPowerShellInnerCommand, GJC_TMUX_LAUNCHED_ENV, type WindowsPowerShellInnerCommandOptions } from "./windows-powershell-command";
+export type { WindowsPowerShellInnerCommandOptions };
+export { buildGjcTmuxExactSessionTarget, buildGjcTmuxProfileCommands, buildWindowsPowerShellInnerCommand, GJC_DEFAULT_TMUX_SESSION, GJC_TMUX_COMMAND_ENV, GJC_TMUX_LAUNCHED_ENV, GJC_TMUX_MOUSE_ENV, GJC_TMUX_PROFILE_ENV, GJC_TMUX_SESSION_PREFIX, };
 export declare const GJC_LAUNCH_POLICY_ENV = "GJC_LAUNCH_POLICY";
 export declare const GJC_TMUX_WINDOW_LABEL_MAX_WIDTH = 48;
 interface TtyState {

package/dist/types/gjc-runtime/psmux-detect.d.ts

@@ -36,6 +36,9 @@ export type PsmuxSpawnRunner = (command: string, args: string[]) => {
 export type BinaryResolver = (candidate: string) => string | null;
 /** @internal Test-only seam; production code never calls this. */
 export declare function __setBinaryResolverForTests(resolver: BinaryResolver | null): void;
+export type ExecutableIdentityResolver = (path: string) => string | null;
+/** @internal Test-only seam; production code never calls this. */
+export declare function __setExecutableIdentityResolverForTests(resolver: ExecutableIdentityResolver | null): void;
 export declare function envDisabled(value: string | undefined): boolean;
 /**
  * Decide whether command resolves to a psmux binary by probing its version

package/dist/types/gjc-runtime/session-state-sidecar.d.ts

@@ -41,6 +41,8 @@ export interface RuntimeStateContext {
     sessionId: string;
     cwd: string;
     sessionFile?: string | null;
+    /** Optional platform seam for deterministic cross-platform path identity checks. */
+    platform?: NodeJS.Platform;
     branch?: string | null;
     /** Public-safe owner metadata used to persist the canonical terminal verdict. */
     ownerTerminal?: OwnerTerminalContext | null;
@@ -60,6 +62,7 @@ export declare function readTerminalRuntimeStateMarker(input: {
     sessionId?: string | null;
     cwd?: string | null;
     sessionFile?: string | null;
+    platform?: NodeJS.Platform;
 }): Promise<TerminalRuntimeStateStatus>;
 export declare function stateForEvent(event: RuntimeStateEvent): RuntimeState | null;
 export declare function eventAffectsCoordinatorRuntimeState(event: RuntimeStateEvent): boolean;

package/dist/types/gjc-runtime/team-runtime.d.ts

@@ -146,7 +146,7 @@ export interface GjcTeamWorkerLifecycle {
 }
 export type GjcTeamNotificationDeliveryState = "pending" | "sent" | "queued" | "deferred" | "failed" | "delivered" | "acknowledged";
 export type GjcTeamPaneAttemptResult = "sent" | "queued" | "deferred" | "failed";
-export type GjcTeamMailboxDeliveryTransportKind = "notifications_sdk" | "pane";
+export type GjcTeamMailboxDeliveryTransportKind = "sdk" | "pane";
 export interface GjcTeamNotification {
     id: string;
     kind: "mailbox_message" | "worker_lifecycle" | "invalid_attempt";
@@ -175,7 +175,7 @@ export interface GjcTeamMailboxDeliveryInput {
     env: NodeJS.ProcessEnv;
 }
 export type GjcTeamMailboxDeliveryResult = {
-    transport: "notifications_sdk";
+    transport: "sdk";
     state: GjcTeamNotificationDeliveryState;
     reason?: string;
 } | {
@@ -314,8 +314,7 @@ export declare function resolveWorkerWorktreePath(input: {
     platform: NodeJS.Platform;
     isPsmux: boolean;
 }): string;
-type CommandPathResolver = (command: string) => string | null;
-export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, argv?: string[], execPath?: string, which?: CommandPathResolver): string;
+export declare function resolveGjcWorkerCommand(cwd?: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, argv?: string[], execPath?: string): string;
 /** @internal Exported for unit tests. */
 export declare function buildWorkerCommand(config: GjcTeamConfig, worker: GjcTeamWorker, platform?: NodeJS.Platform): string;
 export type GjcWorkerCheckpointClassification = {

package/dist/types/gjc-runtime/tmux-owner-isolation-cli.d.ts

@@ -1,5 +1,18 @@
+import { type TmuxServerProof } from "./tmux-owner-isolation";
 /** Matches the sole argv shape allowed to enter the owner-isolation JSON-line protocol. */
 export declare function isTmuxOwnerIsolationCliArgv(argv: readonly string[]): boolean;
+interface TmuxListSessionsResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+interface TmuxServerProofOptions {
+    platform?: NodeJS.Platform;
+    runListSessions?: (argv: string[]) => TmuxListSessionsResult;
+}
+/** Probes a tmux server using an injectable list-sessions runner for platform-bounded callers. */
+export declare function tmuxServerProof(socketKey: string, tmuxControlArgv?: string[], options?: TmuxServerProofOptions): Promise<TmuxServerProof>;
 /** Reads exactly one bounded JSON line and writes exactly one JSON response line. */
 export declare function runTmuxOwnerIsolationCli(stdin: string): Promise<string>;
 export declare function runTmuxOwnerIsolationCliFromStdin(): Promise<void>;
+export {};

package/dist/types/gjc-runtime/tmux-sessions.d.ts

@@ -65,6 +65,9 @@ export interface ForceCloseOwnerDependencies {
     sleep(ms: number): Promise<void>;
     listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
 }
+export interface CreateGjcTmuxSessionOptions {
+    platform?: NodeJS.Platform;
+}
 export type CreateOwnerIsolationTestDependencies = {
     probe?: Partial<OwnerIsolationProbeSync>;
     execute?: (plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies) => TmuxOwnerIsolationExecutionResult;
@@ -80,7 +83,7 @@ export declare function findGjcTmuxSessionByBranch(branch: string, env?: NodeJS.
 export declare function findGjcTmuxSessionByName(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
 export declare function findGjcTmuxSessionByScope(project: string, branch: string | null | undefined, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus | undefined;
 export declare function statusGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
-export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
+export declare function createGjcTmuxSession(env?: NodeJS.ProcessEnv, options?: CreateGjcTmuxSessionOptions): GjcTmuxSessionStatus;
 /** Proves a managed reusable name still resolves to one immutable session on one server. */
 export declare function proveGjcTmuxSessionMutationTarget(sessionName: string, env?: NodeJS.ProcessEnv): ProvenTmuxSessionIdentity;
 /** @internal */

package/dist/types/gjc-runtime/windows-powershell-command.d.ts

@@ -0,0 +1,9 @@
+export declare const GJC_TMUX_LAUNCHED_ENV = "GJC_TMUX_LAUNCHED";
+export interface WindowsPowerShellInnerCommandOptions {
+    command: readonly string[];
+    args?: readonly string[];
+    environment?: Record<string, string>;
+    tmuxExitMarkerPath?: string;
+}
+/** Builds the shared BOM-free UTF-16LE command for native Windows tmux-compatible panes. */
+export declare function buildWindowsPowerShellInnerCommand({ command, args, environment, tmuxExitMarkerPath, }: WindowsPowerShellInnerCommandOptions): string;