@gajae-code/coding-agent 0.9.6 → 0.10.1

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

@@ -0,0 +1,309 @@
+/**
+ * Provenance and lifecycle primitives for tmux-resident GJC owners.
+ * This module intentionally accepts and stores only opaque identifiers and
+ * process/cgroup metadata; it never reads panes, prompts, environment, or logs.
+ */
+export declare const TMUX_OWNER_ISOLATION_SCHEMA_VERSION = 1;
+export declare const TMUX_OWNER_ISOLATION_MAX_LINE_BYTES: number;
+export declare const TMUX_OWNER_ISOLATION_MAX_DIAGNOSTIC_CHARS = 512;
+export declare function tmuxOwnerIsolationBootstrapArgv(): string[];
+export type CgroupClassification = "not_applicable" | "safe" | "unsafe_service" | "unverifiable";
+export type ServerState = "absent" | "safe" | "unsafe" | "unverifiable";
+export type PlanErrorCode = "scope_unavailable" | "server_unsafe" | "server_unverifiable" | "server_race" | "scope_bootstrap_failed";
+export type ExpectedTerminalResult = "owner_term_then_session_cleanup";
+export type TerminalSignal = "SIGTERM" | "SIGHUP" | "SIGINT" | "SIGKILL" | "EXIT" | "MANUAL" | "UNKNOWN";
+export type VerdictClassification = "expected_operator_shutdown" | "unexpected_owner_loss" | "non_operator_cleanup";
+export type TerminalObserver = "sidecar" | "raw_monitor";
+export interface CgroupInfo {
+    classification: CgroupClassification;
+    scope?: string;
+    diagnostic?: string;
+}
+/** Classify only public cgroup path metadata; malformed Linux data fails closed. */
+export declare function classifyCgroup(input: {
+    platform: NodeJS.Platform;
+    cgroupText?: string | null;
+}): CgroupInfo;
+export declare function ownerProcessStartTime(platform: NodeJS.Platform, stat: string | null): string | null;
+export interface TmuxServerProof {
+    state: ServerState;
+    pid?: number;
+    startTime?: string;
+    cgroup?: CgroupInfo;
+    sessionNames?: string[];
+}
+export interface PlanRequest {
+    schema_version: 1;
+    op: "plan";
+    platform: NodeJS.Platform;
+    session_id: string;
+    owner_generation: string;
+    cwd: string;
+    state_dir: string;
+    socket_key: string;
+    tmux_argv: string[];
+    baseline: OwnerGenerationBaseline;
+}
+export interface PublishGenerationRequest {
+    schema_version: 1;
+    op: "publish_generation";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    baseline: OwnerGenerationBaseline;
+}
+export interface PublishGenerationResult {
+    schema_version: 1;
+    ok: true;
+    code: "generation_published";
+    generation: string;
+}
+export interface AttemptCapability {
+    token: string;
+    session_name: string;
+    socket_key: string;
+    server_absent_before: boolean;
+    baseline: OwnerGenerationBaseline;
+    expires_at: string;
+}
+export interface DirectExecution {
+    mode: "direct";
+    argv: string[];
+    attempt_session: string;
+    server_key: string;
+    server_absent_before: boolean;
+    server_pid?: number;
+    server_start_time?: string;
+}
+export interface ScopedExecution {
+    mode: "scoped";
+    argv: string[];
+    stdin_line: string;
+    expected_scope: string;
+    attempt: AttemptCapability;
+    attempt_session: string;
+    server_key: string;
+    server_absent_before: true;
+}
+export type PlanExecution = DirectExecution | ScopedExecution;
+export interface PlanSuccess {
+    schema_version: 1;
+    ok: true;
+    code: "not_required" | "unsafe_scope_required";
+    execution: PlanExecution;
+    classification: CgroupInfo;
+    server_state: ServerState;
+}
+export interface TmuxOwnerIsolationExecutionSuccess {
+    ok: true;
+    code: "executed";
+    execution: PlanExecution;
+    server: TmuxServerProof;
+    server_key: string;
+    server_pid: number;
+    server_start_time: string;
+    server_session: string;
+    native_session_id?: string;
+}
+export interface PlanFailure {
+    schema_version: 1;
+    ok: false;
+    code: PlanErrorCode;
+    diagnostic: string;
+}
+export type PlanResponse = PlanSuccess | PlanFailure;
+export interface OwnerIsolationProbe {
+    readCallerCgroup(): Promise<string | null>;
+    probeServer(socketKey: string, tmuxArgv?: string[]): Promise<TmuxServerProof>;
+}
+/** Synchronous probe boundary for managed launch paths. */
+export interface OwnerIsolationProbeSync {
+    readCallerCgroup(): string | null;
+    probeServer(socketKey: string): TmuxServerProof;
+    recordAttempt(input: {
+        stateDir: string;
+        sessionId: string;
+        generation: string;
+        attempt: AttemptCapability;
+    }): void;
+}
+export interface TmuxOwnerIsolationExecutionFailure {
+    ok: false;
+    code: PlanErrorCode;
+    diagnostic: string;
+}
+export type TmuxOwnerIsolationExecutionResult = TmuxOwnerIsolationExecutionSuccess | TmuxOwnerIsolationExecutionFailure;
+/** Synchronous spawn boundary; callers pass argv and scoped stdin unchanged. */
+export interface TmuxOwnerIsolationExecutionDependencies {
+    socketKey: string;
+    spawn(argv: string[], stdinLine?: string): {
+        exitCode: number | null;
+        stdout?: string;
+    };
+    probeServer(socketKey: string): TmuxServerProof;
+    /** Reads the published owner generation immediately around direct execution. */
+    isCurrentGeneration?(): boolean;
+    cleanupSpawned?(input: {
+        execution: DirectExecution;
+        nativeSessionId: string;
+        server: TmuxServerProof;
+    }): void;
+}
+export declare function isExactScopedBootstrapSuccessReceipt(stdout: string): boolean;
+/**
+ * Synchronous equivalent of the target-server truth table for managed callers.
+ * Attempt persistence is injected so a caller can use its existing atomic state writer.
+ */
+export declare function planTmuxOwnerIsolationSync(request: PlanRequest, probe: OwnerIsolationProbeSync): PlanResponse;
+/**
+ * Runs one planned argv exactly and re-proves the target server before callers
+ * perform profile, attach, or cleanup operations.
+ */
+export declare function executeTmuxOwnerIsolationPlanSync(plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies): TmuxOwnerIsolationExecutionResult;
+/** Implements the target-server truth table before any tmux operation. */
+export declare function planTmuxOwnerIsolation(request: PlanRequest, probe: OwnerIsolationProbe): Promise<PlanResponse>;
+export interface BootstrapRequest {
+    schema_version: 1;
+    op: "bootstrap";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    socket_key: string;
+    expected_scope: string;
+    tmux_argv: string[];
+    attempt: AttemptCapability;
+}
+export interface BootstrapResult {
+    schema_version: 1;
+    ok: boolean;
+    code: "bootstrapped" | "scope_bootstrap_failed";
+    native_session_id?: string;
+    server_pid?: number;
+    server_start_time?: string;
+    session_name?: string;
+    diagnostic?: string;
+}
+export interface BootstrapDependencies {
+    readSelfCgroup(): Promise<string | null>;
+    spawn(argv: string[]): {
+        exitCode: number | null;
+        stdout?: string;
+    };
+    probeServer(socketKey: string, tmuxControlArgv?: string[]): Promise<TmuxServerProof>;
+}
+/** Self-proves the scope and synchronously invokes the exact supplied argv. */
+export declare function bootstrapTmuxOwnerIsolation(request: BootstrapRequest, deps: BootstrapDependencies): Promise<BootstrapResult>;
+export interface OwnerIntent {
+    schema_version: 1;
+    intent_id: string;
+    generation: string;
+    session_id: string;
+    server_key: string;
+    expected_terminal: {
+        signal: "SIGTERM";
+        result: ExpectedTerminalResult;
+    };
+    dispatch_id: string;
+    created_at: string;
+    expires_at: string;
+    state: "pending";
+}
+export interface OwnerVerdict {
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    server_key: string;
+    observed_at: string;
+    signal: TerminalSignal;
+    exit_code: number | null;
+    result: string;
+    observer: TerminalObserver;
+    classification: VerdictClassification;
+    reason: string;
+    intent_id?: string;
+    dedupe_key: string;
+}
+export interface OwnerIncident {
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    dedupe_key: string;
+    created_at: string;
+    classification: "unexpected_owner_loss";
+}
+export interface ObserveTerminalRequest {
+    schema_version: 1;
+    op: "observe_terminal";
+    session_id: string;
+    owner_generation: string;
+    state_dir: string;
+    socket_key: string;
+    observer: TerminalObserver;
+    observed_at: string;
+    signal: TerminalSignal;
+    exit_code: number | null;
+    exit_kind: string;
+    reason: string;
+    operator_dispatch_id?: string;
+}
+export interface LifecyclePaths {
+    root: string;
+    generation: string;
+    generationFile: string;
+    generationMarkerFile: string;
+    intentFile: string;
+    verdictFile: string;
+    verdictAliasFile: string;
+    incidentFile: string;
+    lockDatabaseFile: string;
+    journalFile: string;
+}
+export declare function lifecyclePaths(stateDir: string, sessionId: string, generation: string): LifecyclePaths;
+export declare function replaceOwnerGeneration(stateDir: string, sessionId: string, generation?: string, expectedBaseline?: OwnerGenerationBaseline): Promise<string>;
+export type OwnerGenerationBaseline = {
+    state: "absent";
+} | {
+    state: "current";
+    schema_version: 1;
+    generation: string;
+    session_id: string;
+    published_at: string;
+};
+export declare function captureOwnerGenerationBaseline(stateDir: string, sessionId: string): Promise<OwnerGenerationBaseline>;
+/** Captures the full immutable generation record for a planned owner launch. */
+export declare function captureOwnerGenerationBaselineSync(stateDir: string, sessionId: string): OwnerGenerationBaseline;
+export declare function isOwnerGenerationBaselineCurrentSync(stateDir: string, sessionId: string, baseline: OwnerGenerationBaseline): boolean;
+/** Synchronous publication for managed launch paths, serialized by a SQLite write transaction. */
+export declare function replaceOwnerGenerationSync(stateDir: string, sessionId: string, generation: string, expectedBaseline: OwnerGenerationBaseline): string;
+/** Publishes a raw-owner generation through the canonical SQLite-serialized CAS path. */
+export declare function publishOwnerGenerationSync(request: PublishGenerationRequest): PublishGenerationResult;
+export declare function createOwnerIntent(stateDir: string, input: Omit<OwnerIntent, "schema_version" | "intent_id" | "state">): Promise<OwnerIntent>;
+/** Publish exactly one terminal verdict. Existing valid verdicts always win. */
+export declare function observeOwnerTerminal(request: ObserveTerminalRequest): Promise<OwnerVerdict>;
+/** Strictly validate the persisted authorization, optionally against its terminal observation. */
+export declare function isValidOwnerIntent(intent: unknown, request?: ObserveTerminalRequest): intent is OwnerIntent;
+/** Accept only real UTC timestamps in the canonical evidence serialization. */
+export declare function isCanonicalUtcTimestamp(value: unknown): value is string;
+/** Strictly validate a complete persisted verdict, optionally against its observation. */
+export declare function isValidOwnerVerdict(verdict: unknown, request?: ObserveTerminalRequest): verdict is OwnerVerdict;
+export interface ExactOwnerCloseRequest {
+    stateDir: string;
+    sessionId: string;
+    generation: string;
+    serverKey: string;
+    pid: number;
+    startTime: string;
+    dispatchId: string;
+    createdAt: string;
+    expiresAt: string;
+}
+export interface ExactOwnerCloseDependencies {
+    readStartTime(pid: number): Promise<string | null>;
+    sendSigterm(pid: number): Promise<void>;
+    waitForVerdict(): Promise<OwnerVerdict | null>;
+    cleanupSession(): Promise<void>;
+}
+/** Authorizes only an exact, start-time-validated SIGTERM before compatibility cleanup. */
+export declare function closeExactTmuxOwner(request: ExactOwnerCloseRequest, deps: ExactOwnerCloseDependencies): Promise<OwnerVerdict>;
+export declare function parseOwnerIsolationRequest(line: string): PlanRequest | BootstrapRequest | PublishGenerationRequest | ObserveTerminalRequest | null;
+export declare function serializeOwnerIsolationResponse(response: PlanResponse | BootstrapResult | PublishGenerationResult | OwnerVerdict): string;

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

@@ -1,3 +1,4 @@
+import { type OwnerIsolationProbeSync, type PlanResponse, type TmuxOwnerIsolationExecutionDependencies, type TmuxOwnerIsolationExecutionResult } from "./tmux-owner-isolation";
 export interface GjcTmuxSessionStatus {
     name: string;
     attached: boolean;
@@ -11,6 +12,8 @@ export interface GjcTmuxSessionStatus {
     sessionId?: string;
     sessionStateFile?: string;
     version?: string;
+    ownerGeneration?: string;
+    nativeSessionId?: string;
     panePids: number[];
     profile?: string;
 }
@@ -22,6 +25,8 @@ export interface GjcTmuxSessionTagsForGc {
     sessionId?: string;
     sessionStateFile?: string;
     version?: string;
+    ownerGeneration?: string;
+    nativeSessionId?: string;
     createdAt?: string;
     attached?: boolean;
     panePids?: number[];
@@ -30,6 +35,44 @@ export interface GjcTmuxSessionsForGc {
     tagged: GjcTmuxSessionStatus[];
     untagged: GjcTmuxSessionStatus[];
 }
+export interface ProvenTmuxSessionIdentity {
+    nativeSessionId: string;
+    serverPid: number;
+    serverStartTime: string;
+}
+export interface ExpectedGjcTmuxSessionIdentity {
+    nativeSessionId: string;
+    ownerGeneration: string;
+    sessionId: string;
+    sessionStateFile: string;
+    project: string;
+    createdAt: string;
+}
+export interface ExactOwnerIdentity {
+    sessionId: string;
+    stateDir: string;
+    socketKey: string;
+    generation: string;
+    pid: number;
+    startTime: string;
+}
+export interface ForceCloseOwnerDependencies {
+    resolveOwner(sessionName: string, env: NodeJS.ProcessEnv): Promise<ExactOwnerIdentity>;
+    signalTerm(pid: number): void;
+    readProcessStartTime(pid: number): Promise<string | null>;
+    cleanupSession(sessionTarget: string, env: NodeJS.ProcessEnv): void;
+    now(): Date;
+    sleep(ms: number): Promise<void>;
+    listPanePids(sessionName: string, env: NodeJS.ProcessEnv): number[];
+}
+export type CreateOwnerIsolationTestDependencies = {
+    probe?: Partial<OwnerIsolationProbeSync>;
+    execute?: (plan: PlanResponse, deps: TmuxOwnerIsolationExecutionDependencies) => TmuxOwnerIsolationExecutionResult;
+};
+/** @internal Test-only seam; production create always uses live fail-closed probes. */
+export declare function __setCreateOwnerIsolationForTests(dependencies: CreateOwnerIsolationTestDependencies | null): void;
+/** @internal Test-only seam; production mutations always use live fail-closed proofs. */
+export declare function __setMutationServerProofForTests(dependency: ((tmuxCommand: string, env: NodeJS.ProcessEnv) => unknown) | null): void;
 export declare function listGjcTmuxSessions(env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus[];
 /** @internal */
 export declare function listTmuxSessionsForGc(env?: NodeJS.ProcessEnv): GjcTmuxSessionsForGc;
@@ -38,25 +81,14 @@ export declare function findGjcTmuxSessionByName(sessionName: string, env?: Node
 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;
+/** 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 */
 export declare function readTmuxSessionTagsForGc(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionTagsForGc;
-export declare function removeGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): GjcTmuxSessionStatus;
+export declare function removeGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedIdentity?: ExpectedGjcTmuxSessionIdentity): GjcTmuxSessionStatus;
 /**
- * Force-close a GJC-managed tmux session, even if a live pane is attached.
- *
- * This is the lifecycle-control counterpart to {@link removeGjcTmuxSession}: it
- * intentionally does NOT refuse live/attached panes (hard-kill is the contract),
- * but it keeps every safety check so it can only ever kill a genuinely
- * GJC-managed session:
- * - re-reads the exact tmux profile immediately before kill (never a non-GJC
- *   session, even one that collides by name);
- * - when `expectedSessionId` is given, requires the `@gjc-session-id` tag match;
- * - when `expectedStateFile` is given, requires the `@gjc-session-state-file`
- *   tag match.
- *
- * Returns the prior status (for audit). Throws a tagged error otherwise:
- * `gjc_tmux_session_not_found`, `gjc_tmux_session_not_managed`,
- * `gjc_tmux_session_id_mismatch`, or `gjc_tmux_session_state_file_mismatch`.
+ * Requests an exact tagged owner shutdown. Session cleanup is compatibility-only
+ * and follows a validated SIGTERM verdict; it never authorizes the close.
  */
-export declare function forceCloseGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string): GjcTmuxSessionStatus;
+export declare function forceCloseGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv, expectedSessionId?: string, expectedStateFile?: string, deps?: Partial<ForceCloseOwnerDependencies>): Promise<GjcTmuxSessionStatus>;
 export declare function attachGjcTmuxSession(sessionName: string, env?: NodeJS.ProcessEnv): never;

package/dist/types/internal-urls/local-protocol.d.ts

@@ -17,22 +17,26 @@ export declare class LocalProtocolHandler implements ProtocolHandler {
     readonly scheme = "local";
     readonly immutable = false;
     /**
-     * Install a process-global override that wins over the AgentRegistry-based
-     * derivation. Used by SDK consumers that wire `localProtocolOptions` on
-     * `createAgentSession` and by subagents that share their parent's root.
+     * Install an explicit local-protocol mapping owned by the caller.
+     *
+     * The most recently installed live mapping wins. The returned disposer removes
+     * only this registration and is safe to call more than once.
+     */
+    static installOverride(value: LocalProtocolOptions): () => void;
+    /**
+     * Install a process-global test override that wins over owned and registry
+     * mappings. Prefer {@link installOverride} for lifecycle-bound production use.
      */
     static setOverride(value: LocalProtocolOptions | undefined): void;
-    /** Reset the process-global override. Test-only. */
+    /** Reset all process-global local-protocol overrides. Test-only. */
     static resetOverrideForTests(): void;
     /**
      * Returns the active local-protocol options.
      *
      * Resolution order:
-     * 1. Explicit override installed via {@link setOverride} (used by subagents
-     *    that share their parent's root and by SDK consumers with a custom
-     *    artifacts/session id mapping).
-     * 2. The main session in `AgentRegistry.global()`. Its `SessionManager`
-     *    supplies both `getArtifactsDir` and `getSessionId`.
+     * 1. Direct test override installed via {@link setOverride}.
+     * 2. The most recently installed live owned override.
+     * 3. A live main session in `AgentRegistry.global()`.
      */
     static resolveOptions(): LocalProtocolOptions | undefined;
     resolve(url: InternalUrl): Promise<InternalResource>;

package/dist/types/main.d.ts

@@ -4,15 +4,39 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
+import type { ImageContent } from "@gajae-code/ai";
 import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
+import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import type { SessionSelectionResult } from "./modes/components/session-selector";
 import type { InteractiveMode } from "./modes/interactive-mode";
+import type { PrintModeOptions } from "./modes/print-mode";
+import { initTheme } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
+import type { MCPManager } from "./runtime-mcp";
 import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
-import { SessionManager } from "./session/session-manager";
+import { type ResumeSessionIdentity, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
+import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
+import type { LspStartupServerInfo } from "./tools";
+import type { EventBus } from "./utils/event-bus";
+export type StartupUpdateRoute = "interactive" | "print" | "text" | "json" | "rpc" | "rpc-ui" | "acp" | "bridge";
+export declare function classifyStartupUpdateRoute(parsed: Pick<Args, "print" | "mode">, autoPrint: boolean): StartupUpdateRoute;
+/** Coordinates the non-blocking update check around the interactive UI lifecycle. */
+export declare class StartupUpdateOrchestrator {
+    #private;
+    constructor(route: StartupUpdateRoute, enabled: () => boolean, check: () => Promise<string | undefined>);
+    startBeforeInteractiveInitialization(): void;
+    attachAfterInteractiveInitialization(notify: (version: string) => void): void;
+}
+export interface StartupUpdateInteractiveMode {
+    init: () => Promise<void>;
+    showNewVersionNotification: (version: string) => void;
+}
+export declare function initializeInteractiveModeWithStartupUpdate(mode: StartupUpdateInteractiveMode, startupUpdate: StartupUpdateOrchestrator): Promise<void>;
+declare function readPipedInput(): Promise<string | undefined>;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
@@ -52,6 +76,25 @@ export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof
  * tool registry and shadow the client-supplied servers (issue #1234).
  */
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+interface InteractiveModeFactoryOptions {
+    session: AgentSession;
+    version: string;
+    changelogMarkdown: string | undefined;
+    setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
+    lspServers: LspStartupServerInfo[] | undefined;
+    mcpManager: MCPManager | undefined;
+    eventBus?: EventBus;
+}
+type CreateInteractiveMode = (options: InteractiveModeFactoryOptions) => InteractiveMode;
+type ResumePickerTerminalCheck = () => boolean;
+type ListForResumePickerReadOnly = (cwd: string, sessionDir?: string) => Promise<SessionInfo[]>;
+type SelectResumeSession = (sessions: SessionInfo[]) => Promise<SessionSelectionResult>;
+type OpenExistingSessionStrict = (identity: ResumeSessionIdentity, sessionDir?: string) => Promise<StrictSessionOpenResult>;
+export declare const BARE_RESUME_CONFLICT_ERROR = "--resume without a session cannot be combined with --continue, --fork, or --no-session.";
+export declare const BARE_RESUME_INTERACTIVE_ERROR = "--resume requires an interactive terminal; use --resume <id>.";
+export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
+export declare function runInteractiveMode(session: AgentSession, version: string, changelogMarkdown: string | undefined, notifs: (InteractiveModeNotify | null)[], startupUpdate: StartupUpdateOrchestrator, initialMessages: string[], setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers: LspStartupServerInfo[] | undefined, mcpManager: MCPManager | undefined, eventBus?: EventBus, initialMessage?: string, initialImages?: ImageContent[], createInteractiveMode?: CreateInteractiveMode, resumeAction?: "continue-tail" | "open-idle"): Promise<void>;
+declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
 /**
  * Research-mode (RLM) preset hook. Lets `gjc rlm` augment the session options
@@ -62,13 +105,34 @@ export interface RlmPreset {
     applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
     onSessionCreated?: (session: AgentSession) => void | Promise<void>;
 }
-interface RunRootCommandDependencies {
+type RunRpcMode = (session: AgentSession, setToolUIContext?: CreateAgentSessionResult["setToolUIContext"], options?: {
+    listen?: string;
+}) => Promise<void>;
+type RunBridgeMode = (session: AgentSession, setToolUIContext?: CreateAgentSessionResult["setToolUIContext"]) => Promise<void>;
+type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
+export interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
     runAcpMode?: (createSession: AcpSessionFactory) => Promise<void>;
     settings?: Settings;
     rlmPreset?: RlmPreset;
     suppressProcessExit?: boolean;
+    startupUpdate?: {
+        check: () => Promise<string | undefined>;
+    };
+    initTheme?: typeof initTheme;
+    readPipedInput?: typeof readPipedInput;
+    runStartupCredentialAutoImportIfNeeded?: typeof runStartupCredentialAutoImportIfNeeded;
+    getChangelogForDisplay?: typeof getChangelogForDisplay;
+    runRpcMode?: RunRpcMode;
+    runBridgeMode?: RunBridgeMode;
+    createInteractiveMode?: CreateInteractiveMode;
+    runPrintMode?: RunPrintMode;
+    isResumePickerTerminal?: ResumePickerTerminalCheck;
+    listForResumePickerReadOnly?: ListForResumePickerReadOnly;
+    selectResumeSession?: SelectResumeSession;
+    openExistingSessionStrict?: OpenExistingSessionStrict;
+    initializeSettings?: typeof Settings.init;
 }
 export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
 export declare function main(args: string[]): Promise<void>;

package/dist/types/modes/acp/acp-agent.d.ts

@@ -1,4 +1,4 @@
-import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModelRequest, type SetSessionModelResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
 /**
@@ -40,9 +40,20 @@ export declare class AcpAgent implements Agent {
     resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
     unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
     closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
+    /**
+     * Hard delete an ACP session. `DeleteSessionRequest` carries only `sessionId`;
+     * the server owns authorization through the immutable canonical cwd scope and
+     * the complete strict scoped inventory snapshot.
+     *
+     * - No scope / unknown / already-deleted id → lookup-free `{}`.
+     * - Duplicate/conflict id → visible error; neither transcript nor artifacts change.
+     * - Active session → reserve `deleting`, drain/cancel prompt, flush, strict
+     *   dispose/close, recheck identity/state, then verified artifact-first deletion.
+     * - Concurrent delete callers join the terminal promise.
+     */
+    deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse>;
     setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
     setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
-    unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse>;
     prompt(params: PromptRequest): Promise<PromptResponse>;
     cancel(params: {
         sessionId: string;
@@ -57,5 +68,11 @@ export declare class AcpAgent implements Agent {
     }): Promise<void>;
     get signal(): AbortSignal;
     get closed(): Promise<void>;
+    /**
+     * Connection-local shutdown promise. Resolves once all terminal work (dispose,
+     * active deletes, abort cleanup) has settled. `acp-mode.ts` awaits this after
+     * transport closure so `process.exit` never kills in-flight deletion/disposal.
+     */
+    get shutdownPromise(): Promise<void>;
 }
 export {};

package/dist/types/modes/acp/acp-mode.d.ts

@@ -1,5 +1,17 @@
 import { AgentSideConnection, type Stream } from "@agentclientprotocol/sdk";
 import type { AgentSession } from "../../session/agent-session";
+import { AcpAgent } from "./acp-agent";
 export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
+export interface AcpConnectionHandle {
+    connection: AgentSideConnection;
+    agent: AcpAgent;
+}
 export declare function createAcpConnection(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AgentSideConnection;
+/**
+ * Create an ACP connection and return both the {@link AgentSideConnection} and the
+ * underlying {@link AcpAgent}. Callers that need to await agent shutdown (terminal
+ * delete/dispose work) after transport closure should use this instead of
+ * {@link createAcpConnection}.
+ */
+export declare function createAcpConnectionWithAgent(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AcpConnectionHandle;
 export declare function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never>;

package/dist/types/modes/components/assistant-message.d.ts

@@ -10,7 +10,7 @@ export declare class AssistantMessageComponent extends Container {
     #private;
     private hideThinkingBlock;
     private readonly onImageUpdate?;
-    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined);
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, viewportAnchorId?: string);
     invalidate(): void;
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;

package/dist/types/modes/components/custom-editor.d.ts

@@ -49,6 +49,8 @@ export declare class CustomEditor extends Editor {
     /** Called before regular composer input should return the transcript viewport to the live bottom. */
     onViewportFollowLive?: () => void;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
+    /** Returns whether a built-in editor action consumes this configured key before custom handlers. */
+    hasActionKey(key: KeyId): boolean;
     /**
      * Register a custom key handler. Extensions use this for shortcuts.
      */