@gajae-code/coding-agent 0.17.1 → 0.17.4

package/dist/types/config/model-registry.d.ts

@@ -20,6 +20,12 @@ export type { BillingPath, BillingPathKind } from "./billing-path";
 export type { EffectiveProviderAuth, ProviderSelectionPolicy } from "./provider-selection-policy";
 export type { CanonicalModelIndex, CanonicalModelRecord, CanonicalModelVariant, ModelEquivalenceConfig };
 export { isAuthenticated, kNoAuth };
+/**
+ * Scrub resolved credential material from a discovery failure before it is
+ * published to discovery state, cache provenance, or the logger. Mutates
+ * Error messages and stacks in place to preserve class/identity; wraps non-Errors.
+ */
+export declare function scrubDiscoveryError(error: unknown, secrets: ReadonlyArray<string | undefined>): unknown;
 /**
  * A loopback discovery endpoint that is proven to have no listener is the normal state of
  * a machine without a local model server. Structured transport evidence is required when
@@ -321,6 +327,7 @@ interface ProviderOverride {
     cacheRetention?: CacheRetention;
     isOAuth?: boolean;
 }
+export declare function registrySelectorResolvesToModel(selector: string, models: readonly Model<Api>[]): boolean;
 /**
  * Merge a freshly discovered model with the matching bundled/configured entry
  * (or a runtime provider override when no bundled entry exists).
@@ -406,6 +413,15 @@ export declare class ModelRegistry {
     getAll(): Model<Api>[];
     /** Provider ids declared in models.yml, including override-only providers. */
     getConfiguredProviderIds(): readonly string[];
+    /**
+     * Whether this registry can serve a provider id from any active source.
+     *
+     * Built-in providers are backed by the bundled AI catalog, configured
+     * providers come from models.yml, and extension registrations are retained
+     * in the runtime provider stores below. Runtime model/override state is
+     * included for direct registrations that do not have an extension source id.
+     */
+    isKnownProvider(provider: string): boolean;
     /**
      * Deterministic provider priority for autorouting tier generation: configured
      * `modelProviderOrder` first, then first-wins catalog order.
@@ -514,8 +530,10 @@ export declare class ModelRegistry {
      */
     seedCanonicalVariant(sessionId: string, model: Model<Api>): boolean;
     /**
-     * Get only models that have auth configured.
-     * This is a fast check that doesn't refresh OAuth tokens.
+     * Get selectable models with auth configured.
+     * This is a fast check that doesn't refresh OAuth tokens. A current,
+     * authoritative live catalog also limits each provider to its enrolled ids;
+     * bundled entries remain the fallback until that evidence exists.
      */
     getAvailable(): Model<Api>[];
     /**

package/dist/types/config/settings-schema.d.ts

@@ -157,6 +157,12 @@ export interface ModelTagsSettings {
     [key: string]: ModelTagDef;
 }
 export declare const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[];
+export declare const DEFAULT_SDK_PROMPT_DEADLINE_MS = 3600000;
+export declare const DEFAULT_SDK_PROMPT_MAX_RUNTIME_MS = 21600000;
+/** Resolve a `sdk.promptDeadlineMs` lookup, falling back on any non-finite value. */
+export declare function resolveSdkPromptDeadlineMs(value: unknown): number;
+/** Resolve a `sdk.promptMaxRuntimeMs` lookup, falling back on any non-finite value. */
+export declare function resolveSdkPromptMaxRuntimeMs(value: unknown): number;
 export declare const SETTINGS_SCHEMA: {
     readonly lastChangelogVersion: {
         readonly type: "string";
@@ -219,6 +225,11 @@ export declare const SETTINGS_SCHEMA: {
         readonly description: "Hard maximum runtime for an SDK prompt from acceptance, bounding progress-aware renewals.";
         readonly validate: (value: number) => boolean;
     };
+    readonly "sdk.flushWorktreeOnDeadline": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly description: "Autosave uncommitted changes in the session's linked worktree by default as a WIP commit when a prompt deadline retires a prompt; primary checkouts require an explicit true opt-in.";
+    };
     readonly "sdk.masterOrphanGraceMs": {
         readonly type: "number";
         readonly default: 120000;

package/dist/types/coordinator-mcp/question-state.d.ts

@@ -454,7 +454,12 @@ export declare function readSchedulerRoster(paths: CoordinatorStatePaths, option
 export declare function advanceSchedulerCursor(paths: CoordinatorStatePaths, cursor: string, options?: {
     signal?: AbortSignal;
 }): Promise<void>;
-export declare function readSessionTransaction(paths: CoordinatorStatePaths, sessionId: string): Promise<CoordinatorSessionTransactionV1 | null>;
+export declare function readSessionTransaction(paths: CoordinatorStatePaths, sessionId: string, options?: {
+    signal?: AbortSignal;
+}): Promise<CoordinatorSessionTransactionV1 | null>;
+export declare function repairLegacyReportIds(paths: CoordinatorStatePaths, sessionId: string, options?: {
+    signal?: AbortSignal;
+}): Promise<CoordinatorSessionTransactionV1 | null>;
 export declare function withSessionTransaction<T>(paths: CoordinatorStatePaths, sessionId: string, operation: (transaction: CoordinatorSessionTransactionV1) => Promise<T>, options?: {
     signal?: AbortSignal;
 }): Promise<T>;

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

@@ -62,6 +62,9 @@ interface CoordinatorServices {
     canonicalizePath?: (value: string) => Promise<string>;
     codexTransportFactory?: CodexTransportFactory;
     eventWebhookDelivery?: WebhookDelivery;
+    /** Observable transitions for consumers coordinating with the filesystem-backed event wait. */
+    onCoordinatorEventWatchReady?: () => void;
+    onCoordinatorEventWake?: () => void;
     /** Test barrier invoked after an accepted prompt receipt is durable and before turn finalization. */
     afterPromptReceiptPersisted?: (sessionId: string) => void | Promise<void>;
     /** Test barrier invoked after an answer dispatch is claimed and before its final admission check. */

package/dist/types/daemon/operator-contract.d.ts

@@ -24,11 +24,15 @@ export declare const DAEMON_ACTION_ALIASES: Readonly<Record<string, DaemonAction
 export declare const DAEMON_ACTION_TOKENS: readonly string[];
 /** Resolve a leading verb (canonical or alias) to its canonical action. */
 export declare function resolveDaemonAction(token: string | undefined): DaemonAction | undefined;
-/** Exit codes for `gjc daemon`. Backward compatible: success 0, any failure 1. */
+/** Public input failures exit 2; operational failures retain exit 1. */
 export declare const DAEMON_EXIT: {
     readonly ok: 0;
     readonly failure: 1;
+    readonly usage: 2;
 };
+/** A refused result may follow a successful stop or spawn; snapshots and prose
+ * do not prove that no effect occurred. Only completed results prove applied. */
+export declare function daemonOperationOutcome(result: DaemonOperationResult): "applied" | "unknown";
 /** Human-facing headline when a spawn/reload is refused by a live foreign identity. */
 export declare const OWNERSHIP_MISMATCH_MESSAGE = "refused: a live Telegram daemon with a different bot token or chat already owns this workspace";
 /** Structured, actionable recovery for a token/chat ownership mismatch. */

package/dist/types/eval/js/worker-protocol.d.ts

@@ -10,6 +10,8 @@ export interface RunErrorPayload {
     stack?: string;
     isAbort?: boolean;
     isToolError?: boolean;
+    /** Set only when the originating error carried the trusted designed marker. */
+    isDesigned?: boolean;
 }
 export type ToolReply = {
     ok: true;

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

@@ -31,6 +31,7 @@ import type { AgentSessionEventListener } from "../../session/agent-session";
 import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
 import type { CustomMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
+import type { SessionWorkLease } from "../../session/session-work-lease";
 import type { BashToolDetails, BashToolInput, FindToolDetails, FindToolInput, ReadToolDetails, ReadToolInput, SearchToolDetails, SearchToolInput, WriteToolInput } from "../../tools";
 import type { EventBus } from "../../utils/event-bus";
 import type { AgentEndEvent, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryEndEvent, AutoRetryStartEvent, ContextEvent, GoalUpdatedEvent, SessionBeforeBranchEvent, SessionBeforeBranchResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionBranchEvent, SessionCompactEvent, SessionCompactingEvent, SessionCompactingResult, SessionEvent, SessionShutdownEvent, SessionStartEvent, SessionSwitchEvent, SessionTreeEvent, AgentStartEvent as SharedAgentStartEvent, TodoReminderEvent, ToolCallEventResult, ToolResultEventResult, TtsrTriggeredEvent, TurnEndEvent, TurnStartEvent } from "../shared-events";
@@ -279,6 +280,8 @@ export interface ExtensionContext {
     isIdle(): boolean;
     /** Stable resource ownership identifier for the active prompt run. */
     getActivePromptHandle(): string | undefined;
+    /** The session's authoritative host-liveness lease. */
+    getSessionWorkLease?(): SessionWorkLease | undefined;
     /** Abort the current agent operation */
     abort(): void | Promise<void>;
     /** Abort and prove whether resources for a specific prompt settled. */
@@ -1044,6 +1047,13 @@ export type SendUserMessageHandler = (content: string | (TextContent | ImageCont
         startsOwnRun?: boolean;
         removed?: boolean;
     }) => void;
+    /**
+     * Fired synchronously when a plain prompt's dispatch resolves at queue
+     * time instead of run end (diverted into an in-flight run's steering).
+     */
+    onDispatchDisposition?: (promotion: {
+        startsOwnRun: boolean;
+    }) => void;
     preflightSignal?: AbortSignal;
 }) => void | Promise<void>;
 export type AppendEntryHandler = <T = unknown>(customType: string, data?: T) => void;
@@ -1111,6 +1121,8 @@ export interface ExtensionContextActions {
     isIdle: () => boolean;
     /** Stable resource ownership identifier for the active prompt run. */
     getActivePromptHandle?: () => string | undefined;
+    /** The session's authoritative host-liveness lease. */
+    getSessionWorkLease?: () => SessionWorkLease | undefined;
     abort: () => void | Promise<void>;
     abortPromptAndWait?: (handle: string, options: {
         graceMs: number;

package/dist/types/extensibility/gjc-plugins/registry.d.ts

@@ -1,4 +1,8 @@
 import { type GjcPluginRegistry, type GjcPluginRegistryEntry, type GjcPluginScope } from "./types";
+export declare const RegistryLockTestHooks: {
+    beforeEviction?: (lockPath: string, raw: string) => void | Promise<void>;
+    beforePublish?: (stagingPath: string, lockPath: string) => void | Promise<void>;
+};
 export declare function registryRootForScope(scope: GjcPluginScope, cwd: string): string;
 export declare function registryPathForScope(scope: GjcPluginScope, cwd: string): string;
 /**

package/dist/types/extensibility/runtime-skill-discovery.d.ts

@@ -23,6 +23,16 @@ export interface RuntimeSkillDiscoveryResult {
     candidates: RuntimeSkillDiscoveryCandidate[];
     /** Deduped skill metadata the query filter ran against, including bundled entries; candidates.length <= scanned. */
     scanned: number;
+    /**
+     * Skills left after the query filter, before the page slice: the denominator
+     * a page is a page *of*. `scanned` counts everything the filter ran against,
+     * so it cannot serve this role.
+     */
+    matching: number;
+    /** Normalized zero-based offset the returned page starts at. */
+    offset: number;
+    /** Offset of the next page, present only while one exists; omitted on the final page. */
+    nextOffset?: number;
     diagnostics: RuntimeSkillDiscoveryDiagnostics;
 }
 export interface DiscoverRuntimeSkillsOptions {
@@ -33,9 +43,17 @@ export interface DiscoverRuntimeSkillsOptions {
     profileAuthority?: "default" | "custom";
     query?: string;
     limit?: number;
+    /** Zero-based index into the matching set the returned page starts at; defaults to 0. */
+    offset?: number;
     source?: RuntimeSkillDiscoveryScope | "all";
     policy?: SkillsSettings;
 }
+/**
+ * Upper bound every caller's `limit` clamps to. Exported so `gjc skills discover`
+ * can default a human to the widest page the library will serve instead of the
+ * model-context-sized `DEFAULT_LIMIT`.
+ */
+export declare const SKILL_DISCOVERY_MAX_LIMIT = 50;
 /**
  * Explain an empty result that is caused by disabled discovery config rather
  * than by an actually empty skill catalog. Uses the user-facing trust

package/dist/types/extensibility/shared-events.d.ts

@@ -81,9 +81,11 @@ export interface SessionCompactEvent {
     /** Whether the compaction entry was provided by an extension/hook */
     fromExtension: boolean;
 }
-/** Fired on process exit (SIGINT/SIGTERM) */
+/** Fired during session teardown, including process exit and SDK host self-reap. */
 export interface SessionShutdownEvent {
     type: "session_shutdown";
+    /** Set only when the SDK host reaped itself after detached-idle grace. */
+    reason?: "detached_idle";
 }
 /** Preparation data for tree navigation (used by session_before_tree event) */
 export interface TreePreparation {

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

@@ -1,3 +1,4 @@
+import { type LinuxProcPidProbeResult } from "./linux-proc";
 /**
  * How a `<file>.lock` owner record can be opened safely on this platform.
  *
@@ -43,6 +44,13 @@ export declare const SessionStateLockTestHooks: {
      * configuration.
      */
     probeProcessSignal?: (pid: number) => void;
+    /**
+     * @internal How an owner pid's `/proc` entry is read. Whether a killed pid is still an
+     * unreaped zombie depends on when its parent happens to reap it, so it cannot be
+     * arranged deterministically from a test. Production code never sets it, and it is
+     * never serialized or exposed as runtime configuration.
+     */
+    probeLinuxProcPid?: (pid: number) => LinuxProcPidProbeResult;
     /**
      * @internal Runs inside a NEW owner record's write, after the exclusive create has
      * taken the pathname and before the record's bytes land. Throwing from it fails that
@@ -90,6 +98,32 @@ export declare const SessionStateLockTestHooks: {
 };
 /** Raised when the lock could not be acquired; callers map it to their own refusal. */
 export type SessionStateLockUnavailableReason = "acquire_timeout" | "legacy_directory_owner_unprovenanced" | "lock_initialization_failed" | "lock_inspection_failed" | "lock_owner_live_or_unverifiable" | "lock_owner_record_fresh" | "lock_owner_record_unprovenanced" | "lock_release_failed" | "transition_claim_timeout" | "unsafe_lock_path_type";
+/**
+ * Why a stale-transition reclaim refused, as a bounded classifier.
+ *
+ * `transition_claim_timeout` collapsed several structurally different refusals into
+ * one message, so an operator could not tell a foreign-host tombstone from a
+ * live owner from a directory an external process was stamping — the gap #5606
+ * asked for. Every member is a fixed enum: never a path, token, host id, pid or
+ * raw errno, because this rides on an error message users paste into reports.
+ */
+export type TransitionReclaimRefusal = 
+/** The claim vanished, or its owner sidecar was absent/unparseable/invalid. */
+"claim_or_owner_unreadable"
+/** A released tombstone carrying no `owner_host_id` at all. */
+ | "released_owner_unprovenanced"
+/** A released tombstone belonging to a different installation. */
+ | "released_owner_foreign_host"
+/** A released tombstone still inside `RELEASED_TRANSITION_GRACE_MS`. */
+ | "released_owner_within_grace"
+/** The owner is alive, or its liveness could not be disproven. */
+ | "owner_live_or_unverifiable"
+/** The claim changed between inspection and capture — an external writer. */
+ | "claim_generation_changed"
+/** The claim was not empty when captured, so it is not ours to remove. */
+ | "claim_not_empty"
+/** The claim's canonical path or directory snapshot could not be taken. */
+ | "claim_capture_failed";
 interface SessionStateLockUnavailableDetails {
     lockPath: string;
     reason: SessionStateLockUnavailableReason;
@@ -170,6 +204,33 @@ export declare function setSessionStateLockNativeBindings(load: SessionStateLock
  * and deletion has a different inode identity and is refused by construction.
  */
 export declare function removeVerifiedEmptyQuarantine(directory: string, name: string): Promise<void>;
+/**
+ * Outcome of one stale-transition reclaim attempt. `reclaimed` drives the
+ * caller's retry accounting exactly as the previous boolean did; `refusal`
+ * exists only so the eventual `transition_claim_timeout` can name which
+ * precondition said no (#5606).
+ */
+interface TransitionReclaimOutcome {
+    reclaimed: boolean;
+    reclaimReason?: "released_handoff" | "dead_owner";
+    refusal?: TransitionReclaimRefusal;
+}
+/**
+ * Classify one stale-transition reclaim attempt.
+ *
+ * @internal exported as the seam the refusal classifier is tested through. Driving
+ * a real `transition_claim_timeout` would mean waiting out `LOCK_ACQUIRE_MAX_WAIT_MS`
+ * (60s) per case, and `tryWithSessionStateFileLock` throws BUSY before the timeout
+ * is ever built, so the per-branch reasons have no other reachable surface (#5606).
+ */
+export declare function classifyTransitionReclaimForTests(transitionDir: string, quarantineName: string): Promise<TransitionReclaimOutcome>;
+/**
+ * Build the timeout error exactly as the transition loop does.
+ *
+ * @internal exported so the message contract — a bounded enum suffix and nothing
+ * else — is pinned without a 60s wait (#5606).
+ */
+export declare function transitionClaimTimeoutForTests(transitionDir: string, refusal: TransitionReclaimRefusal | undefined): SessionStateLockUnavailableError;
 export declare function reclaimStaleSessionStateLock(lockFile: string, quarantineName?: string): Promise<void>;
 /**
  * Serialize one read-modify-write of `stateFile` against every other holder of

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

@@ -0,0 +1,9 @@
+import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
+/**
+ * Handler for `embedded:` URLs.
+ */
+export declare class EmbeddedProtocolHandler implements ProtocolHandler {
+    readonly scheme = "embedded";
+    readonly immutable = true;
+    resolve(url: InternalUrl): Promise<InternalResource>;
+}

package/dist/types/internal-urls/index.d.ts

@@ -9,6 +9,7 @@
  */
 export * from "./agent-protocol";
 export * from "./artifact-protocol";
+export * from "./embedded-protocol";
 export * from "./gjc-protocol";
 export * from "./issue-pr-protocol";
 export * from "./json-query";

package/dist/types/internal-urls/parse.d.ts

@@ -10,10 +10,18 @@
  * MUST use this function instead of calling `new URL()` directly.
  */
 import type { InternalUrl } from "./types";
+/**
+ * Canonicalize an internal URL so slashless schemes carry an authority.
+ *
+ * Every entry point that inspects or routes an internal URL (router,
+ * read/write tools, selector splitting) MUST normalize first, so handlers only
+ * ever see the `scheme://authority/path` form.
+ */
+export declare function normalizeInternalUrlInput(input: string): string;
 /**
  * Parse an internal URL into an InternalUrl.
  *
  * Handles URLs where `new URL()` would fail (e.g., `skill://plugin:name`
  * where the colon is not a port separator).
  */
-export declare function parseInternalUrl(input: string): InternalUrl;
+export declare function parseInternalUrl(rawInput: string): InternalUrl;

package/dist/types/main.d.ts

@@ -5,6 +5,7 @@
  * createAgentSession() options. The SDK does the heavy lifting.
  */
 import type { ImageContent } from "@gajae-code/ai/core";
+import { postmortem } from "@gajae-code/utils";
 import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
@@ -17,6 +18,8 @@ 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 { processIncarnation } from "./sdk/broker/process-incarnation";
+import { SessionIndex } from "./sdk/broker/session-index";
 import type { AgentSession } from "./session/agent-session";
 import { type ResumeSessionIdentity, type SessionDestination, type SessionDirectoryMigrationPolicy, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
 import { resolveStartupAuthConfig } from "./session/startup-auth-config";
@@ -117,6 +120,7 @@ export declare class SessionNotFoundError extends Error {
     get sessionId(): string;
 }
 export declare function operatorFacingSessionOpenMessage(value: unknown): string | undefined;
+export declare function shouldNotifyModelFallback(authBootstrap: boolean | undefined, isInteractive: boolean): boolean;
 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", startDeferredMcpConfig?: CreateAgentSessionResult["startDeferredMcpConfig"], startDeferredModelProfiles?: DeferredModelProfileStartup, options?: {
     stopAfterFirstPaint?: boolean;
 }): Promise<void>;
@@ -153,6 +157,24 @@ export interface RunRootCommandDependencies {
     initializeSettings?: typeof Settings.init;
     loadSettingsForScope?: typeof Settings.loadForScope;
 }
+type DirectSessionManager = Pick<SessionManager, "getCwd" | "getSessionFile" | "getSessionId">;
+/**
+ * Direct CLI liveness is meaningful only for sessions with a durable transcript.
+ * An in-memory manager has no artifacts for GC to fence and must not touch the
+ * shared SDK session-index lock.
+ */
+export declare function directSessionRegistrationId(sessionManager: DirectSessionManager | undefined, lifecycleRequestId: string | undefined): string | undefined;
+interface DirectSessionRegistrationDependencies {
+    createIndex?: (agentDir: string) => SessionIndex;
+    processIncarnation?: typeof processIncarnation;
+    registerPostmortem?: typeof postmortem.register;
+    masterRole?: {
+        ownerSessionId: string;
+        attestationEpoch: string;
+    };
+}
+/** Register a durable direct CLI session while leaving ephemeral sessions lock-free. */
+export declare function registerDirectSession(sessionManager: DirectSessionManager | undefined, agentDir: string, lifecycleRequestId: string | undefined, dependencies?: DirectSessionRegistrationDependencies): Promise<void>;
 export interface ModelRoleOverrides {
     smol?: string;
     slow?: string;

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

@@ -1,5 +1,6 @@
 import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type AvailableCommand, type CancelNotification, 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 AcpProviderRegistration, type AcpReverseConnection, AcpSdkAdapter } from "../../sdk/acp";
+import { type AcpProviderRegistration, type AcpReverseConnection, AcpSdkAdapter, AcpSdkAdapterError } from "../../sdk/acp";
+import type { SdkPromptFailureCategory, SdkPromptFailurePhase, SdkPromptTerminalOutcome } from "../../sdk/prompt-status";
 import { type PromptWatchdogClock } from "../../sdk/prompt-watchdog";
 import type { AcpStartupOptions } from "./startup-options";
 /**
@@ -43,6 +44,98 @@ export declare function paginateAcpSessions(listed: unknown[], cwd: string | und
 }>): ListSessionsResponse;
 /** Build the ACP command palette from the shared builtins and live SDK skill state. */
 export declare function acpAvailableCommandsFromSkills(query: unknown): AvailableCommand[];
+type SdkPromptFailedOutcome = Extract<SdkPromptTerminalOutcome, {
+    kind: "failed";
+}>;
+/**
+ * A prompt rejection that still carries the terminal's structured failure classification.
+ * The ACP client sees only the code and message, but the first-turn retry gate must decide on
+ * what the terminal actually proved — the failure's execution phase and its bounded origin
+ * category — so settlement carries that classification instead of discarding it into a bare
+ * `AcpSdkAdapterError` (review P1, issue #5574).
+ */
+export declare class AcpPromptFailureError extends AcpSdkAdapterError {
+    readonly failure: SdkPromptFailedOutcome;
+    constructor(failure: SdkPromptFailedOutcome);
+}
+/**
+ * The wire projection of a prompt terminal's classification (issue #5615).
+ *
+ * `super(failure.code, failure.message)` above narrows the error to the generic
+ * `prompt_failed` plus its fixed redacted message, so the classification the
+ * terminal already computed used to die at the JSON-RPC boundary: an ACP client
+ * saw only `-32603 {code, details}` and could not tell a transient provider blip
+ * from a dead session without parsing English. These fields carry it across.
+ *
+ * `providerCode` is re-checked against the safe-token rule rather than trusted:
+ * `terminalOutcome` accepts the host's `providerCode` on a `typeof` check alone,
+ * and this is the first path that puts it on the wire, so an unbounded value is
+ * dropped instead of becoming a leak of provider text (the redaction contract in
+ * `sanitizePromptFailure`). A dropped or absent code is omitted, never nulled.
+ */
+export declare const OPERATOR_UPSTREAM_LABEL = "Upstream provider failure";
+export declare const OPERATOR_UPSTREAM_SUFFIX = ": the model provider ended this turn.";
+/**
+ * `post_start` proves execution began, so tools may already have run and had effects before the
+ * provider died. The wording therefore qualifies the turn rather than absolving the task: saying
+ * the task was unaffected would assert something the bounded classifiers do not establish.
+ */
+export declare const OPERATOR_PARTIAL_WORK_NOTE = " Work this turn had already performed may have taken effect; check before retrying.";
+/**
+ * Operator-facing wording for a post-start terminal, assembled ONLY from bounded safe tokens: the
+ * classifier `phase`, the `category`, and a `providerCode` that passes `isSafePromptFailureCode`.
+ * Raw provider text never reaches this function and must never reach it.
+ *
+ * Gated on BOTH `phase === "post_start"` and `category === "provider_transport"`. A submission-phase
+ * provider failure is rejected by the phase gate: nothing executed, so wording about a turn the
+ * provider ended would describe an event that never occurred.
+ *
+ * It claims only what those tokens prove — that the upstream provider ended the turn — and says
+ * nothing about whether the operator's work survived. `post_start` proves execution began, so the
+ * wording qualifies that earlier work may already have taken effect instead of absolving the task.
+ *
+ * This is additive. The wire `code`/`details` pair and every `PROMPT_FAILURE_MESSAGE_*` constant
+ * stay exactly as they are — pinned ACP core-v1 conformance asserts on them — so this wording
+ * travels alongside the redacted message instead of repurposing it.
+ *
+ * It says NOTHING about the worktree, deliberately. Nothing on this path inspects the worktree, so
+ * any sentence about uncommitted work would assert a check that never ran — reporting an
+ * uninspected tree as clean is the absence-of-evidence-as-evidence-of-absence error, and an
+ * operator who believed it would sweep work away. Silence is the only honest option until something
+ * actually looks.
+ *
+ * Returns `undefined` for every other category: `phase` and `category` are already on the wire, so
+ * restating them in prose tells an operator nothing they do not already have.
+ */
+export declare function postStartOperatorMessage(input: {
+    phase: SdkPromptFailurePhase;
+    category: SdkPromptFailureCategory;
+    providerCode?: string;
+}): string | undefined;
+/**
+ * What an ACP `plan` update said the turn intended to do. Structural rather than the SDK's
+ * `PlanEntry` so only the fields this evidence reads are depended on.
+ */
+type AcpPlanSnapshot = Array<{
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    _meta?: {
+        gjcTodoStatus?: unknown;
+    } | null;
+}>;
+/**
+ * An abandoned prompt that still carries the plan its turn was working through (issue #5669).
+ *
+ * The watchdog settles a prompt whose host stopped producing frames, and that rejection used to
+ * be a bare `AcpSdkAdapterError`: `{code, details}` and nothing else. A wrapper could not tell
+ * "the agent finished" from "the agent stopped with work left", so an abandoned turn's unverified
+ * diff was published as if it were complete. The last observed plan is the evidence that settles
+ * that question, so settlement carries it instead of dropping it at the JSON-RPC boundary.
+ */
+export declare class AcpPromptAbandonedError extends AcpSdkAdapterError {
+    readonly plan: AcpPlanSnapshot | undefined;
+    constructor(code: string, message: string, plan: AcpPlanSnapshot | undefined);
+}
 export type TranscriptReplayBlock = {
     type: "text";
     text: string;

package/dist/types/modes/acp/startup-provenance.d.ts

@@ -0,0 +1,16 @@
+type JsonObject = Record<string, unknown>;
+export type PrimaryControlSurface = "cli" | "sdk";
+/**
+ * Startup-control provenance is the authority record ACP needs before it may take
+ * permission, provider, and lifecycle ownership of a session. Hosts serving that
+ * record report capabilities carrying `promptTerminalOutcomeVersion`
+ * and `primaryControlSurface`; a host that predates the record reports neither, and a
+ * host that cannot answer at all reports nothing. Those are three different operator
+ * problems, so they get three different messages instead of one "restart the session".
+ */
+export declare function resolveStartupProvenance(input: {
+    sessionId: string;
+    capabilities: JsonObject | undefined;
+    queryFailure: unknown;
+}): PrimaryControlSurface;
+export {};

package/dist/types/modes/components/custom-provider-wizard.d.ts

@@ -2,10 +2,28 @@ import { Container } from "@gajae-code/tui";
 import type { ProviderSetupInput } from "../../setup/provider-onboarding";
 export type CustomProviderCredentialSource = "env" | "literal";
 export type CustomProviderWizardSubmit = ProviderSetupInput;
+export interface CustomProviderWizardDiscoveryDeps {
+    discoverModels?: (input: {
+        baseUrl: string;
+        apiKeyEnv?: string;
+        apiKey?: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        models: string[];
+    }>;
+}
 export declare class CustomProviderWizardComponent extends Container {
     #private;
-    constructor(onSubmit: (input: CustomProviderWizardSubmit) => void, onCancel: () => void, onRender?: () => void);
+    constructor(onSubmit: (input: CustomProviderWizardSubmit) => void, onCancel: () => void, onRender?: () => void, discoveryDeps?: CustomProviderWizardDiscoveryDeps);
     setSubmitError(error: string): void;
     handleInput(keyData: string): void;
     complete(): void;
+    /** Generation token for the latest submit attempt. */
+    currentSubmitGeneration(): number;
+    /**
+     * Whether a submit attempt is still current: same generation and not
+     * dismissed. Revision or cancel invalidates pending completions so a
+     * stale refresh cannot report success or rerender over new inputs.
+     */
+    isSubmitCurrent(generation: number): boolean;
 }

package/dist/types/modes/components/session-selector.d.ts

@@ -19,14 +19,16 @@ declare class SessionList implements Component {
     onCancel?: () => void;
     onExit: () => void;
     onDeleteRequest?: (session: SessionInfo) => void;
+    onToggleStarRequest?: (session: SessionInfo) => void;
     constructor(allSessions: SessionInfo[], showCwd?: boolean);
     setInputFrozen(frozen: boolean): void;
     removeSession(sessionPath: string): void;
+    setSessionStarred(sessionPath: string, starred: boolean): void;
     invalidate(): void;
     render(width: number): string[];
     handleInput(keyData: string): void;
 }
-/** A one-shot resume consent selector. It never opens or mutates sessions. */
+/** A one-shot resume consent selector with host-owned deletion and star persistence. */
 export declare class SessionSelectorComponent extends Container {
     #private;
     private readonly onSelect;
@@ -35,7 +37,8 @@ export declare class SessionSelectorComponent extends Container {
     private readonly onDelete?;
     private readonly inspector?;
     private readonly onSelection?;
-    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void | Promise<void>, onCancel: () => void, onExit: () => void, onDelete?: ((session: SessionInfo) => Promise<boolean>) | undefined, inspector?: SessionInspector | undefined, onSelection?: ((selection: SessionSelectionResult) => void) | undefined);
+    private readonly onSetStarred?;
+    constructor(sessions: SessionInfo[], onSelect: (sessionPath: string) => void | Promise<void>, onCancel: () => void, onExit: () => void, onDelete?: ((session: SessionInfo) => Promise<boolean>) | undefined, inspector?: SessionInspector | undefined, onSelection?: ((selection: SessionSelectionResult) => void) | undefined, onSetStarred?: ((session: SessionInfo, starred: boolean) => Promise<void>) | undefined);
     setOnRequestRender(callback: () => void): void;
     handleInput(keyData: string): void;
     getSessionList(): SessionList;

package/dist/types/modes/components/thinking-selector.d.ts

@@ -1,4 +1,5 @@
 import { type ThinkingLevel as ThinkingLevelValue } from "@gajae-code/agent-core";
+import type { Model } from "@gajae-code/ai/types";
 import { Container, SelectList } from "@gajae-code/tui";
 export interface ThinkingSelectorSelection {
     level: ThinkingLevelValue;
@@ -9,7 +10,7 @@ export interface ThinkingSelectorSelection {
  */
 export declare class ThinkingSelectorComponent extends Container {
     #private;
-    constructor(currentLevel: ThinkingLevelValue | undefined, availableLevels: ThinkingLevelValue[], onSelect: (selection: ThinkingSelectorSelection) => void, onCancel: () => void);
+    constructor(currentLevel: ThinkingLevelValue | undefined, availableLevels: ThinkingLevelValue[], onSelect: (selection: ThinkingSelectorSelection) => void, onCancel: () => void, model?: Model);
     handleInput(data: string): void;
     getSelectList(): SelectList;
 }

package/dist/types/modes/components/user-message-selector.d.ts

@@ -13,16 +13,19 @@ declare class UserMessageList implements Component {
     onSelect?: (entryId: string) => void;
     onCancel?: () => void;
     constructor(messages: UserMessageItem[]);
+    setAvailableRows(rows: number): void;
     invalidate(): void;
     render(width: number): string[];
     handleInput(keyData: string): void;
 }
 /**
- * Component that renders a user message selector for branching
+ * Component that renders a prompt selector for creating a new session
  */
 export declare class UserMessageSelectorComponent extends Container {
     #private;
-    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void);
+    private readonly getViewportRows;
+    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void, getViewportRows: () => number);
+    render(width: number): string[];
     getMessageList(): UserMessageList;
 }
 export {};

package/dist/types/modes/controllers/command-controller.d.ts

@@ -30,7 +30,7 @@ export declare class CommandController {
     handleDropCommand(): Promise<boolean>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
-    handleRenameCommand(title: string): Promise<void>;
+    handleRenameCommand(title?: string): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;