@gajae-code/coding-agent 0.11.11 → 0.12.1

package/dist/types/modes/components/notifications-settings-editor.d.ts

@@ -12,6 +12,7 @@ export interface NotificationsEditorPreferences {
     richDraftEnabled: boolean;
     toolActivityEnabled: boolean;
     streamingEnabled: boolean;
+    sound: "all" | "important" | "none";
 }
 /** Secret-safe snapshot used to render the Notifications tab. */
 export interface NotificationsEditorState {

package/dist/types/modes/components/read-tool-group.d.ts

@@ -8,12 +8,11 @@ type ReadRenderArgs = {
     file_path?: string;
     sel?: string;
 };
-type ReadToolGroupOptions = {
-    showContentPreview?: boolean;
-};
 export declare class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
     #private;
-    constructor(options?: ReadToolGroupOptions);
+    constructor(options?: {
+        showContentPreview?: boolean;
+    });
     updateArgs(args: ReadRenderArgs, toolCallId?: string): void;
     updateResult(result: {
         content: Array<{
@@ -32,5 +31,6 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
      */
     setManuallyExpanded(expanded: boolean): void;
     getComponent(): Component;
+    consumeVisibleTranscriptChange(): boolean;
 }
 export {};

package/dist/types/modes/components/session-observer-overlay.d.ts

@@ -2,6 +2,24 @@ import type { KeyId } from "../../config/keybindings";
 import type { SessionMessageEntry } from "../../session/session-manager";
 import type { SessionObserverRegistry } from "../session-observer-registry";
 import { type TranscriptViewerEntry, TranscriptViewerOverlay } from "./transcript-viewer-overlay";
+export declare const __sessionObserverProjectionCounters: {
+    enabled: boolean;
+    projectionFullRuns: number;
+    projectionIncrementalRuns: number;
+    sourceMessagesProjected: number;
+    projectedEntriesAppended: number;
+    resultPatchCount: number;
+    snapshot(): {
+        projectionFullRuns: number;
+        projectionIncrementalRuns: number;
+        sourceMessagesProjected: number;
+        projectedEntriesAppended: number;
+        resultPatchCount: number;
+    };
+    enable(): void;
+    disable(): void;
+    reset(): void;
+};
 /** Session-observer adapter. The shared viewer owns navigation and fold state. */
 export declare class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
     #private;
@@ -9,4 +27,8 @@ export declare class SessionObserverOverlayComponent extends TranscriptViewerOve
     refreshFromRegistry(): void;
     handleInput(keyData: string): void;
 }
+/**
+ * This deliberately remains the eager full-history projection. PR2 owns projection
+ * virtualization/incrementalization; source acquisition above only controls snapshot safety.
+ */
 export declare function entriesFromMessages(entries: readonly SessionMessageEntry[]): TranscriptViewerEntry[];

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

@@ -3,6 +3,7 @@ import type { Effort } from "@gajae-code/ai";
 import { type Component, Container } from "@gajae-code/tui";
 import { type SettingPath } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
+import type { GjcRuntimeSnapshotProvider } from "../../extensibility/gjc-plugins/runtime-quarantine";
 import { type NotificationsEditorOperations } from "./notifications-settings-editor";
 import type { StatusLineSegmentOptions } from "./tool-status-header";
 /**
@@ -24,6 +25,14 @@ export interface SettingsRuntimeContext {
     petAvailable?: boolean;
     /** Terminal environment used to select unavailable-pet guidance. Omitted in production to use Bun.env. */
     terminalEnv?: NodeJS.ProcessEnv;
+    /**
+     * Runtime evidence published by the session for the current activation
+     * generation. Omitted when no session published one, in which case the GJC
+     * Bundles tab honestly reports runtime status as unavailable.
+     */
+    gjcRuntimeSnapshot?: GjcRuntimeSnapshotProvider;
+    /** Activation generation the published snapshot must match to be merged. */
+    gjcActivationGeneration?: number;
 }
 /** Status line settings subset for preview */
 export interface StatusLinePreviewSettings {
@@ -58,6 +67,8 @@ export interface SettingsCallbacks {
     getStatusLinePreview?: (width?: number) => string;
     /** Called when plugins change */
     onPluginsChanged?: () => void;
+    /** Called when an interactive setting cannot be committed. */
+    onError?: (message: string) => void;
     /** Called when settings panel is closed */
     onCancel: () => void;
 }

package/dist/types/modes/components/status-line/gh.d.ts

@@ -0,0 +1,5 @@
+import { type RunGh } from "../../../utils/gh";
+export declare function lookupCurrentPr(runGh?: RunGh): Promise<{
+    number: number;
+    url: string;
+} | null>;

package/dist/types/modes/components/tool-execution.d.ts

@@ -5,6 +5,8 @@ export interface ToolExecutionOptions {
     editFuzzyThreshold?: number;
     editAllowFuzzy?: boolean;
     hashlineAutoDropPureInsertDuplicates?: boolean;
+    /** Internal observer for visible asynchronous renderer mutations. */
+    onVisibleTranscriptMutation?: () => void;
 }
 export interface ToolExecutionHandle {
     updateArgs(args: any, toolCallId?: string): void;
@@ -29,6 +31,11 @@ export interface ToolExecutionHandle {
      * back to {@link setExpanded}.
      */
     setManuallyExpanded?(expanded: boolean): void;
+    /**
+     * Internal capability for dispatchers that need exact synchronous visible-output
+     * detection. Optional so existing structural handles remain source compatible.
+     */
+    consumeVisibleTranscriptChange?(): boolean;
 }
 /**
  * Component that renders a tool call with its result (updateable)
@@ -52,6 +59,7 @@ export declare class ToolExecutionComponent extends Container {
         details?: any;
         isError?: boolean;
     }, isPartial?: boolean, _toolCallId?: string): void;
+    consumeVisibleTranscriptChange(): boolean;
     /**
      * Stop spinner animation and cleanup resources.
      */

package/dist/types/modes/components/transcript-viewer-overlay.d.ts

@@ -29,13 +29,30 @@ export type TranscriptViewerOverlayOptions = {
     footerControls?: string;
     getEntryText?: (entry: TranscriptViewerEntry, expanded: boolean) => string;
 };
+export declare const __transcriptViewerPerfCounters: {
+    enabled: boolean;
+    layoutCacheHits: number;
+    layoutCacheMisses: number;
+    refreshRuns: number;
+    rebuildRuns: number;
+    snapshot(): {
+        layoutCacheHits: number;
+        layoutCacheMisses: number;
+        refreshRuns: number;
+        rebuildRuns: number;
+    };
+    enable(): void;
+    disable(): void;
+    reset(): void;
+};
 /** Message-agnostic, modal transcript browser over resolved projection entries. */
 export declare class TranscriptViewerOverlay extends Container {
     #private;
     constructor(options: TranscriptViewerOverlayOptions);
     get selectedEntryId(): string | undefined;
     get isFullscreen(): boolean;
-    refresh(identityMap?: ReadonlyMap<string, string>): void;
+    refresh(identityMap?: ReadonlyMap<string, string>, preserveLayoutCache?: boolean): void;
+    invalidateLayoutEntries(entryIds: readonly string[]): void;
     render(width: number): string[];
     handleMouse(event: MouseEvent): void;
     handleInput(keyData: string): void;

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

@@ -3,7 +3,10 @@ import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 /** Test-only performance counters for advisory baseline tests. */
 export declare const __eventControllerPerfCounters: {
+    enabled: boolean;
     messageUpdateContentVisits: number;
+    enable(): void;
+    disable(): void;
     reset(): void;
 };
 export declare class EventController {

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

@@ -181,6 +181,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<void>;
     flushPendingBashComponents(): void;
     isKnownSlashCommand(text: string): boolean;
+    /** Advances the sticky-viewport source only for semantic transcript output. */
+    recordVisibleTranscriptMutation(): void;
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
     }): Component[];

package/dist/types/modes/irc-observation-ledger.d.ts

@@ -1,5 +1,18 @@
 import type { ParsedIrcMessage } from "./utils/irc-message";
 type InlineMode = "persistent" | "ephemeral";
+export declare const IRC_OBSERVATION_LEDGER_MAX_RECORDS = 10000;
+export declare const IRC_OBSERVATION_LEDGER_MAX_RETAINED_UTF8_BYTES: number;
+export declare const IRC_OBSERVATION_LEDGER_MAX_SEEN_IDENTITIES = 100000;
+export declare const __ircLedgerPerfCounters: {
+    enabled: boolean;
+    epochAdvances: number;
+    snapshot(): {
+        epochAdvances: number;
+    };
+    enable(): void;
+    disable(): void;
+    reset(): void;
+};
 export type IrcObservationRecord = Readonly<ParsedIrcMessage & {
     mode: InlineMode;
     observedAt: number;
@@ -10,6 +23,7 @@ export type IrcObservationRecord = Readonly<ParsedIrcMessage & {
 /** Runtime-only IRC observations. This intentionally has no persistence layer. */
 export declare class IrcObservationLedger {
     #private;
+    get mutationEpoch(): number;
     /** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
     observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined;
     getRecord(observationId: string): IrcObservationRecord | undefined;
@@ -17,6 +31,8 @@ export declare class IrcObservationLedger {
     getInlineProjection(now: number): readonly IrcObservationRecord[];
     /** Returns and clears IDs whose retained payload was released. */
     drainEvictedObservationIds(): readonly string[];
-    reset(): void;
+    reset(options?: {
+        retireCurrentSessionIdentities?: boolean;
+    }): void;
 }
 export {};

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

@@ -218,6 +218,8 @@ export interface InteractiveModeContext {
     getAssistantViewportAnchorId?(message: AssistantMessage): string;
     findLastAssistantMessage(): AssistantMessage | undefined;
     extractAssistantText(message: AssistantMessage): string;
+    /** Records one semantic visible-transcript mutation for the sticky viewport. */
+    recordVisibleTranscriptMutation?(): void;
     updateEditorTopBorder(): void;
     updateEditorBorderColor(): void;
     rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -6,6 +6,22 @@ import { type SessionContext } from "../../session/session-manager";
 import { type ParsedIrcMessage } from "./irc-message";
 export type { TranscriptRebuildPolicy } from "../../modes/types";
 export declare function prepareTranscriptRebuild(ui: TUI, policy: TranscriptRebuildPolicy): void;
+export declare const RESUME_PROGRESS_COMMIT_TIMEOUT_MS = 250;
+export interface ResumeProgressLease {
+    readonly committed: Promise<boolean>;
+    clear(): void;
+}
+/**
+ * Mount a resume loader on the live status rail and wait for its render generation
+ * to commit before session I/O begins. The commit is advisory: a stopped or
+ * unavailable terminal resolves false and callers continue without blocking.
+ *
+ * Fail open (no-op lease, committed=false) when the status rail or UI lacks the
+ * child-mutation/render-commit surface required to mount progress. Headless and
+ * minimal controller contexts keep resume/migration semantics; full interactive
+ * TUI containers retain progress-before-switch.
+ */
+export declare function acquireResumeProgressLease(ctx: Pick<InteractiveModeContext, "ui" | "statusContainer">): ResumeProgressLease;
 interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
 }

package/dist/types/reminders/star-reminder.d.ts

@@ -1,5 +1,8 @@
 import type { ImageContent } from "@gajae-code/ai";
 import type { CustomMessage } from "../session/messages";
+import { type GhResult, type RunGh, runGhDefault } from "../utils/gh";
+export type { GhResult, RunGh };
+export { runGhDefault };
 export declare const STAR_REMINDER_REPO = "Yeachan-Heo/gajae-code";
 export declare const STAR_REMINDER_CUSTOM_TYPE = "star-reminder";
 export declare const STARRED_CACHE_TTL_MS: number;
@@ -10,15 +13,6 @@ export interface StarReminderState {
     starredCheckedAt: string;
 }
 export type StarCheckStatus = "starred" | "unstarred" | "unavailable";
-export interface GhResult {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-    timedOut?: boolean;
-}
-export type RunGh = (args: string[], options?: {
-    timeoutMs?: number;
-}) => Promise<GhResult>;
 export interface StarReminderDeps {
     statePath?: string;
     now?: () => Date;
@@ -49,10 +43,6 @@ export declare function recordStarredFromPut(deps?: StarReminderDeps): Promise<S
 export declare function recordFreshStarCheck(status: "starred" | "unstarred", deps?: StarReminderDeps): Promise<StarReminderState>;
 /** Record a launch-nudge decline. Never downgrades a confirmed star. */
 export declare function recordDeclinedAfterNo(deps?: StarReminderDeps): Promise<StarReminderState>;
-/** Default `gh` runner. Returns an unavailable-style result instead of throwing. */
-export declare function runGhDefault(args: string[], options?: {
-    timeoutMs?: number;
-}): Promise<GhResult>;
 /** Classify the star state of the repo via `gh api`. */
 export declare function checkGhStarred(deps?: StarReminderDeps): Promise<StarCheckStatus>;
 /** Star the repo via `gh api -X PUT`. Returns whether the PUT succeeded. */

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

@@ -6,6 +6,7 @@ import type { MCPToolDetails } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
 import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
 export declare function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number;
+export declare function resolveExactConfigStartupTimeoutMs(configs: MCPServerConfig[]): number;
 /**
  * Stable, total ordering on MCP tools by name.
  *

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

@@ -7,6 +7,11 @@ type SmitheryCliPollResponse = {
     apiKey?: string;
     message?: string;
 };
+/** Test seam: the Smithery origin and env API key as resolved from trusted env. */
+export declare function resolveSmitheryEnvForTest(): {
+    url: string;
+    apiKey: string | undefined;
+};
 export declare function getSmitheryLoginUrl(): string;
 export declare function createSmitheryCliAuthSession(): Promise<SmitheryCliAuthSession>;
 export declare function pollSmitheryCliAuthSession(sessionId: string, signal?: AbortSignal): Promise<SmitheryCliPollResponse>;

package/dist/types/sdk/acp/adapter.d.ts

@@ -2,7 +2,9 @@ import { SdkClient, SdkClientError, type SdkFrame } from "../client";
 type JsonObject = Record<string, unknown>;
 /** The small agent-side ACP surface used for reverse requests. */
 export interface AcpReverseConnection {
-    request?(method: string, params: JsonObject): Promise<unknown>;
+    request?(method: string, params: JsonObject, options?: {
+        cancellationSignal?: AbortSignal;
+    }): Promise<unknown>;
     [key: string]: unknown;
 }
 export interface AcpProviderRegistration {

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

@@ -73,6 +73,11 @@ export interface SessionLifecycleLaunchRequest {
 export declare function readSessionLifecycleLaunchRequest(value: string | undefined, now?: number): SessionLifecycleLaunchRequest;
 type CleanupEvidence = BrokerCleanupEvidence;
 export declare function validateBrokerModelPresetForTest(agentDir: string, requestedProfile: string): string | BrokerResponse;
+/** Test seam: the session-host command override as resolved from trusted env. */
+export declare function sdkSessionCommandOverrideForTest(): {
+    file: string;
+    args: string[];
+} | undefined;
 export declare function setProcessIncarnationForTest(broker: Broker, value: ((pid: number) => string | undefined) | undefined): 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>;

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

@@ -1,4 +1,6 @@
 import type { Broker } from "./broker";
+export type BrokerShutdownSendAction = "dropped" | "wait_for_drain" | "close";
+export declare function brokerShutdownSendAction(status: number): BrokerShutdownSendAction;
 /** Loopback-only WebSocket transport for the agent-global SDK broker. */
 export declare class BrokerTransport {
     #private;

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

@@ -7,6 +7,7 @@
 export type TelegramFileSink = (file: {
     path: string;
     caption?: string;
+    mime?: string;
 }) => Promise<{
     ok: boolean;
     error?: string;

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

@@ -16,7 +16,10 @@ export type ChatDaemonAction = "stop" | "reload";
  * when deleting an observed owner-lock lease. Generation 12 refreshes retained
  * native path and process authority semantics. Generation 13 rejects special
  * files before retained native authority opens. Generation 14 reloads shared
- * chat daemons after notification configuration parsing changes.
+ * chat daemons after notification configuration parsing changes. Generation 15
+ * applies the current notification configuration directly when starting chat
+ * daemon transports. Generation 16 applies Telegram sound-policy configuration
+ * through shared notification parsing.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

package/dist/types/sdk/bus/config.d.ts

@@ -28,6 +28,7 @@ export interface NotificationSettingsSnapshot {
         botToken?: string;
         chatId?: string;
         activation?: Record<string, unknown>;
+        sound: "all" | "important" | "none";
         btw: {
             enabled: boolean;
         };
@@ -105,6 +106,7 @@ export interface NotificationConfig {
      * (those carrying {@link SPAWN_PROVENANCE_ENV}) unless they explicitly opt in.
      */
     sessionScope: "all" | "primary";
+    sound: "all" | "important" | "none";
     idleTimeoutMs: number;
     btw: {
         enabled: boolean;
@@ -177,7 +179,7 @@ export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is No
     chatId: string;
 };
 /** Is Discord configured with all credentials and routing identifiers required by its daemon. */
-export declare function isDiscordConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export declare function isDiscordConfigured(cfg: Pick<NotificationConfig, "enabled" | "discord">): cfg is Pick<NotificationConfig, "enabled"> & {
     discord: {
         botToken: string;
         applicationId: string;
@@ -186,7 +188,7 @@ export declare function isDiscordConfigured(cfg: NotificationConfig): cfg is Not
     };
 };
 /** Is Slack configured with both SDK tokens and its workspace/channel routing identifiers. */
-export declare function isSlackConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export declare function isSlackConfigured(cfg: Pick<NotificationConfig, "enabled" | "slack">): cfg is Pick<NotificationConfig, "enabled"> & {
     slack: {
         botToken: string;
         appToken: string;
@@ -286,6 +288,8 @@ export interface RedactableAction {
     workflowGateId?: string;
     question?: string;
     options?: string[];
+    /** Selected zero-based option positions for transport-specific multi-select rendering. */
+    selectedOptionIndices?: number[];
     summary?: string;
     /** Optional zero-based recommendation into the authoritative raw options. */
     recommendedIndex?: number;

package/dist/types/sdk/bus/control-drain-lease.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Ordering seam for an in-band SDK identity transition.
+ *
+ * A request arrives through predecessor A, so a successful terminal response cannot
+ * be published until successor B is ready. Native builds may provide a true
+ * send-only connection lease; source/dev builds use the conservative fallback in
+ * which the predecessor server remains alive until the terminal write completes.
+ */
+export type TerminalSendOutcome = "written" | "disconnected" | "write_failed";
+/** Fence/capability hooks may return false to reject; undefined means ok. */
+export type IdentityControlGateResult = boolean | undefined;
+export type IdentityControlGate = () => IdentityControlGateResult | Promise<IdentityControlGateResult>;
+export interface IdentityControlSuccessPathInput {
+    /** Fence predecessor inbound work. The fence must not close its response writer. */
+    fence: IdentityControlGate;
+    /** Optional explicit proof that the predecessor writer is still usable. */
+    ensurePredecessorSendCapable?: IdentityControlGate;
+    /** Start successor B and resolve only after its public endpoint is ready. */
+    startSuccessor: () => Promise<void>;
+    /** Write and flush either the success or non-success terminal response. */
+    sendTerminal: () => Promise<TerminalSendOutcome>;
+    /** Release predecessor A after the terminal response has settled. */
+    stopPredecessor: () => Promise<void>;
+    /** Set only when a caller cannot use the retained-writer fallback. */
+    requireNativeControlDrain?: boolean;
+}
+export interface IdentityControlTerminalPathInput {
+    fenceInbound: IdentityControlGate;
+    ensurePredecessorSendCapable?: IdentityControlGate;
+    startSuccessorReady: () => Promise<void>;
+    sendTerminal: () => Promise<TerminalSendOutcome>;
+    stopPredecessor: () => Promise<void>;
+    requireNativeControlDrain?: boolean;
+}
+/**
+ * Probe the loaded native addon, never an environment flag or a TypeScript shim.
+ * Older/source installs intentionally report false so callers can select the
+ * retained-writer fallback or fail closed when detach is mandatory.
+ */
+export declare function isNativeControlDrainAvailable(): boolean;
+/**
+ * Run the only safe ordering for a successful identity-control response.
+ *
+ * The `finally` is deliberately around both successor startup and terminal
+ * delivery: a failed startup must not leave the fenced predecessor alive, and a
+ * failed/disconnected terminal write must still release it. When native detach
+ * is unavailable the caller is expected to keep A's server up (not call
+ * `stopAndWait`) until `sendTerminal` settles.
+ */
+export declare function runIdentityControlSuccessPath(input: IdentityControlSuccessPathInput): Promise<TerminalSendOutcome>;
+/** Compatibility spelling used by the host wiring design notes. */
+export declare function runIdentityControlTerminalPath(input: IdentityControlTerminalPathInput): Promise<TerminalSendOutcome>;

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

@@ -26,10 +26,13 @@ import type { AgentSessionEvent } from "../../session/agent-session";
 import type { AskAnswerSourceResult, AskRemoteControl } from "../../tools";
 import { SessionSdkHost } from "../host";
 import { CursorRegistry, RevisionStore } from "../host/query";
+import { type SdkPromptTerminalOutcome } from "../prompt-status";
 import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
 import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
+export type { IdentityControlSuccessPathInput, IdentityControlTerminalPathInput, TerminalSendOutcome, } from "./control-drain-lease";
+export { isNativeControlDrainAvailable, runIdentityControlSuccessPath, runIdentityControlTerminalPath, } from "./control-drain-lease";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -297,6 +300,8 @@ interface SessionRuntime {
     disposeGateListener: () => void;
     /** Whether notification-only delivery and answer resources are active. */
     notificationsActive: boolean;
+    /** Rejects new SDK frames while a leased terminal response drains. */
+    inboundFenced: boolean;
     /** Set as soon as terminal teardown is requested, before startup settles. */
     stopping: boolean;
     /** Recreates notification-only resources after `/notify on`. */
@@ -344,6 +349,23 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     };
+    /** Binds the executing Agent run to a correlated prompt so cleanup targets only it. */
+    bindPromptExecutionHandle: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, handle: string | undefined) => void;
+    /** Reads the durable non-terminal claim for a correlated prompt, if any. */
+    peekPromptPendingOutcome: (correlation: {
+        commandId: string;
+        turnId: string;
+    }) => SdkPromptTerminalOutcome | undefined;
+    /** Claims, fences, finalizes, and publishes exactly one normalized prompt terminal. */
+    terminalizePrompt: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, outcome: SdkPromptTerminalOutcome, extra?: {
+        finalText?: string;
+    }) => Promise<void>;
     /** Records a correlated prompt terminal boundary after agent unwind. */
     /** Atomically claims a correlated prompt terminal boundary after agent unwind. */
     recordPromptTerminal: (correlation: {
@@ -375,6 +397,7 @@ interface SessionRuntime {
         commandId?: string;
         turnId?: string;
         finalText?: string;
+        outcome?: SdkPromptTerminalOutcome;
     } | {
         type: "agent_failed";
         sessionId: string;
@@ -384,6 +407,7 @@ interface SessionRuntime {
             code: string;
             message: string;
         };
+        outcome?: SdkPromptTerminalOutcome;
     }) => void;
     /** Publishes one canonical agent-wire event to the client that owns the active prompt. */
     emitPromptEvent: (event: AgentSessionEvent) => void;
@@ -442,6 +466,15 @@ type SessionStartResult = {
     failure?: SdkStartupFailure;
     suppressExtensionError?: boolean;
 };
+/**
+ * Whether the notifications control channel is enabled.
+ *
+ * Trusted sources only: enabling it opens the session control/answer channel, so
+ * a repository must not be able to turn it on. `$env` merges the caller's
+ * `cwd/.env` into `process.env`; the sibling resolvers in `config.ts` and
+ * `session-control.ts` already read an injected env record rather than the merged
+ * view, and this direct read was the outlier.
+ */
 export declare function notificationsEnabled(): boolean;
 /** Workflow-gate answer shape. */
 interface GateAnswer {
@@ -513,6 +546,17 @@ export declare class EphemeralTurnHost {
  * an identity for a transport that never became available is false success.
  */
 export declare function ensureConfiguredProviderDaemons(settings: Settings, cfg: NotificationConfig, ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>): Promise<void>;
+/**
+ * Classify whether a session identity event must await notification endpoint startup.
+ * Only an interactive selector resume may defer this ancillary startup; all other
+ * events, including branches and unknown origins, fail closed to awaiting it.
+ */
+export declare function shouldAwaitNotificationStartup(event: {
+    type: "session_switch" | "session_branch";
+    transition?: {
+        origin: string;
+    };
+}): boolean;
 export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
     settings?: Settings;
     ensureTelegramDaemon?: (input: {
@@ -539,4 +583,3 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     readNotificationFile?: (path: string) => Promise<Buffer>;
     readNotificationDiffStat?: (cwd: string) => Promise<string | undefined>;
 }): void;
-export {};

package/dist/types/sdk/bus/kind-aware-reconciliation.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
+ * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
+ */
+import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
+import { type PromptCorrelation } from "./prompt-reconciliation";
+import type { ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
+export type { ReconciliationKind };
+export interface KindCorrelation extends PromptCorrelation {
+    kind: ReconciliationKind;
+}
+export interface KindAwareReconciliation {
+    admit(kind: ReconciliationKind, clientRef?: string): void;
+    releaseAdmission(kind: ReconciliationKind, clientRef?: string): void;
+    noteAccepted(kind: ReconciliationKind, correlation: PromptCorrelation, clientRef?: string, extra?: {
+        skillName?: string;
+    }): Promise<void>;
+    noteTransition(kind: ReconciliationKind, correlation: PromptCorrelation | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }): Promise<void>;
+    claimPendingOutcome(correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome): Promise<SdkPromptTerminalOutcome>;
+    finalizePromptOutcome(correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {
+        code: string;
+        message: string;
+    }): Promise<void>;
+    peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
+    lookup(kind: ReconciliationKind, selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): TurnPromptReconciliation;
+    cleanup(): void;
+    activeCount(kind: ReconciliationKind): number;
+    /** Hydrate from durable store (call once at session host start). */
+    hydrateFromStore(): Promise<void>;
+}
+export declare function createKindAwareReconciliation(options?: {
+    now?: () => number;
+    store?: ReconciliationStore | null;
+}): KindAwareReconciliation;
+export type { PromptReconciliationStatus };

package/dist/types/sdk/bus/lifecycle-control-runtime.d.ts

@@ -48,6 +48,8 @@ export declare function buildCreateArgv(frame: SessionCreateFrame, _ids: {
 /** Real daemon-safe tmux launcher: canonical owner-isolation plan + GJC tags. */
 export declare function daemonSpawnCreate(env?: NodeJS.ProcessEnv, opts?: {
     ownerIsolationProbe?: OwnerIsolationProbe;
+    platform?: NodeJS.Platform;
+    processIncarnation?: (pid: number) => string | undefined;
 }): (frame: SessionCreateFrame, ids: {
     lifecycleRequestId: string;
     intendedSessionId: string;
@@ -73,6 +75,8 @@ export declare function daemonResumeSession(env?: NodeJS.ProcessEnv, opts?: {
     sessionsRoot?: string;
     listSessions?: (env: NodeJS.ProcessEnv) => GjcTmuxSessionStatus[];
     ownerIsolationProbe?: OwnerIsolationProbe;
+    platform?: NodeJS.Platform;
+    processIncarnation?: (pid: number) => string | undefined;
 }): (target: {
     sessionIdOrPrefix: string;
     path?: string;

package/dist/types/sdk/bus/prompt-reconciliation.d.ts

@@ -12,7 +12,8 @@
  * - Terminal records are retained for TERMINAL_TTL_MS and bounded to
  *   TERMINAL_CAPACITY, evicted oldest-terminal-first by terminalAt; only then
  *   does a lookup honestly report `unknown`.
- * - The durability floor is the live session process: restart means `unknown`.
+ * - Process-local durability floor is the live session process: restart means `unknown`.
+ *   Session-scoped durable retention (kind-aware store) is provided by reconciliation-store.ts (#3032).
  * - The clientRef index is session-runtime scoped; a ref conflicts only while
  *   retained and must never be reused as a retry mechanism.
  * - Terminal transitions settle once: the first terminal outcome wins.