@gajae-code/coding-agent 0.16.3 → 0.16.6

package/dist/types/modes/types.d.ts

@@ -57,6 +57,11 @@ export type ActivityIndicatorStopOptions = Readonly<{
     /** The terminal event is authoritative even if the session's streaming flag has not settled yet. */
     foregroundSettled?: boolean;
 }>;
+export declare function clearInteractiveActivityIndicator(ctx: {
+    loadingAnimation?: Loader;
+    statusContainer?: PartialActivityStatusContainer;
+    clearLoadingAnimation?: () => void;
+}): void;
 export declare function stopInteractiveActivityIndicator(ctx: {
     loadingAnimation?: Loader;
     statusContainer?: PartialActivityStatusContainer;
@@ -190,6 +195,7 @@ export interface InteractiveModeContext {
     setWorkingMessage(message?: string): void;
     applyPendingWorkingMessage(): void;
     ensureLoadingAnimation(): void;
+    clearLoadingAnimation(): void;
     syncActivityIndicator(): void;
     suspendActivityIndicator(): () => void;
     stopLoadingAnimation(options?: ActivityIndicatorStopOptions): void;
@@ -259,6 +265,7 @@ export interface InteractiveModeContext {
     extractAssistantText(message: AssistantMessage): string;
     /** Records one semantic visible-transcript mutation for the sticky viewport. */
     recordVisibleTranscriptMutation?(): void;
+    resetAssistantTextPresentation(): void;
     updateEditorTopBorder(): void;
     updateEditorBorderColor(): void;
     rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;

package/dist/types/runtime-mcp/client.d.ts

@@ -1,4 +1,12 @@
-import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerCapabilities, MCPServerConfig, MCPServerConnection, MCPToolCallResult, MCPToolDefinition } from "./types";
+import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerCapabilities, MCPServerConfig, MCPServerConnection, MCPToolCallResult, MCPToolDefinition, MCPTransport } from "./types";
+import { MCPExpectedFailure } from "./types";
+/** Failed connection whose still-owned transport cleanup can be retried explicitly. */
+export declare class MCPConnectionCleanupFailure extends MCPExpectedFailure {
+    #private;
+    constructor(cause: unknown, transport: MCPTransport);
+    /** Retry the same retained transport cleanup; failures preserve all prior causes. */
+    close(): Promise<void>;
+}
 /**
  * Connect to an MCP server.
  * Has a 30 second timeout to prevent blocking startup.

package/dist/types/runtime-mcp/manager.d.ts

@@ -8,6 +8,7 @@ import { type TSchema } from "@gajae-code/ai/core";
 import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";
+import { MCPConnectionCleanupFailure } from "./client";
 import { MCPConnectionPool, type MCPPoolLease } from "./pool";
 import type { MCPProtocolObservation } from "./protocol";
 import type { MCPToolDetails } from "./tool-bridge";
@@ -200,6 +201,10 @@ export declare class MCPManager {
     }): Promise<T>;
     /** Read-only test seam for pending retired lease-release records. */
     get retiredLeaseReleaseCountForTests(): number;
+    /** Read-only test seam for retained failed-connection cleanup owners. */
+    get pendingConnectionCleanupCountForTests(): number;
+    /** Read-only test seam for retained failed-connection cleanup causes. */
+    getPendingConnectionCleanupFailureForTests(name: string): MCPConnectionCleanupFailure | undefined;
     /**
      * Get all connected server names.
      */
@@ -223,7 +228,8 @@ export declare class MCPManager {
      * Tears down the stale connection, re-resolves auth, establishes a new
      * connection, reloads tools, and notifies consumers.
      * Concurrent calls for the same server share one reconnection attempt.
-     * Returns the new connection, or null if reconnection failed.
+     * Returns the new connection, or null if reconnection fails after cleanup.
+     * Throws a retryable cleanup failure while the previous transport owner remains incomplete.
      */
     reconnectServer(name: string): Promise<MCPServerConnection | null>;
     /**

package/dist/types/runtime-mcp/pool.d.ts

@@ -1,3 +1,4 @@
+import { MCPConnectionCleanupFailure } from "./client";
 import { type MCPPoolKeyIdentity, type MCPPoolKeyOptions, type MCPPoolSharingMode } from "./pool-key";
 import { type MCPRequestOptions, type MCPServerConfig, type MCPServerConnection } from "./types";
 export type { MCPPoolCapabilityProfile, MCPPoolKeyIdentity, MCPPoolKeyOptions, MCPPoolSharingMode } from "./pool-key";
@@ -18,8 +19,9 @@ export declare class MCPPoolAcquireAbortError extends Error {
     readonly code: "MCP_POOL_ACQUIRE_ABORTED";
     readonly serverName: string;
     readonly poolKey: string;
-    cleanup?: Promise<unknown>;
-    constructor(serverName: string, poolKey: string, cause: unknown, cleanup?: Promise<unknown>);
+    readonly cleanup?: Promise<void>;
+    readonly cleanupGeneration?: number;
+    constructor(serverName: string, poolKey: string, cause: unknown, cleanup?: Promise<void>, cleanupGeneration?: number);
 }
 export declare class MCPPoolLeaseInvalidatedError extends Error {
     readonly code: "MCP_POOL_LEASE_INVALIDATED";
@@ -60,6 +62,8 @@ export interface MCPPoolAcquireOptions extends MCPPoolKeyOptions {
     advertiseRoots?: boolean;
     onNotification?: (method: string, params: unknown) => void;
     onRequest?: (method: string, params: unknown) => Promise<unknown>;
+    /** @internal Synchronous handoff for a pool-owned abandoned-acquire cleanup flight. */
+    onCleanupPending?: (error: MCPPoolAcquireAbortError) => void;
 }
 export interface MCPConnectionPoolOptions {
     sharedPoolIdleMs?: number;
@@ -105,6 +109,7 @@ type PendingWaiter = {
     settled: boolean;
     claimed: boolean;
     removeAbortListener?: () => void;
+    onCleanupPending?: (error: MCPPoolAcquireAbortError) => void;
 };
 type PendingEntry = {
     claims: number;
@@ -118,7 +123,7 @@ type PendingEntry = {
     cancellationReason?: unknown;
     openAbortController: AbortController;
     openSignal?: AbortSignal;
-    settlement?: Promise<unknown>;
+    settlement?: Promise<void>;
 };
 /** A lease over one physical MCP connection. */
 export interface MCPPoolLease {
@@ -182,6 +187,20 @@ export declare class MCPConnectionPool {
     awaitRestart(key: string): Promise<boolean>;
     finishRestart(key: string, error?: unknown): void;
     releaseRestart(key: string): void;
+    private retainCancelledAcquireCleanup;
+    private notifyPendingAcquireCleanup;
+    /** @internal Whether this pool still owns the notified abandoned-acquire flight. */
+    hasPendingAcquireCleanup(error: MCPPoolAcquireAbortError): boolean;
+    /** @internal Current retained failure for one notified abandoned-acquire generation. */
+    getPendingAcquireCleanupFailure(error: MCPPoolAcquireAbortError): MCPConnectionCleanupFailure | undefined;
+    /** @internal Prevent manager-level duplication of the pool's retained cleanup owner. */
+    ownsPendingAcquireCleanupFailure(error: unknown): boolean;
+    /** Read-only test seam for abandoned-acquire cleanup owners. */
+    get pendingAcquireCleanupCountForTests(): number;
+    /** Read-only test seam for the current retained abandoned-acquire cleanup failure. */
+    getPendingAcquireCleanupFailureForTests(name: string): MCPConnectionCleanupFailure | undefined;
+    /** @internal Join and retry one generation of abandoned acquisition cleanup. */
+    closePendingAcquireCleanup(key: string, generation: number): Promise<void>;
     acquire(name: string, config: MCPServerConfig, options?: MCPPoolAcquireOptions): Promise<MCPPoolLease>;
     private waitForPendingEntry;
     private scheduleZeroClaimCleanup;

package/dist/types/runtime-mcp/transports/stdio.d.ts

@@ -23,7 +23,3 @@ export declare class StdioTransport implements MCPTransport {
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
     close(): Promise<void>;
 }
-/**
- * Create and connect a stdio transport.
- */
-export declare function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport>;

package/dist/types/runtime-mcp/types.d.ts

@@ -78,6 +78,20 @@ export interface MCPServerConfigBase {
     };
 }
 /** Stdio server configuration */
+export interface MCPStdioSpawnLaunch {
+    command: string;
+    args: readonly string[];
+    cwd: string;
+    /** Transport-supplied registrar for retryable cleanup before preparation allocates resources. */
+    registerCleanup?: (cleanup: () => Promise<void>) => void;
+}
+export interface MCPStdioPreparedLaunch extends MCPStdioSpawnLaunch {
+    /**
+     * Per-attempt cleanup run after confirmed child exit or failed spawn. The same
+     * callback may already have been registered during preparation.
+     */
+    afterProcessExit?: () => Promise<void>;
+}
 export interface MCPStdioServerConfig extends MCPServerConfigBase {
     type?: "stdio";
     command: string;
@@ -91,6 +105,14 @@ export interface MCPStdioServerConfig extends MCPServerConfigBase {
      */
     noInheritEnv?: boolean;
     cwd?: string;
+    /** Internal trusted-boundary preparation of immutable per-spawn authority. */
+    prepareSpawn?: (launch: MCPStdioSpawnLaunch) => Promise<MCPStdioPreparedLaunch>;
+    /** Internal trusted-boundary check run immediately before process creation. */
+    spawnGuard?: (launch: MCPStdioSpawnLaunch) => Promise<void>;
+    /** Internal cleanup run only after the owned stdio child is confirmed exited. */
+    afterProcessExit?: () => Promise<void>;
+    /** Test seam for deterministic mutation after the guard and before process creation. */
+    afterSpawnGuardForTest?: () => Promise<void>;
 }
 /** HTTP server configuration (Streamable HTTP transport) */
 export interface MCPHttpServerConfig extends MCPServerConfigBase {

package/dist/types/sdk/broker/ensure.d.ts

@@ -1,7 +1,9 @@
 import { type ChildProcess } from "node:child_process";
 import type { FileHandle } from "node:fs/promises";
+import { type FileLockOptions } from "../../config/file-lock";
 import { type BrokerDiscovery } from "./discovery";
 import { type SdkInternalSpawnCommand } from "./runtime";
+export declare function isBrokerGenerationCompatible(discovery: BrokerDiscovery | null): boolean;
 export interface EnsureBrokerSettings {
     agentDir: string;
     heartbeatTtlMs?: number;
@@ -12,6 +14,27 @@ export interface EnsureBrokerSettings {
      */
     env?: NodeJS.ProcessEnv;
 }
+type SpawnLockOptions = Pick<FileLockOptions, "retries" | "retryDelayMs" | "signal">;
+declare function readBrokerDiscoveryBeforeDeadline(agentDir: string, heartbeatTtlMs: number | undefined, deadline: number): Promise<BrokerDiscovery | null>;
+/**
+ * Cross-process single-flight for the detached broker spawn (#5198).
+ *
+ * `ensureInFlight` only dedupes within one process. Every CLI invocation is
+ * its own process, so N concurrent invocations that all miss discovery each
+ * spawn a broker; the losers of the runtime's ownership lock then leave
+ * quarantine tombstones behind and the next start fails with
+ * `quarantine_collision`. The spawn itself must be exclusive across process
+ * death and PID reuse, so it uses the shared identity-bound file-lock protocol:
+ * complete owner metadata is published atomically, stale removal is bound to
+ * the exact directory generation, and ownership includes the OS incarnation.
+ */
+declare function acquireSpawnLock(agentDir: string, options?: SpawnLockOptions): Promise<() => Promise<void>>;
+/**
+ * Child-owned fence for the interval from bootstrap through discovery publication.
+ * The parent-held spawn lock prevents ordinary stampedes; this second fence keeps
+ * startup single-flight if that detached child's launcher dies and its lock is reclaimed.
+ */
+export declare function withBrokerStartupLock<T>(agentDir: string, operation: (deadline: number) => Promise<T>): Promise<T>;
 /**
  * Tail of the detached broker's stderr folded into a discovery failure.
  *
@@ -62,6 +85,12 @@ interface ReapTiming {
     killVerifyMs: number;
 }
 type BrokerOwnerIdentity = Pick<BrokerDiscovery, "ownerId" | "pid" | "incarnation">;
+/** Start client teardown, but never await it past the retirement operation's absolute deadline. */
+export declare function closeBrokerClientBeforeDeadline(client: {
+    close(): Promise<void>;
+}, deadline: number): Promise<void>;
+/** Reconcile an observed broker generation before entering a startup critical section. */
+export declare function reconcileBrokerGenerationForStartup(settings: EnsureBrokerSettings, deadline?: number): Promise<BrokerDiscovery | undefined>;
 /** Starts the detached broker entrypoint when discovery has no live owner. */
 export declare function ensureBroker(settings: EnsureBrokerSettings): Promise<BrokerDiscovery>;
 /** Starts one fresh fixture broker and returns its sole exact-child close lease. */
@@ -73,6 +102,9 @@ export declare function startFixtureBrokerWithLeaseForTest(settings: EnsureBroke
  */
 export declare function startFixtureBrokerCommandWithLeaseForTest(command: FixtureBrokerCommand): StartedFixtureBrokerCommand;
 /** Test hook: returns a stop handle for the detached broker this process spawned. */
+export declare const acquireSpawnLockForTest: typeof acquireSpawnLock;
+/** Test hook: proves discovery reads honor their enclosing absolute deadline. */
+export declare const readBrokerDiscoveryBeforeDeadlineForTest: typeof readBrokerDiscoveryBeforeDeadline;
 export declare function brokerOwnerForTest(agentDir: string): BrokerOwner | undefined;
 /** Test hook: verifies the complete broker owner identity used during stale retirement. */
 export declare function brokerOwnerIdentityMatchesForTest(left: BrokerOwnerIdentity | null, right: BrokerOwnerIdentity): boolean;

package/dist/types/sdk/broker/lifecycle-ledger.d.ts

@@ -78,7 +78,6 @@ export interface LifecycleLedgerEntry {
     unresolvedCleanupResponseDigest?: string;
     uncertainCleanupSessionId?: string;
     uncertainCleanupSessionIds?: string[];
-    uncertainCleanupAllSessions?: true;
     ts: number;
 }
 export type BeginResult = {

package/dist/types/sdk/broker/lifecycle.d.ts

@@ -173,14 +173,20 @@ export declare function observeProcessForTest(pid: number, expectedIncarnation:
  * deliberately left untouched.
  */
 export declare function reapDeadLifecycleMarkers(root: string, limit?: number): Promise<number>;
+export declare function writeEffectMarker(root: string, id: string, marker: EffectMarker): Promise<void>;
 /** The child writes this only after its endpoint and semantic ready event are both live. */
 export declare function writeSessionLifecycleReady(root: string, id: string, effectMarker: string): Promise<void>;
 export interface LifecycleTranscriptEvidence {
     digest: string;
     identity: SessionLifecycleTranscriptIdentity;
 }
+type LifecycleFailureArtifact = EffectMarker & SdkStartupFailure & {
+    rollback: SdkStartupRollbackResult;
+    transcript?: LifecycleTranscriptEvidence;
+};
 /** Writes bounded startup diagnostics. The child stamps its own pid; the broker may stamp a proven child identity. */
 export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string, ownerPid?: number): Promise<void>;
+export declare function readSessionLifecycleFailure(root: string, id: string, expected: EffectMarker): Promise<LifecycleFailureArtifact | undefined>;
 export declare function readSessionLifecycleFailureForTest(root: string, id: string, expected: {
     pid: number;
     effectMarker: string;

package/dist/types/sdk/broker/startup-failure.d.ts

@@ -1,5 +1,5 @@
 export interface BrokerStartupFailureMarker {
-    version: 1;
+    version: 2;
     reason: string;
     exitCode: number | null;
     signal: string | null;
@@ -13,6 +13,8 @@ export interface BrokerStartupFailureMarker {
      * failure.
      */
     pid: number;
+    /** Kernel-derived identity for the exact process incarnation that wrote the marker. */
+    incarnation: string;
 }
 export declare function brokerStartupFailurePath(agentDir: string): string;
 /**
@@ -26,6 +28,7 @@ export declare function writeBrokerStartupFailureMarker(agentDir: string, failur
     exitCode: number | null;
     signal: string | null;
     pid: number;
+    incarnation?: string;
 }): Promise<void>;
 /** Reads a bounded startup-failure marker; `undefined` when absent or malformed. */
 export declare function readBrokerStartupFailureMarker(agentDir: string): Promise<BrokerStartupFailureMarker | undefined>;

package/dist/types/sdk/bus/chat-daemon-control.d.ts

@@ -105,6 +105,8 @@ export type ChatDaemonAction = "stop" | "reload";
  * Discord generation 72 / Slack generation 75 serialize same-generation
  * successor attachment admission behind predecessor provider retirement, so a
  * pre-upgrade owner cannot retain the queue race fixed by #5120.
+ * Slack generation 80 persists and fences the inbound SDK dispatch boundary so
+ * crashes, recovery, and attachment retirement cannot replay ambiguous work.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

package/dist/types/sdk/bus/chat-daemon-runtime.d.ts

@@ -36,6 +36,18 @@ export interface ChatDaemonRuntimeDeps {
     createSlackProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["slack"]>) => SlackProviderClient;
     routerDeps?: SessionRouterDeps;
 }
+/**
+ * Chat notifications in lean mode are an answer surface, not a mirror of the
+ * session protocol. Lifecycle, identity, and activity frames remain available
+ * to verbose consumers, while finalized answers and action-needed events are
+ * delivered in lean mode.
+ */
+export declare function shouldPublishChatFrame(frame: Record<string, unknown>, verbosity: "lean" | "verbose" | undefined): boolean;
+/**
+ * A final answer's message ref identifies its one rendered message even when
+ * the SDK transport delivers an unpositioned duplicate frame.
+ */
+export declare function publicationIdForFinalChatAnswer(sessionId: string, frame: Record<string, unknown>): string | undefined;
 /**
  * Worker-owned session discovery and event fanout. It connects only through the
  * public SDK transport and retains SDK credentials solely in live client objects.

package/dist/types/sdk/bus/chat-effect-journal.d.ts

@@ -2,7 +2,7 @@ import { type ConversationRecord, type ConversationStoreFs } from "./conversatio
 export declare const CHAT_EFFECT_JOURNAL_VERSION = 1;
 export declare const MAX_TERMINAL_CHAT_EFFECTS = 128;
 export declare function chatEffectJournalPath(agentDir: string, transport: "discord" | "slack"): string;
-export type ChatEffectState = "pending" | "leased" | "accepted" | "uncertain" | "terminal";
+export type ChatEffectState = "pending" | "leased" | "dispatching" | "accepted" | "uncertain" | "terminal";
 /** Provider receipts are identifiers/status only. Never put request or response bodies here. */
 export interface ChatEffectReceipt {
     provider?: string;
@@ -77,9 +77,24 @@ export declare class ChatEffectJournal {
     enqueueAndClaim<TPayload>(input: EnqueueChatEffect<TPayload>, owner: string, leaseMs: number): Promise<ChatEffect<TPayload> | undefined>;
     claim<TPayload = unknown>(id: string, owner: string, leaseMs: number): Promise<ChatEffect<TPayload> | undefined>;
     renew<TPayload = unknown>(id: string, lease: ChatEffectLease, leaseMs: number): Promise<ChatEffect<TPayload> | undefined>;
+    markDispatching<TPayload = unknown>(id: string, lease: ChatEffectLease): Promise<ChatEffect<TPayload> | undefined>;
+    ownsDispatching(id: string, lease: ChatEffectLease): Promise<boolean>;
+    /** Hold the durable dispatching lease until the synchronous SDK prewire boundary. */
+    dispatchWithLeaseFence<R>(id: string, lease: ChatEffectLease, dispatch: () => Promise<R>, dispatched: Promise<void>): Promise<{
+        value: R;
+    } | undefined>;
+    recoverDispatchingAsUncertain<TPayload = unknown>(id: string, options?: {
+        onlyIfExpired?: boolean;
+    }): Promise<ChatEffect<TPayload> | undefined>;
     /** Persists provider progress without releasing the owner/epoch fence. */
     recordReceipt<TPayload = unknown>(id: string, lease: ChatEffectLease, receipt: ChatEffectReceipt): Promise<ChatEffect<TPayload> | undefined>;
-    record<TPayload = unknown>(id: string, lease: ChatEffectLease, state: Exclude<ChatEffectState, "pending" | "leased">, receipt?: ChatEffectReceipt): Promise<ChatEffect<TPayload> | undefined>;
+    record<TPayload = unknown>(id: string, lease: ChatEffectLease, state: "accepted" | "uncertain" | "terminal", receipt?: ChatEffectReceipt): Promise<ChatEffect<TPayload> | undefined>;
     /** Irreversibly rejects an effect whose mapping never accepted its authority. */
     terminalize(id: string, receipt: ChatEffectReceipt, lease?: ChatEffectLease): Promise<ChatEffect | undefined>;
+    /**
+     * Terminalize only a decided effect. The uncertainty check and state change
+     * share one store transaction so a concurrent sender cannot publish an
+     * ambiguity tombstone between a caller's read and stale cleanup.
+     */
+    terminalizeDecided(id: string, receipt: ChatEffectReceipt, lease?: ChatEffectLease): Promise<ChatEffect | undefined>;
 }

package/dist/types/sdk/bus/conversation-store.d.ts

@@ -88,4 +88,15 @@ export declare class ConversationStore<T extends ConversationRecord> {
      * other writer uses.
      */
     transactWithSnapshot(key: string, update: (current: T | undefined, conversations: Readonly<Record<string, T>>) => T | undefined | Promise<T | undefined>): Promise<T | undefined>;
+    /**
+     * Hold the cross-process mapping lock until a prepared dispatch either reaches
+     * its synchronous wire boundary or fails before sending. The result may remain
+     * pending after the lock is released while the remote response is awaited.
+     */
+    dispatchWithSnapshotFence<R>(key: string, prepare: (current: T | undefined, conversations: Readonly<Record<string, T>>) => {
+        result: Promise<R>;
+        dispatched: Promise<void>;
+    } | undefined): Promise<{
+        value: R;
+    } | undefined>;
 }

package/dist/types/sdk/bus/lifecycle-commands.d.ts

@@ -1,5 +1,11 @@
 import type { SessionCloseTarget, SessionCreateTarget, SessionLifecycleResponse, SessionResumeTarget } from "./index";
 export type LifecycleCommandVerb = "session_create" | "session_close" | "session_resume";
+export interface LifecycleCommandContext {
+    chatType?: string;
+    botUsername?: string;
+    /** Session durably associated with the Telegram topic containing the command. */
+    threadSessionId?: string;
+}
 /** A parsed, validated lifecycle command (transport identity added by caller). */
 export type ParsedLifecycleCommand = {
     kind: "create";
@@ -27,10 +33,7 @@ export type ParsedLifecycleCommand = {
 /** True when the text begins with any /session_* token, regardless of addressability. */
 export declare function isLifecycleCommandLikeText(text: string | undefined): boolean;
 /** True when the text begins an addressable /session_* command (cheap pre-gate). */
-export declare function isLifecycleCommandText(text: string | undefined, ctx?: {
-    chatType?: string;
-    botUsername?: string;
-}): boolean;
+export declare function isLifecycleCommandText(text: string | undefined, ctx?: LifecycleCommandContext): boolean;
 /**
  * Parse a paired-chat message into a lifecycle command. Returns `none` for
  * non-lifecycle text, `usage`/`reject` for malformed input (no side effect), or
@@ -39,10 +42,7 @@ export declare function isLifecycleCommandText(text: string | undefined, ctx?: {
  * The caller MUST have already enforced paired-chat authorization; this function
  * performs grammar + target validation only.
  */
-export declare function parseLifecycleCommand(text: string | undefined, ctx?: {
-    chatType?: string;
-    botUsername?: string;
-}): ParsedLifecycleCommand;
+export declare function parseLifecycleCommand(text: string | undefined, ctx?: LifecycleCommandContext): ParsedLifecycleCommand;
 /** The canonical usage text (exported for the daemon's help replies). */
 export declare function lifecycleUsage(): string;
 /**

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

@@ -30,7 +30,7 @@ export interface SlackNotificationDaemonOptions {
     resolveAttachment: (sessionId: string) => Promise<SessionAttachment | null>;
     /** Exact Router proof for adopting an existing root. */
     resolveBindingAuthority?: (sessionId: string) => Promise<SlackBindingAuthority | undefined>;
-    onCommand?: (sessionId: string, content: string, attachment: SessionAttachment, idempotencyKey: string) => Promise<boolean>;
+    onCommand?: (sessionId: string, content: string, attachment: SessionAttachment, idempotencyKey: string, beforeDispatch: () => void, dispatchFence: <T>(dispatch: () => Promise<T>) => Promise<T>) => Promise<boolean>;
 }
 /**
  * Slack Socket Mode notification daemon. Accepted inbound SDK effects are

package/dist/types/sdk/bus/slack-live-provider.d.ts

@@ -59,6 +59,12 @@ export declare class SlackLiveProvider implements SlackProviderClient, SlackDiag
         clientMsgId: string;
         signal?: AbortSignal;
     }): Promise<SlackPostedMessage>;
+    addReaction(input: {
+        channel: string;
+        timestamp: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     findMessageByClientMsgId(input: {
         channel: string;
         clientMsgId: string;

package/dist/types/sdk/bus/slack-provider.d.ts

@@ -52,6 +52,12 @@ export interface SlackProviderClient {
         threadTs?: string;
         signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
+    addReaction?(input: {
+        channel: string;
+        timestamp: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Prove that an operator-supplied timestamp addresses a real message in the
      * requested channel. Adoption of an existing root is refused when a client
@@ -87,6 +93,12 @@ export declare class SlackProvider {
         threadTs?: string;
         signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
+    addReaction(input: {
+        channel: string;
+        timestamp: string;
+        name: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
     /** Fail-closed root verification: a client without this capability can never confirm a root. */
     findMessageByTimestamp(input: {
         channel: string;

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

@@ -206,6 +206,14 @@ export declare class TopicRegistry {
     private rebuildInboundRoutes;
     /** Resolve the owning session for a topic id (for fail-closed inbound routing). */
     sessionForTopic(topicId: string): string | undefined;
+    /**
+     * Resolve a durable topic association for explicit lifecycle controls.
+     *
+     * Unlike inbound message routing, this may return an inactive session so a
+     * user can resume it from its old topic. Ambiguous, malformed, cross-chat,
+     * and quarantined records fail closed.
+     */
+    sessionForLifecycleTopic(topicId: string, chatId: string): string | undefined;
     /** All session ids with a persisted topic record. */
     sessionIds(): string[];
     /** The existing topic record for a session, if any. */

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

@@ -12,6 +12,10 @@ export declare class SdkClientError extends Error {
     readonly reconnect?: SdkReconnectExhaustedDetails;
     constructor(code: SdkErrorCode, message: string, details?: unknown, reconnect?: SdkReconnectExhaustedDetails);
 }
+/** A prepared transport operation failed before any wire handoff. */
+export declare class SdkPreparedDispatchError extends SdkClientError {
+    constructor(error: SdkClientError);
+}
 export type SdkReconnectTerminationReason = "attempts_exhausted" | "deadline" | "cancelled";
 /**
  * Reconnect-cycle termination diagnostics. `attemptsConsumed` counts retry slots,
@@ -66,6 +70,8 @@ export interface SdkRequestOptions {
      * alter that settlement.
      */
     onDispatch?: SdkDispatchHandler;
+    /** Internal prepared-dispatch mode: fail pre-send instead of reconnecting. */
+    connectedOnly?: boolean;
 }
 export type SdkFrame = Record<string, unknown>;
 /**

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

@@ -117,6 +117,8 @@ export declare class SessionSdkHost {
      * publishing a second readiness signal.
      */
     activate(expectedGeneration?: number): Promise<SessionActivationOutcome>;
-    stop(): Promise<"stopped" | "already">;
+    stop(options?: {
+        allowLockContention?: boolean;
+    }): Promise<"stopped" | "already">;
     registerWithBroker(writer: BrokerIndexWriter): Promise<void>;
 }

package/dist/types/sdk/host/session-runtime.d.ts

@@ -1,5 +1,6 @@
 import { type Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
+import type { AgentEndEvent } from "../../extensibility/shared-events";
 import { type MasterRoleAttestationV2, SessionIndex, type SessionLocatorV2 } from "../broker/session-index";
 import type { SdkPromptTerminalOutcome } from "../prompt-status";
 import { type ReceiptState } from "../receipt-state";
@@ -24,6 +25,16 @@ export declare function verifyMasterCapabilityFrame(input: {
     nonce: string;
     attestationEpoch: string;
 };
+/**
+ * Normalize an agent-loop stop reason into the published terminal outcome.
+ *
+ * Only reached for a boundary that actually terminalizes an owned invocation,
+ * so every result is a `stopped` disposition: a failed run publishes its own
+ * correlated `agent_failed` frame with the sanitized cause instead.
+ */
+export declare function terminalStoppedOutcome(stopReason: AgentEndEvent["stopReason"], maintenanceOutcome: string | undefined): Extract<SdkPromptTerminalOutcome, {
+    kind: "stopped";
+}>;
 /** Transport-neutral endpoint contract consumed by the SDK session runtime. */
 export interface SessionSdkTransport {
     readonly sessionId: string;
@@ -167,6 +178,18 @@ export declare class SessionSdkSessionRuntime {
     get generation(): number;
     getProviderDefinitions(capability: string): unknown | undefined;
     emitEvent(frame: SdkFrame): void;
+    /**
+     * Deliver a frame to specific connections without recording it.
+     *
+     * Deliberately not `emitEvent`: that assigns a ring position and broadcasts to
+     * every authenticated socket. Streamed turn content is high-frequency and
+     * unbounded in size, so a count-bounded ring would evict the lifecycle events
+     * clients depend on -- including the `agent_end` that settles their prompt --
+     * and broadcasting would hand every subscriber a stream only the submitter
+     * asked for. Delivery failure is ignored: a disconnected consumer must never
+     * disturb the turn producing the content.
+     */
+    sendFrameTo(connectionId: string, frame: SdkFrame): void;
     publish(frame: SdkFrame): void;
     startHost(): Promise<"started" | "already">;
     startTransport(): Promise<{
@@ -175,7 +198,9 @@ export declare class SessionSdkSessionRuntime {
     start(): Promise<{
         url: string;
     }>;
-    stop(): Promise<void>;
+    stop(options?: {
+        allowLockContention?: boolean;
+    }): Promise<void>;
     registerWithBroker(writer: BrokerIndexWriter): Promise<void>;
 }
 /** Narrow extension-facing factory for the SDK-only session path. */

package/dist/types/sdk/lifecycle/service.d.ts

@@ -137,6 +137,7 @@ export interface SessionLifecycleSessionResult {
     readonly sessionId: string;
     readonly cwd?: string;
     readonly endpointGeneration?: number;
+    readonly endpointIncarnation?: string;
     readonly reused?: boolean;
     readonly note?: string;
 }

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

@@ -2,6 +2,7 @@ import { type SessionIndex } from "../broker/session-index";
 import { type SdkDispatchContext, type SdkDispatchHandler } from "../client/client";
 import { type ActivatedPreparedSession } from "../session-activation";
 export interface SessionEndpointIdentity {
+    readonly dev: bigint;
     readonly mtimeMs: number;
     readonly mtimeNs: bigint;
     readonly ctimeNs: bigint;
@@ -32,7 +33,10 @@ export interface SessionAttachment {
     readonly connectionId?: string;
     readonly generation: number;
     isCurrent(): boolean;
-    send(frame: Record<string, unknown>): unknown;
+    send(frame: Record<string, unknown>, options?: {
+        beforeDispatch?: () => void;
+        dispatchFence?: (dispatch: () => Promise<void>) => Promise<void>;
+    }): unknown;
     /**
      * Idempotent provider-lease heartbeat send that skips the pre-send authority
      * reconcile (#4689).
@@ -106,6 +110,7 @@ export interface SessionRouterClient {
     connect?(): Promise<void>;
     request(frame: Record<string, unknown>, options?: {
         timeoutMs?: number;
+        connectedOnly?: boolean;
         /** Synchronous pre-send observer; a throw aborts the dispatch before the wire. */
         beforeDispatch?: (context: SdkDispatchContext) => void;
         /** Synchronous post-send boundary observer for transport-close-aware consumers. */
@@ -208,6 +213,7 @@ export declare class SessionRouter {
         timeoutMs?: number;
         beforeDispatch?: (context: SdkDispatchContext) => void;
         onDispatch?: SdkDispatchHandler;
+        dispatchFence?: (dispatch: () => Promise<Record<string, unknown>>) => Promise<Record<string, unknown>>;
     }): Promise<Record<string, unknown>>;
     /** Resolves the exact provider-neutral binding authority for operator adoption. */
     bindingAuthority(sessionId: string): Promise<{
@@ -224,5 +230,7 @@ export declare class SessionRouter {
     /** Activates a prepared session through one Router-owned, one-shot SDK client. */
     activatePreparedSession(sessionId: string): Promise<ActivatedPreparedSession>;
     /** Lists saved sessions through Router-owned Broker discovery without exposing credentials or mutation authority. */
-    listBrokerSessions(input: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>>;
+    listBrokerSessions(input: Record<string, unknown>, idempotencyKey: string, options?: {
+        beforeDispatch?: (context: SdkDispatchContext) => void;
+    }, dispatchFence?: (dispatch: () => Promise<Record<string, unknown>>) => Promise<Record<string, unknown>>): Promise<Record<string, unknown>>;
 }