@gajae-code/coding-agent 0.11.1 → 0.11.2

package/dist/types/sdk/bus/telegram-daemon.d.ts

@@ -18,6 +18,11 @@ export interface DaemonState {
     startedAt: number;
     heartbeatAt: number;
     roots: string[];
+    /**
+     * Present only for the Windows source-launch handoff. `pid` starts as this
+     * short-lived launcher PID and may be rebound exactly once to the daemon PID.
+     */
+    launcherPid?: number;
     version: 1;
     /**
      * Operational daemon generation of the process that owns the lock, distinct
@@ -55,6 +60,8 @@ export interface TelegramDaemonDeps {
         logPath?: string;
     }) => SpawnResult;
     execPath?: string;
+    /** Injectable platform seam for source-linked Windows daemon spawning. */
+    platform?: NodeJS.Platform;
     randomId?: () => string;
     /**
      * Signal delivery + poll timing for the stale-generation reload handoff in
@@ -73,6 +80,11 @@ export declare const CLIENT_PING_PONG_CAPABILITY = "client_ping_pong";
 /** Capability required for typed controls and semantic Selected acknowledgement frames. */
 export declare const ASK_SELECTED_ACK_CAPABILITY = "ask_selected_ack_v1";
 export declare const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
+/** Capability required for tool lifecycle and reasoning-summary frames. */
+export declare const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
+export declare const BTW_QUESTION_MAX_UNICODE_SCALARS = 4096;
+export declare const BTW_QUESTION_MAX_UTF8_BYTES = 16384;
+export declare function endpointAuthorityDigest(url: string, token: string, connectionIdentity?: string): string;
 export { type DaemonPaths, daemonPaths } from "./daemon-paths";
 export declare function deriveLifecycleAuditRedactionKey(botToken: string): Uint8Array;
 /**
@@ -126,6 +138,10 @@ export declare function acquireDaemonOwnership(input: {
     pid?: number;
     pidAlive?: (pid: number) => boolean;
     randomId?: () => string;
+    /** Permit one Windows source launcher PID to daemon PID handoff. */
+    allowPidRebind?: boolean;
+    /** A caller-supplied opaque owner identity, used when the launcher PID is not durable. */
+    ownerId?: string;
 }): Promise<{
     acquired: boolean;
     ownerId?: string;
@@ -137,13 +153,22 @@ export declare function acquireDaemonOwnership(input: {
 export declare function renewDaemonHeartbeat(input: {
     settings: Settings;
     ownerId: string;
+    /** Bind a daemon heartbeat to the Telegram identity that acquired the lock. */
+    tokenFingerprint: string;
+    chatId: string;
+    /** Require the current daemon PID after the launcher-to-daemon PID rebind. */
+    pid: number;
     fs?: TelegramDaemonFs;
     now?: () => number;
-    pid?: number;
 }): Promise<boolean>;
 export declare function releaseDaemonOwnership(input: {
     settings: Settings;
     ownerId: string;
+    /** Bind release to the Telegram identity that acquired the lock. */
+    tokenFingerprint: string;
+    chatId: string;
+    /** Require the current daemon PID after the launcher-to-daemon PID rebind. */
+    pid: number;
     fs?: TelegramDaemonFs;
     now?: () => number;
 }): Promise<void>;
@@ -298,6 +323,9 @@ export interface TelegramDaemonOptions {
     clearTimeoutImpl?: typeof clearTimeout;
     setIntervalImpl?: typeof setInterval;
     clearIntervalImpl?: typeof clearInterval;
+    btw?: {
+        enabled: boolean;
+    };
     idleTimeoutMs?: number;
     scanIntervalMs?: number;
     pid?: number;
@@ -346,6 +374,8 @@ interface SessionSocket {
     logicalSessionId: string;
     token: string;
     endpointKey: string;
+    endpointDigest: string;
+    hostGeneration: number;
     ws: WebSocket;
     pending: Map<string, {
         sessionId: string;
@@ -353,6 +383,7 @@ interface SessionSocket {
     }>;
     /** True once the server advertised the `client_ping_pong` capability. */
     capable: boolean;
+    ephemeralCapable: boolean;
     /** Timestamp (via opts.now) of the last received pong; seeds the TTL window. */
     lastPongAt: number;
     /** Nonce of the most recent in-flight ping, if any. */
@@ -380,6 +411,7 @@ export declare class TelegramNotificationDaemon {
     private running;
     private readonly fsImpl;
     private readonly botApi;
+    private readonly effects;
     private readonly topics;
     /** Serializes registry snapshots so an older atomic write cannot overwrite newer rename state. */
     private topicsPersistQueue;
@@ -476,7 +508,7 @@ export declare class TelegramNotificationDaemon {
     persistSeenUpdateIds(): Promise<void>;
     private pruneSeenUpdateIds;
     private rememberSeenUpdateId;
-    private rememberSeenUpdateIdForUnavailableNotice;
+    private reserveSeenUpdateId;
     scanRoots(): Promise<void>;
     connectSession(sessionId: string, url: string, token: string): void;
     /**
@@ -513,6 +545,9 @@ export declare class TelegramNotificationDaemon {
     private sessionCanClaimIdentity;
     private submitThreadedFrame;
     private existingTopicForPrivateChat;
+    private topicAuthorityLease;
+    private topicAuthorityLeaseFromRegistry;
+    private topicLeaseIsCurrent;
     /** Best-effort re-assertion for a durable user-owned topic name. */
     private reconcileUserTopicName;
     private rememberPendingThreadedFrame;
@@ -525,7 +560,7 @@ export declare class TelegramNotificationDaemon {
      */
     private ensureTopic;
     private topicPastOrphanGrace;
-    private deleteOrphanedTopic;
+    private observeOrphanedTopic;
     /** Best-effort delete of a session topic once its local notification endpoint shuts down. */
     private deleteTopic;
     private persistTopics;
@@ -563,6 +598,7 @@ export declare class TelegramNotificationDaemon {
     private flushChain;
     private flushPool;
     /** Drain the shared rate-limit pool and deliver each granted send to its topic. */
+    private submitPool;
     private flushPoolInner;
     /**
      * Track the Telegram message id backing a streamed `(sessionId, coalesceKey)`
@@ -593,6 +629,13 @@ export declare class TelegramNotificationDaemon {
     private notifyThreadedFallback;
     private startFlushTimer;
     private stopFlushTimer;
+    private renewOwnershipHeartbeat;
+    /**
+     * Ownership must be renewed independently of Telegram's 25-second long poll:
+     * the ownership TTL is shorter than a single poll request.
+     */
+    private startOwnershipHeartbeatTimer;
+    private stopOwnershipHeartbeatTimer;
     /** Run a root scan, guarding against overlapping scans from the timer + loop. */
     private runScan;
     private startScanTimer;

package/dist/types/sdk/bus/threaded-inbound.d.ts

@@ -60,7 +60,7 @@ export type ThreadedInboundDecision = {
     text: string;
     updateId: number;
     threadId: string;
-    messageId?: number;
+    messageId: number;
     attachment?: InboundAttachment;
 } | {
     kind: "duplicate";

package/dist/types/sdk/bus/threaded-render.d.ts

@@ -41,6 +41,13 @@ export interface ThreadedSend {
     richMarkdown?: string;
     /** Live-turn raw markdown for opt-in draft streaming (set ONLY on non-finalized turn frames; never triggers rich-final promotion, which requires `lane === "finalized"`). */
     richDraftMarkdown?: string;
+    /**
+     * True for a terminal tool_activity frame (phase completed/failed/cancelled/
+     * unknown). The daemon evicts the tool's `tool:<toolCallId>` live-message entry
+     * after delivering it, so completed tools do not accumulate unbounded across a
+     * long session (concurrent in-flight `started` entries are retained).
+     */
+    terminal?: boolean;
 }
 interface ThreadedFrame {
     type?: unknown;
@@ -60,6 +67,12 @@ interface ThreadedFrame {
     finalAnswer?: boolean;
     text?: unknown;
     messageRef?: unknown;
+    turnRef?: unknown;
+    toolCallId?: unknown;
+    toolName?: unknown;
+    argsSummary?: unknown;
+    resultSummary?: unknown;
+    isError?: unknown;
     source?: unknown;
     data?: unknown;
     mime?: unknown;

package/dist/types/sdk/bus/topic-registry.d.ts

@@ -20,6 +20,8 @@ export interface TopicRecord {
     identitySent: boolean;
     /** Creation timestamp (ms epoch). */
     createdAt: number;
+    /** First positive observation that the owning endpoint is stale, dead, or missing. */
+    orphanedAt?: number;
     /** Last applied or observed Telegram topic title. */
     name?: string;
     /** Naming authority. Missing values are legacy daemon-owned records. */
@@ -34,11 +36,17 @@ export interface TopicRecord {
     replayGeneration?: number;
     /** Last SDK event sequence durably consumed within replayGeneration. */
     replaySeq?: number;
+    /** Serialized authority epoch; a late create may commit only in its starting epoch. */
+    authorityEpoch?: number;
+    /** An uncertain delete fences future creation and inbound routing. */
+    authorityState?: "active" | "delete_pending";
 }
 /** Serialisable shape persisted to disk. */
 export interface TopicRegistryState {
     /** sessionId -> record. */
     topics: Record<string, TopicRecord>;
+    /** Durable deletion epochs retained after a definite delete. */
+    fences?: Record<string, number>;
 }
 export declare function emptyTopicRegistryState(): TopicRegistryState;
 /**
@@ -47,14 +55,18 @@ export declare function emptyTopicRegistryState(): TopicRegistryState;
  * `createForumTopic` call); reuse-on-resume is automatic when a record exists.
  */
 export declare class TopicRegistry {
+    #private;
     private readonly topics;
     /** Maps topicId -> sessionId for fast inbound routing. */
     private readonly byTopic;
     /** In-flight create promises, keyed by session, to dedupe concurrent creates. */
     private readonly inflight;
+    /** Monotonic authority epochs, including deletion fences for absent records. */
+    private readonly epochs;
     constructor(state?: TopicRegistryState);
     /** Merge serialized state and normalize authority fields from older releases. */
     load(state: TopicRegistryState): void;
+    private rebuildInboundRoutes;
     /** Resolve the owning session for a topic id (for fail-closed inbound routing). */
     sessionForTopic(topicId: string): string | undefined;
     /** All session ids with a persisted topic record. */
@@ -65,13 +77,17 @@ export declare class TopicRegistry {
      * Return the existing active topic for `sessionId`, or create one via
      * `create` (called only on first use).
      */
-    getOrCreateTopic(sessionId: string, create: () => Promise<string>, now?: () => number, name?: string): Promise<TopicRecord>;
+    getOrCreateTopic(sessionId: string, create: () => Promise<unknown>, now?: () => number, name?: string): Promise<TopicRecord>;
     /** Mark the identity header as sent for a session. Idempotent. */
     markIdentitySent(sessionId: string): void;
     /** Whether the identity header still needs sending for this session. */
     needsIdentity(sessionId: string): boolean;
     /** Remember stable repo/branch identity independently of the displayed name. */
     markIdentityKey(sessionId: string, identityKey: string): boolean;
+    /** Start the orphan grace clock on the first positive liveness-loss observation. */
+    markOrphaned(sessionId: string, now: number): boolean;
+    /** Clear a prior orphan observation after the endpoint is positively live again. */
+    clearOrphaned(sessionId: string): boolean;
     /** Last durably consumed SDK event cursor for reconnect replay. */
     replayCursor(sessionId: string): {
         generation: number;
@@ -93,7 +109,13 @@ export declare class TopicRegistry {
     markUserNamePending(sessionId: string, name: string): boolean;
     /** Commit a successfully-applied daemon topic title. */
     markNameApplied(sessionId: string, name: string): void;
-    /** Remove a session topic record after Telegram deletes the topic. */
+    /** Fence new work before the remote delete starts, including an absent in-flight create. */
+    beginDelete(sessionId: string): TopicRecord | undefined;
+    /** Wait for a revoked create to settle before admitting a later lifecycle epoch. */
+    awaitInflight(sessionId: string): Promise<void>;
+    /** Remove only after a definite remote deletion; ambiguity deliberately retains its fence. */
+    settleDelete(sessionId: string, topicId: string): boolean;
+    /** Remove a topic record immediately for local/test cleanup compatibility. */
     delete(sessionId: string): boolean;
     /** Serialise for atomic persistence beside the daemon state. */
     serialize(): TopicRegistryState;

package/dist/types/sdk/host/control/operations.d.ts

@@ -11,7 +11,7 @@ export interface ControlSurface {
     abort(): Promise<ControlValue> | ControlValue;
     abortAndPrompt(text: string): Promise<ControlValue> | ControlValue;
     answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
-    answerGate(id: string, response: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
+    answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string): Promise<ControlValue> | ControlValue;
     approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
     invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
     setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;

package/dist/types/sdk/host/host.d.ts

@@ -12,6 +12,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     installProviderDefinitions?: (capability: string, definitions: unknown) => void;
     onProviderDefinitionsRemoved?: (capability: string) => void;
     onReverseCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
+    /** Best-effort capabilities mirrored from the native transport for out-of-band consumers. */
+    connectionCapabilities?: (connectionId: string) => ReadonlySet<string>;
 }
 /** SDK hosting is independent of notification configuration. Only root sessions host an endpoint. */
 export declare function shouldHostSdk(_settings: unknown, isTopLevel: boolean, env?: NodeJS.ProcessEnv): boolean;

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

@@ -4,3 +4,4 @@ export * as host from "./host";
 export * as mcp from "./mcp";
 export type { Q10CurrentThinkingLevel, Q10Model, Q10SettableThinkingLevel, Q10ThinkingCapabilities, Q10ThinkingEffort, Q10ThinkingMode, } from "./models";
 export * from "./session";
+export * from "./session-directory";

package/dist/types/sdk/session-directory.d.ts

@@ -0,0 +1,56 @@
+import type { ResumeSessionIdentity } from "../session/session-manager";
+/** Version of the supported readonly managed-session directory API. */
+/** Broker-owned policy for managed-session migration decisions after scope validation. */
+export type DirectoryMigrationPolicy = "copy-retain" | "disabled";
+export declare const SESSION_DIRECTORY_API_VERSION: 1;
+/** A collision-resistant v2 managed-session scope for one canonical workspace identity. */
+export interface ManagedSessionScope {
+    readonly apiVersion: 1;
+    readonly layoutVersion: 2;
+    readonly identityVersion: 1;
+    readonly agentDir: string;
+    readonly sessionsRoot: string;
+    readonly canonicalCwd: string;
+    readonly legacyLexicalCwd: string;
+    readonly directoryName: string;
+    readonly directoryPath: string;
+}
+export type ResolveManagedSessionScopeResult = {
+    kind: "resolved";
+    scope: ManagedSessionScope;
+} | {
+    kind: "error";
+    code: "cwd_missing" | "cwd_not_directory" | "identity_unavailable" | "network_unsupported" | "sessions_root_unavailable" | "binding_conflict" | "binding_invalid";
+    message: string;
+};
+export interface LogicalSessionCandidate {
+    readonly sessionId: string;
+    readonly path: string;
+    readonly cwd: string;
+    readonly provenance: "v2" | "legacy";
+    readonly identity: Readonly<ResumeSessionIdentity>;
+    readonly migrationState: "native_v2" | "legacy_unmigrated" | "migrated_v2";
+}
+export type ListManagedSessionCandidatesResult = {
+    kind: "complete";
+    scope: ManagedSessionScope;
+    owned: readonly LogicalSessionCandidate[];
+    foreignCount: number;
+    invalid: readonly {
+        code: string;
+    }[];
+} | {
+    kind: "error";
+    code: "scan_failed" | "unsafe_root" | "invalid_candidate";
+    message: string;
+};
+/** Resolve a v2 scope without creating, migrating, or deleting session data. */
+export declare function resolveManagedSessionScope(input: {
+    cwd: string;
+    agentDir?: string;
+    sessionsRoot?: string;
+}): Promise<ResolveManagedSessionScopeResult>;
+/** List readonly v2 and validated legacy candidates for an already resolved scope. */
+export declare function listManagedSessionCandidates(input: {
+    scope: ManagedSessionScope;
+}): Promise<ListManagedSessionCandidatesResult>;

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

@@ -33,6 +33,25 @@ export interface PurgeQueuedCustomMessagesResult {
     displayFollowUp: number;
     totalExecutable: number;
 }
+export type AbortOutcome = {
+    kind: "settled";
+} | {
+    kind: "timeout";
+} | {
+    kind: "error";
+    cause: unknown;
+};
+export type CancelAndSubmitOutcome = {
+    kind: "submitted";
+} | {
+    kind: "refused";
+    reason: "duplicate" | "compaction";
+} | {
+    kind: "rolled_back";
+    outcome: Extract<AbortOutcome, {
+        kind: "timeout" | "error";
+    }>;
+};
 export interface ForkContextSeed {
     messages: Message[];
     agentMessages: AgentMessage[];
@@ -43,6 +62,7 @@ export interface ForkContextSeed {
 export interface ForkContextSeedOptions {
     maxMessages: number;
     maxTokens: number;
+    preserveLatestUser?: boolean;
     cacheIdentity?: string;
     signal?: AbortSignal;
 }
@@ -68,7 +88,6 @@ import type { HindsightSessionState } from "../hindsight/state";
 import { type WorkflowGateEmitter } from "../modes/shared/agent-wire/workflow-gate-broker";
 import type { PlanModeState } from "../plan-mode/state";
 import { type AgentRegistry } from "../registry/agent-registry";
-import { type DiscoverableMCPSearchIndex, type DiscoverableMCPTool } from "../runtime-mcp/discoverable-tool-metadata";
 import { MCPManager } from "../runtime-mcp/manager";
 import type { NotificationSessionController } from "../sdk/bus/session-control";
 import { type SecretObfuscator } from "../secrets/obfuscator";
@@ -181,6 +200,10 @@ export interface AgentSessionConfig {
     slashCommands?: FileSlashCommand[];
     /** Extension runner (created in main.ts with wrapped tools) */
     extensionRunner?: ExtensionRunner;
+    /** Override first-party worker integration dispatch for embedded hosts and deterministic lifecycle tests. */
+    workerIntegrationRequest?: (signal: AbortSignal) => Promise<void>;
+    /** Bound terminal worker-integration settlement for embedded hosts and deterministic lifecycle tests. */
+    workerIntegrationTimeoutMs?: number;
     /** Loaded skills (already discovered by SDK) */
     skills?: Skill[];
     /** Skill loading warnings (already captured by SDK) */
@@ -219,15 +242,12 @@ export interface AgentSessionConfig {
     requestedToolNames?: ReadonlySet<string>;
     /** Optional per-session allowlist for tools exposed through search_tool_bm25. */
     discoverableToolAllowedNames?: readonly string[];
-    /**
-     * Optional accessor for live MCP server instructions. Read by the session's
-     * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
-     * changes (e.g. an MCP server upgrade) that would otherwise pass the tool-set
-     * signature comparison and silently keep a stale prompt cached.
-     */
+    /** Optional accessor for live MCP server instructions, injected as untrusted user-role request data. */
     getMcpServerInstructions?: () => Map<string, string> | undefined;
     /** Enable hidden-by-default MCP tool discovery for this session. */
     mcpDiscoveryEnabled?: boolean;
+    /** Effective discovery mode normalized by the session factory. */
+    discoveryMode?: "off" | "mcp-only" | "all";
     /** MCP tool names to activate for the current session when discovery mode is enabled. */
     initialSelectedMCPToolNames?: string[];
     /** Whether constructor-provided MCP defaults should be persisted immediately. */
@@ -348,6 +368,36 @@ export interface SessionStats {
     cost: number;
     costBreakdown?: Usage["cost"];
 }
+export type EphemeralTurnPurpose = "btw" | "background";
+interface EphemeralTurnBaseArgs {
+    promptText: string;
+    onTextDelta?: (delta: string) => void;
+    signal?: AbortSignal;
+}
+export type EphemeralTurnArgs = (EphemeralTurnBaseArgs & {
+    purpose: "btw";
+}) | (EphemeralTurnBaseArgs & {
+    purpose?: "background";
+    /** Internal caller-supplied, non-persistent context such as the IRC roster. */
+    prependMessages?: AgentMessage[];
+    /** Revalidates optional caller context after asynchronous boundaries. */
+    prependMessagesValid?: () => boolean;
+    /**
+     * An existing IRC roster claim owned by the caller. `undefined` makes this
+     * turn claim and commit its own roster candidate; `null` opts out.
+     */
+    ircRosterClaim?: IrcRosterClaim | null;
+});
+interface EphemeralTurnResult {
+    replyText: string;
+    assistantMessage: AssistantMessage;
+}
+type IrcRosterClaim = {
+    token: symbol;
+    signature: string;
+    epoch: number;
+    message: CustomMessage;
+};
 export type QueuedMessageEditMode = "steer" | "followUp";
 export interface QueuedMessageEditEntry {
     id: string;
@@ -369,8 +419,9 @@ export type BeforeAgentStartContributor = (event: {
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
 export declare class WorkerIntegrationRequestScheduler {
     #private;
-    readonly request: () => Promise<void>;
-    constructor(request: () => Promise<void>);
+    readonly request: (signal: AbortSignal) => Promise<void>;
+    readonly timeoutMs: number;
+    constructor(request: (signal: AbortSignal) => Promise<void>, timeoutMs?: number);
     enqueue(): void;
     flush(): Promise<void>;
 }
@@ -448,6 +499,7 @@ export declare class AgentSession {
     peekQueueInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     peekStandingResolveHandler(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     setStandingResolveHandler(handler: ((input: unknown) => Promise<unknown> | unknown) | null): void;
+    setSdkPlanModeHandler(handler: ((on: boolean) => Promise<PlanModeState | undefined>) | null): void;
     /** Provider-scoped mutable state store for transport/session caches. */
     get providerSessionState(): Map<string, ProviderSessionState>;
     /** Suspend provider state without closing it while a temporary model is active. */
@@ -499,6 +551,8 @@ export declare class AgentSession {
      * react to (e.g. background queue flush failures).
      */
     emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+    /** Await all transformations queued by externally emitted tool results. */
+    awaitPendingContextTransformations(): Promise<void>;
     /**
      * Subscribe to agent events.
      * Session persistence is handled internally (saves messages on message_end).
@@ -541,7 +595,7 @@ export declare class AgentSession {
     get serviceTier(): ServiceTier | undefined;
     /** Whether agent is currently streaming a response */
     get isStreaming(): boolean;
-    /** Wait until streaming and deferred recovery work are fully settled. */
+    /** Wait until streaming and session settlement work are fully settled. */
     waitForIdle(): Promise<void>;
     drainAsyncJobDeliveriesForAcp(options?: {
         timeoutMs?: number;
@@ -603,15 +657,7 @@ export declare class AgentSession {
      * Get all configured tool names (built-in via --tools or default, plus custom tools).
      */
     getAllToolNames(): string[];
-    isMCPDiscoveryEnabled(): boolean;
-    /** @deprecated Use {@link getDiscoverableTools} with `{ source: "mcp" }` instead.
-     *  Preserves the legacy `description`-bearing MCP shape for back-compat callers. */
-    getDiscoverableMCPTools(): DiscoverableMCPTool[];
-    /** @deprecated Use {@link getDiscoverableToolSearchIndex} instead.
-     *  Returns the legacy MCP search index whose documents expose `tool.description`. */
-    getDiscoverableMCPSearchIndex(): DiscoverableMCPSearchIndex;
     getSelectedMCPToolNames(): string[];
-    activateDiscoveredMCPTools(toolNames: string[]): Promise<string[]>;
     isToolDiscoveryEnabled(): boolean;
     getDiscoverableTools(filter?: {
         source?: DiscoverableTool["source"];
@@ -657,6 +703,7 @@ export declare class AgentSession {
     get hasPostPromptWork(): boolean;
     /** All messages including custom types like BashExecutionMessage */
     get messages(): AgentMessage[];
+    get transcriptPromptGeneration(): number;
     /** Main startup calls this exactly once, after a strict open returned `kind: "opened"`. */
     continuePersistedHistory(): Promise<void>;
     buildDisplaySessionContext(): SessionContext;
@@ -689,7 +736,7 @@ export declare class AgentSession {
         args?: string;
         lineCount?: number;
     }>;
-    setSdkPlanMode(on: boolean): PlanModeState | undefined;
+    setSdkPlanMode(on: boolean): Promise<PlanModeState | undefined>;
     operateGoal(op: "create" | "get" | "resume" | "pause" | "complete" | "drop", objective?: string): Promise<unknown>;
     getTranscript(): Array<{
         id: string;
@@ -755,6 +802,10 @@ export declare class AgentSession {
     followUp(text: string, images?: ImageContent[], options?: Pick<PromptOptions, "followUpQueuePolicy">): Promise<void>;
     queueDeferredMessage(message: CustomMessage): void;
     queueDeferredMessageForTests(message: CustomMessage, triggerTurn?: boolean): void;
+    /** Read-only test seam for the hidden next-turn context queue. */
+    getPendingNextTurnMessagesForTests(): readonly CustomMessage[];
+    /** Test-only abort outcome override; undefined retains the production abort race. */
+    setCancelAndSubmitAbortOutcomeProviderForTests(provider: (() => Promise<AbortOutcome>) | undefined): void;
     /**
      * Send a custom message to the session. Creates a CustomMessageEntry.
      *
@@ -835,19 +886,17 @@ export declare class AgentSession {
     runMidRunMaintenanceForTests(context: AgentContext, lifecycle?: MidRunMaintenanceLifecycle): Promise<MidRunMaintenanceOutcome>;
     /** Test seam: estimate mid-run context tokens for a given context view. */
     estimateMidRunContextTokensForTests(messages: readonly AgentMessage[]): number;
-    /**
-     * Abort current operation and wait for agent to become idle.
-     */
+    /** Abort current operation and preserve the established void/rethrow contract. */
     abort(options?: {
         goalReason?: "interrupted" | "internal";
         timeoutMs?: number;
         cause?: "user_interrupt" | "new_session" | "session_switch" | "compaction" | "handoff" | "tool_abort" | "internal";
-        /** Suppress the "Operation aborted" line on the resulting aborted message
-         *  by stamping `SILENT_ABORT_MARKER`. Used when Esc consumes a queued steer
-         *  and resumes via steer-on-interrupt, so the interrupt reads as a quiet
-         *  hand-off rather than a failure. */
         silent?: boolean;
     }): Promise<void>;
+    /** Atomically interrupt the active run and make text the next prompt. */
+    cancelAndSubmit(text: string, options?: {
+        queuedEntryId?: string;
+    }): Promise<CancelAndSubmitOutcome>;
     /**
      * Start a new session, optionally with initial messages and parent tracking.
      * Clears all messages and starts a new session.
@@ -948,6 +997,8 @@ export declare class AgentSession {
      * @returns The new model info, or undefined if only one model available
      */
     cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
+    /** Number of configured role-model candidates that can be cycled. */
+    getRoleModelCycleCandidateCount(roleOrder?: readonly string[]): number;
     /**
      * Cycle through configured role models in a fixed order.
      * Skips missing roles.
@@ -1193,27 +1244,11 @@ export declare class AgentSession {
     emitSubagentSteerRelayObservation(record: CustomMessage): void;
     /**
      * Run a single ephemeral side-channel turn against this session's current
-     * model + system prompt + history.  No tools are used; the side request
-     * does not block on, or interfere with, any in-flight main turn.  The
-     * session's history and persisted state are NOT modified by this call.
-     *
-     * Used by `respondAsBackground` (IRC) and `BtwController` (`/btw`) to share
-     * the snapshot + stream pipeline.  The snapshot includes any in-flight
-     * streaming assistant text so the model sees the half-finished response
-     * rather than missing context.
-     */
-    runEphemeralTurn(args: {
-        promptText: string;
-        onTextDelta?: (delta: string) => void;
-        signal?: AbortSignal;
-        /** Defer the successful roster-claim commit until the caller accepts its exchange. */
-        deferRosterCommit?: boolean;
-    }): Promise<{
-        replyText: string;
-        assistantMessage: AssistantMessage;
-        commitRosterClaim?: () => void;
-        releaseRosterClaim?: () => void;
-    }>;
+     * model + system prompt + history. No tools are used and session history is
+     * not modified. Background turns retain the IRC/session behavior used by
+     * autoreplies; `/btw` turns use an isolated committed-context policy.
+     */
+    runEphemeralTurn(args: EphemeralTurnArgs): Promise<EphemeralTurnResult>;
     /**
      * Reload the current session from disk.
      *

package/dist/types/session/agent-storage.d.ts

@@ -98,4 +98,11 @@ export declare class AgentStorage {
      * Deletes expired cache entries. Call periodically for cleanup.
      */
     cleanExpiredCache(): void;
+    /**
+     * Release prepared statements and the shared SQLite handle.
+     *
+     * AgentStorage instances are cached by path, so closing also evicts this
+     * instance and allows a later open() to create a fresh handle.
+     */
+    close(): void;
 }

package/dist/types/session/fallback-chain-controller.d.ts

@@ -1,4 +1,4 @@
-export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "other";
+import type { FallbackTriggerClass } from "@gajae-code/ai/utils/fallback-transport";
 /** Immutable configured fallback intent. Transient attempt state never belongs here. */
 export interface ConfiguredFallbackChain {
     role: string;
@@ -30,11 +30,14 @@ export declare class FallbackChainController {
     }>;
     exhaustedForTurn: boolean;
     constructor(chain: ConfiguredFallbackChain, maxAttempts: number);
+    get totalAttemptsUsed(): number;
     currentSelector(): string | undefined;
     onResolutionSkip(reason: string): boolean;
     /** Charge an upstream request at its concrete transport boundary. */
     onAttemptStarted(): void;
-    /** Start a logically new request without losing its sticky selected entry. */
+    /** Remove the current started request from fallback-policy accounting without erasing prior failures. */
+    discardStartedAttempt(): void;
+    /** Start a logically new request with a fresh fallback-chain budget. */
     resetAttemptBudget(): void;
     /** Seed a controller from auth-aware resolution without charging requests. */
     seedResolution(activeIndex: number, skips: Array<{
@@ -43,6 +46,11 @@ export declare class FallbackChainController {
     }>): void;
     onAttemptFailure(triggerClass: FallbackTriggerClass, reason: string): FallbackFailureResult;
     advance(): boolean;
+    /**
+     * Restore the entry that just advanced when credential rotation permits a retry.
+     * The chain-wide budget and failure history remain charged.
+     */
+    restorePreviousEntryForRetry(): boolean;
     isExhausted(): boolean;
     resetForNewTurn(): void;
     resetSticky(): void;