@gajae-code/coding-agent 0.11.3 → 0.11.5

package/dist/types/modes/shared/agent-wire/workflow-gate-types.d.ts

@@ -8,12 +8,27 @@ export declare const RESERVED_WORKFLOW_STAGES: readonly string[];
 export type WorkflowGateKind = "question" | "approval" | "execution";
 /** "Other (type your own)" sentinel, mirroring the interactive ask tool. */
 export declare const GATE_OTHER_OPTION = "Other (type your own)";
+/**
+ * Structured adapter context queued at interview start. Non-behavioral:
+ * `confused_terms` and `references` MUST NOT alter the first question, are never
+ * inferred from vocabulary density, and referenced `url`/`excerpt` are inert
+ * strings that are never auto-fetched.
+ */
+export interface AskGateReference {
+    reference_id: string;
+    label: string;
+    origin: string;
+    url?: string;
+    excerpt?: string;
+}
 export interface AskGateDeepInterviewState {
     round_id?: string;
     round: number;
     component: string;
     dimension: string;
     ambiguity: number;
+    confused_terms?: string[];
+    references?: AskGateReference[];
 }
 export interface AskGateStageStateInput {
     id: string;
@@ -26,6 +41,7 @@ export interface AskGateStageStateInput {
 export interface AskGateSchemaInput {
     multi?: boolean;
     allowEmpty?: boolean;
+    customMaxLength?: number;
 }
 /** Rejects stage state that is not exactly compatible with the generic ask-gate producer. */
 export declare function validateAskGateStageState(value: unknown): asserts value is Record<string, unknown>;

package/dist/types/plan-mode/approved-plan.d.ts

@@ -43,6 +43,7 @@ interface RenameApprovedPlanFileOptions {
     planFilePath: string;
     finalPlanFilePath: string;
     getArtifactsDir: () => string | null;
+    isManagedDestination?: () => boolean;
     getSessionId: () => string | null;
 }
 export declare function renameApprovedPlanFile(options: RenameApprovedPlanFileOptions): Promise<void>;

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

@@ -64,6 +64,8 @@ export declare class MCPManager {
     static setInstance(value: MCPManager | undefined): void;
     /** Reset the process-global instance. Test-only. */
     static resetForTests(): void;
+    sealConnectionSet(): void;
+    isConnectionSetSealed(): boolean;
     constructor(cwd: string, toolCache?: MCPToolCache | null, options?: MCPManagerOptions);
     isToolsOnly(): boolean;
     /**

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

@@ -4,6 +4,7 @@
  * Automatically detects OAuth requirements from MCP server responses
  * and extracts authentication endpoints.
  */
+import type { AddressResolver } from "../web/insane/url-guard";
 export interface OAuthEndpoints {
     authorizationUrl: string;
     tokenUrl: string;
@@ -17,6 +18,15 @@ export interface AuthDetectionResult {
     authServerUrl?: string;
     message?: string;
 }
+interface OAuthDiscoveryOptions {
+    fetch?: (input: string | URL | Request, init?: BunFetchRequestInit) => Promise<Response>;
+    resolver?: AddressResolver;
+    maxRequests?: number;
+    maxNodes?: number;
+    maxRedirects?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
 export declare function extractMcpAuthServerUrl(error: Error): string | undefined;
 /**
  * Detect if an error indicates authentication is required.
@@ -37,4 +47,5 @@ export declare function analyzeAuthError(error: Error): AuthDetectionResult;
  * Try to discover OAuth endpoints by querying the server's well-known endpoints.
  * This is a fallback when error responses don't include OAuth metadata.
  */
-export declare function discoverOAuthEndpoints(serverUrl: string, authServerUrl?: string): Promise<OAuthEndpoints | null>;
+export declare function discoverOAuthEndpoints(serverUrl: string, authServerUrl?: string, options?: OAuthDiscoveryOptions): Promise<OAuthEndpoints | null>;
+export {};

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

@@ -109,6 +109,7 @@ export declare class Broker {
     constructor(settings: BrokerSettings);
     start(): Promise<BrokerDiscovery>;
     get ownsDiscovery(): boolean;
+    get completion(): Promise<void>;
     status(): RedactedBrokerDiscovery | null;
     heartbeat(): Promise<void>;
     stop(): Promise<void>;

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

@@ -1,5 +1,11 @@
 import { processIncarnation } from "./process-incarnation";
 import { SDK_STATE_VERSION } from "./state-version";
+export type BrokerPublicationObservation = "owned" | "absent" | "replaced" | "ambiguous";
+export interface RetainedBrokerDiscovery {
+    observe(): BrokerPublicationObservation;
+    heartbeat(heartbeatAt: number): Promise<boolean>;
+    close(): void;
+}
 export declare const BROKER_HEARTBEAT_TTL_MS = 15000;
 export interface BrokerDiscovery {
     version: typeof SDK_STATE_VERSION;
@@ -26,5 +32,9 @@ export declare const newBrokerToken: () => string;
 export declare const brokerProcessIncarnation: typeof processIncarnation;
 export declare function isPidAlive(pid: number): boolean;
 export declare function writeBrokerDiscovery(agentDir: string, discovery: BrokerDiscoveryWrite): Promise<void>;
+/** Publish once by name, then retain no-follow native authority for recurring heartbeats. */
+export declare function publishBrokerDiscovery(agentDir: string, discovery: BrokerDiscoveryWrite, platform?: NodeJS.Platform): Promise<RetainedBrokerDiscovery>;
+/** Heartbeat through retained authority, or the explicit Windows compatibility path. */
+export declare function heartbeatBrokerDiscoveryRetained(publication: RetainedBrokerDiscovery, heartbeatAt: number): Promise<boolean>;
 export declare function readBrokerDiscovery(agentDir: string, ttlMs?: number): Promise<BrokerDiscovery | null>;
 export declare function redactBrokerDiscovery(discovery: BrokerDiscovery): RedactedBrokerDiscovery;

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

@@ -12,11 +12,28 @@ export interface EnsureBrokerSettings {
     env?: NodeJS.ProcessEnv;
 }
 export interface FixtureBrokerLease {
+    /** Backward-compatible fixture cleanup alias for exact child termination. */
     close(): Promise<void>;
 }
+export interface ExactFixtureBrokerLease extends FixtureBrokerLease {
+    /** Observes the retained child only; it never signals a process. */
+    waitForExit(timeoutMs: number): Promise<boolean>;
+    /** Signals only the retained ChildProcess, never a discovery-derived PID. */
+    terminateExactChild(): Promise<void>;
+}
+export interface FixtureBrokerCommand {
+    file: string;
+    args: readonly string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface StartedFixtureBrokerCommand {
+    lease: ExactFixtureBrokerLease;
+    control: NodeJS.WritableStream;
+}
 export interface StartedFixtureBroker {
     discovery: BrokerDiscovery;
-    lease: FixtureBrokerLease;
+    lease: ExactFixtureBrokerLease;
 }
 interface BrokerOwner {
     stop(): Promise<void>;
@@ -31,6 +48,12 @@ interface ReapTiming {
 export declare function ensureBroker(settings: EnsureBrokerSettings): Promise<BrokerDiscovery>;
 /** Starts one fresh fixture broker and returns its sole exact-child close lease. */
 export declare function startFixtureBrokerWithLeaseForTest(settings: EnsureBrokerSettings): Promise<StartedFixtureBroker>;
+/**
+ * Test-only launch surface for topology fixtures. It accepts an already-resolved
+ * command and retains the exact spawned child; no production selection path
+ * reaches this function.
+ */
+export declare function startFixtureBrokerCommandWithLeaseForTest(command: FixtureBrokerCommand): StartedFixtureBrokerCommand;
 /** Test hook: returns a stop handle for the detached broker this process spawned. */
 export declare function brokerOwnerForTest(agentDir: string): BrokerOwner | undefined;
 /** Test hook: drives the detached-broker reap on a controllable child surface. */

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

@@ -0,0 +1,3 @@
+import type { Broker } from "./broker";
+/** Wait for broker-local completion, then terminate only the current broker process. */
+export declare function completeBrokerProcess(broker: Broker, exit?: (code: number) => never): Promise<never>;

package/dist/types/sdk/broker/session-index.d.ts

@@ -36,12 +36,24 @@ export interface SessionList {
     sessions: IndexedSession[];
     warnings: string[];
 }
+export interface SessionIndexDiagnosis {
+    status: "healthy" | "corrupt" | "unsupported";
+    validPrefixSeq: number;
+    snapshotSeq: number;
+    reason?: string;
+}
+export interface SessionIndexRepairResult extends SessionIndexDiagnosis {
+    repaired: boolean;
+    quarantinePath?: string;
+}
 export declare const sessionIndexChecksum: (event: Omit<SessionIndexEvent, "checksum">) => string;
 export declare class SessionIndex {
     #private;
     constructor(agentDir: string);
     open(): Promise<this>;
     replay(): Promise<void>;
+    diagnose(): Promise<SessionIndexDiagnosis>;
+    repair(): Promise<SessionIndexRepairResult>;
     refresh(): Promise<void>;
     get indexSeq(): number;
     append(input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> & Partial<Pick<SessionIndexEvent, "ts">>): Promise<SessionIndexEvent>;

package/dist/types/sdk/broker/state-version.d.ts

@@ -3,8 +3,9 @@ export declare const SESSION_INDEX_SNAPSHOT_VERSION = 2;
 export declare class UnsupportedStateVersionError extends Error {
     readonly file: string;
     readonly version: number;
+    readonly maximumSupportedVersion: number;
     readonly code = "unsupported_state_version";
-    constructor(file: string, version: number);
+    constructor(file: string, version: number, maximumSupportedVersion?: number);
 }
 export declare function assertSupportedStateVersion(file: string, value: unknown): void;
 export declare function assertSupportedSnapshotVersion(file: string, value: unknown): void;

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

@@ -1,4 +1,4 @@
-import { type ChatDaemonKind } from "./chat-daemon-control";
+import { type ChatDaemonKind, renewChatDaemonHeartbeat } from "./chat-daemon-control";
 import { type ChatDaemonRuntimeConfig } from "./chat-daemon-runtime";
 export interface ChatDaemonRuntimeHandle {
     start(): Promise<void>;
@@ -8,11 +8,13 @@ export interface ChatDaemonRuntimeHandle {
 export interface RunChatDaemonInternalDeps {
     processPid?: number;
     pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
     createRuntime?: (input: {
         kind: ChatDaemonKind;
         agentDir: string;
         config: ChatDaemonConfig;
     }) => Promise<ChatDaemonRuntimeHandle> | ChatDaemonRuntimeHandle;
+    renewHeartbeat?: (input: Parameters<typeof renewChatDaemonHeartbeat>[0]) => Promise<boolean>;
     setInterval?: typeof setInterval;
     clearInterval?: typeof clearInterval;
 }

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

@@ -2,6 +2,13 @@ import type { Settings } from "../../config/settings";
 import type { BuiltInDaemonController, DaemonOperationOptions, DaemonOperationResult, DaemonRuntimeInfo, DaemonStatus } from "../../daemon/control-types";
 export type ChatDaemonKind = "discord" | "slack";
 export type ChatDaemonAction = "stop" | "reload";
+/**
+ * Operational generations of the Discord/Slack daemon lifecycle contracts.
+ * These are intentionally separate from per-session endpoint generations.
+ * Generation 6 carries the retained managed filesystem authority boundary.
+ */
+export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
+export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;
 export interface ChatDaemonState {
     version: 1;
     kind: ChatDaemonKind;
@@ -12,8 +19,16 @@ export interface ChatDaemonState {
     startedAt: number;
     heartbeatAt: number;
     transportHealthy: boolean;
+    generation: number;
     stoppedAt?: number;
 }
+/**
+ * State files are untrusted persisted input. A record must be completely valid
+ * before its PID can be treated as an owner, stopped, or safe to replace.
+ */
+/** A legacy owner is recognized only when the sole missing field is generation. */
+export declare function isRecognizedLegacyGeneration(value: unknown): value is undefined;
+export declare function hasSafeChatDaemonStateShape(value: unknown): value is ChatDaemonState;
 export interface ChatDaemonControlRequest {
     version: 1;
     requestId: string;
@@ -23,9 +38,13 @@ export interface ChatDaemonControlRequest {
     createdAt: number;
     incarnation: string;
 }
+export interface ChatDaemonProcessReference {
+    incarnation: string;
+    signalRoot(signal: NodeJS.Signals): void;
+}
 export interface ChatDaemonControlDeps {
     pidAlive?: (pid: number) => boolean;
-    sendSignal?: (pid: number, signal: NodeJS.Signals) => void;
+    processReference?: (pid: number) => ChatDaemonProcessReference | undefined;
     spawn?: (command: string, args: string[], opts: {
         detached: boolean;
         stdio: "ignore";
@@ -36,7 +55,10 @@ export interface ChatDaemonControlDeps {
     ownerPid?: number;
     randomId?: () => string;
     pidIncarnation?: (pid: number) => string | undefined;
+    /** Test seam for platform-specific default stable-process authority. */
+    platform?: NodeJS.Platform;
     sleep?: (ms: number) => Promise<void>;
+    spawnReadyTimeoutMs?: number;
 }
 export declare function chatDaemonPaths(agentDir: string, kind: ChatDaemonKind): {
     dir: string;
@@ -71,7 +93,15 @@ export declare class ChatDaemonController implements BuiltInDaemonController {
     ensure(): Promise<EnsureChatDaemonResult>;
     private operate;
     private incarnation;
-    private isLiveState;
+    private processReference;
+    private isDefinitelyStoppedState;
+    private stateHealth;
+    private isSignalableMatchingOwner;
+    /** A live PID with an invalid ownership record is never safe to overwrite. */
+    private isAmbiguouslyLiveState;
+    private isHealthyFreshState;
+    private classify;
+    private isCurrentCompatibleState;
     private stopForReplacement;
     private ownsCapturedState;
     private signalIfOwner;
@@ -80,6 +110,7 @@ export declare class ChatDaemonController implements BuiltInDaemonController {
     private waitForDeath;
     private sleep;
     private spawn;
+    private waitForOwnership;
 }
 export type EnsureChatDaemonResult = "disabled" | "owner_spawned" | "attached";
 export declare function ensureDiscordDaemon(settings: Settings, deps?: ChatDaemonControlDeps): Promise<EnsureChatDaemonResult>;
@@ -101,11 +132,15 @@ export declare function renewChatDaemonHeartbeat(input: {
     pid?: number;
     incarnation?: string;
     transportHealthy: boolean;
+    pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
 }): Promise<boolean>;
 export declare function releaseChatDaemonOwnership(input: {
     agentDir: string;
     kind: ChatDaemonKind;
     ownerId: string;
-    pid?: number;
-    incarnation?: string;
+    pid: number;
+    incarnation: string;
+    pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
 }): Promise<void>;

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

@@ -67,3 +67,11 @@ export declare function parseInThreadConfigCommand(text: string): ConfigCommandC
  * daemon-locally, so it never becomes a `config_command` frame or a user turn.
  */
 export declare function parseRichToggleCommand(text: string): boolean | undefined;
+/**
+ * Parse a `/toolactivity on|off` toggle for Telegram tool-activity delivery.
+ *
+ * This is daemon-local delivery policy rather than a host-session config
+ * command, so it works without a connected session and persists globally.
+ * Addressed commands are accepted only for the exact current bot username.
+ */
+export declare function parseToolActivityToggleCommand(text: string, botUsername?: string): boolean | undefined;

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

@@ -37,6 +37,12 @@ export interface NotificationSettingsSnapshot {
         richDraft: {
             enabled: boolean;
         };
+        toolActivity: {
+            enabled: boolean;
+        };
+        streaming: {
+            enabled: boolean;
+        };
         topics: {
             nameTemplate?: string;
         };
@@ -109,6 +115,12 @@ export interface NotificationConfig {
     richDraft: {
         enabled: boolean;
     };
+    toolActivity: {
+        enabled: boolean;
+    };
+    streaming: {
+        enabled: boolean;
+    };
     topics: {
         /**
          * Optional Telegram forum-topic name template with `{repo}`, `{branch}`,
@@ -149,6 +161,16 @@ type NotificationConfigFile = z.infer<typeof notificationConfigSchema>;
 export declare function loadNotificationConfigFile(agentDir: string): LoadResult<NotificationConfigFile>;
 export declare function notificationConfigFromFile(value: NotificationConfigFile): Pick<NotificationConfig, "enabled" | "discord" | "slack" | "redact" | "verbosity">;
 export declare function hasNonBlankValue(value: string | undefined): boolean;
+/**
+ * Resolve live assistant streaming independently of generic notification
+ * lifecycle enablement. Explicit environment values override the durable
+ * Telegram preference; otherwise streaming is available only to an active
+ * configured Telegram identity.
+ */
+export declare function isNotificationStreamingEnabled(input: {
+    cfg: NotificationConfig;
+    env: NodeJS.ProcessEnv;
+}): boolean;
 /** Is Telegram configured with usable non-blank boundary credentials? */
 export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
     botToken: string;

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

@@ -21,8 +21,13 @@ import type { Tool } from "@gajae-code/ai";
 import { NotificationServer } from "@gajae-code/natives";
 import { Settings } from "../../config/settings";
 import type { ExtensionAPI, ExtensionContext } from "../../extensibility/extensions";
-import type { WorkflowGateTerminalProof } from "../../modes/shared/agent-wire/workflow-gate-broker";
-import type { AskRemoteControl } from "../../tools";
+import { type WorkflowGateEmitter, type WorkflowGateTerminalProof } from "../../modes/shared/agent-wire/workflow-gate-broker";
+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 SdkStartupFailure } from "../startup-capability";
+import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
 import { type EnsureDaemonResult } from "./telegram-daemon";
 /** Where a `session_create` should run. Discriminated by `kind`. */
@@ -182,6 +187,17 @@ export interface SessionReadyFrame {
  * instead of the worktree directory (e.g. `feat-foo-01047f11`).
  */
 export declare function readGitRepoName(cwd: string): string | undefined;
+interface PendingInteractiveAsk {
+    resolve: (result: AskAnswerSourceResult) => void;
+    options: string[];
+    controls: readonly AskRemoteControl[];
+    actionId?: string;
+    retireForDirectControl: () => RetireStatus;
+    reissue: () => boolean;
+    complete: (actionId: string) => void;
+    completeDirect: () => void;
+    fail: (actionId: string) => void;
+}
 interface UnattendedGatePresentation {
     gateId: string;
     sessionId: string;
@@ -260,9 +276,139 @@ export declare class PresentationArbiter {
     cancel(gateId: string, reason: string): void;
     dispose(): void;
 }
+interface SessionRuntime {
+    server: NotificationServer;
+    host: SessionSdkHost;
+    /** Owns stateRoot-backed revisions and removes their spills on terminal shutdown. */
+    revisions: RevisionStore;
+    /** Releases all snapshot pins before the revision store is closed. */
+    cursors: CursorRegistry;
+    /** Current endpoint session identity; never re-key an existing host across a switch. */
+    id: string;
+    idleSeq: number;
+    /** Interactive asks awaiting a remote answer, by action id. */
+    pendingInteractive: Map<string, PendingInteractiveAsk>;
+    /** Deregisters this session's ask answer source. */
+    disposeAnswerSource: () => void;
+    /** Deregisters this session's Telegram file sink. */
+    disposeFileSink: () => void;
+    /** Deregisters this session's workflow-gate listener. */
+    disposeGateListener: () => void;
+    /** Whether notification-only delivery and answer resources are active. */
+    notificationsActive: boolean;
+    /** Set as soon as terminal teardown is requested, before startup settles. */
+    stopping: boolean;
+    /** Recreates notification-only resources after `/notify on`. */
+    enableNotifications: () => void;
+    /** Deregisters canonical workflow-gate terminal cleanup. */
+    disposeGateTerminalController: () => void;
+    disposeAckRecoveryParticipant: () => void;
+    disposeGateEmitterListener: () => void;
+    /** Aborts and fences side turns while notification delivery is disabled. */
+    disableEphemeralTurns: () => void;
+    waitForGateResolutionQuiescence: () => Promise<void>;
+    trackGateResolution: <T>(resolution: Promise<T>) => Promise<T>;
+    workflowGate?: WorkflowGateEmitter;
+    gatePresentations?: PresentationArbiter;
+    redact: boolean;
+    /** Last stable policy's redaction state, retained while provisional policy is held. */
+    committedRedact: boolean;
+    /** Provisional policy suppresses delivery without changing committed-side effects. */
+    policySuspended: boolean;
+    /** Monotonic policy epoch fences asynchronous notification delivery. */
+    policyGeneration: number;
+    /** True only after the exact host generation was registered with the broker index. */
+    brokerRegistrationActive: boolean;
+    /** Terminal cleanup proof retained across retries; each owner is released at most once after proof. */
+    hostStopped: boolean;
+    serverStopped: boolean;
+    brokerRegistrationReleased: boolean;
+    verbosity: "lean" | "verbose";
+    sessionTag: string;
+    /** Whether the agent loop is currently running (drives the typing indicator). */
+    busy: boolean;
+    /** Prompt command/turn identities awaiting their corresponding agent_start. */
+    pendingPromptCorrelations: Array<{
+        commandId: string;
+        turnId: string;
+    }>;
+    /** Identity bound to the agent lifecycle currently in flight. */
+    activePromptCorrelation?: {
+        commandId: string;
+        turnId: string;
+    };
+    /** Records a correlated prompt terminal boundary after agent unwind. */
+    /** Atomically claims a correlated prompt terminal boundary after agent unwind. */
+    recordPromptTerminal: (correlation: {
+        commandId: string;
+        turnId: string;
+    } | undefined) => boolean;
+    /** Records correlated lifecycle frames for replay and delivers them only to the accepted requester after acknowledgement. */
+    emitPromptLifecycle: (correlation: {
+        commandId: string;
+        turnId: string;
+    } | undefined, frame: {
+        type: "agent_start" | "agent_end";
+        sessionId: string;
+        commandId?: string;
+        turnId?: string;
+    } | {
+        type: "agent_failed";
+        sessionId: string;
+        commandId: string;
+        turnId: string;
+        error: {
+            code: string;
+            message: string;
+        };
+    }) => void;
+    /** Publishes one canonical agent-wire event to the client that owns the active prompt. */
+    emitPromptEvent: (event: AgentSessionEvent) => void;
+    /** Inbound Telegram update ids injected but not yet consumed by a turn. */
+    pendingInbound: Set<number>;
+    /** Latest assistant text of the in-flight turn (from message_update). */
+    currentTurnText?: string;
+    /** Assistant text already flushed before an ask this turn (turn-scoped dedupe
+     * so turn_end does not re-emit the pre-ask lead-in). Reset each turn. */
+    preAskFlushedText?: string;
+    /** Live streaming: opt-in flag, monotonic per-turn ref, and emit throttle state. */
+    stream: boolean;
+    turnSeq?: number;
+    liveRef?: string;
+    lastLiveAt?: number;
+    lastLiveText?: string;
+    /** True between turn_end and the next turn_start: drops late async message_update
+     * frames so a stale live edit can never be emitted after the finalized turn. */
+    turnClosed?: boolean;
+    /** Finalized while provisional policy was held; flush exactly once on stable activation. */
+    pendingFinal?: {
+        text?: string;
+        messageRef?: string;
+    };
+    /** Durable gates emitted while ownership is provisional; presented only after stable activation. */
+    deferredGatePresentations: Array<() => void>;
+    /** SDK control frames received during provisional ownership; replayed only after stable activation. */
+    deferredInboundControls: Array<() => void>;
+    /** Started tool calls awaiting a terminal activity frame, keyed by tool call id. */
+    inFlightTools: Map<string, {
+        toolName: string;
+        args: unknown;
+    }>;
+    /** Cancels the postmortem cleanup that emits `session_closed` on process teardown. */
+    cancelPostmortemCleanup: () => void;
+    /** Disposes side-turn resources when their owning logical session becomes unavailable. */
+    abortEphemeralTurns: () => void;
+}
 /** Stable projection of the tool-owned safe-display seam (never the full Tool surface). */
 type SafeSummaryTool = Pick<Tool, "safeSummary" | "safeSummaryFields">;
 export declare function projectToolSummary(tool: SafeSummaryTool | undefined, kind: "args" | "result", value: unknown): string | undefined;
+type SessionStartStatus = "started" | "already" | "disabled" | "failed";
+type SessionStartResult = {
+    status: SessionStartStatus;
+    runtime?: SessionRuntime;
+    failure?: SdkStartupFailure;
+    suppressExtensionError?: boolean;
+};
 export declare function notificationsEnabled(): boolean;
 /** Workflow-gate answer shape. */
 interface GateAnswer {
@@ -328,6 +474,12 @@ export declare class EphemeralTurnHost {
     /** Testable event-ring eviction boundary; tombstones remain idempotency authority. */
     evictTerminalEvents(): void;
 }
+/**
+ * Ensures every configured chat-provider daemon is ready before the SDK
+ * publishes session identity. A rejected ensure is startup-fatal: presenting
+ * 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>;
 export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
     settings?: Settings;
     ensureTelegramDaemon?: (input: {
@@ -335,6 +487,7 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
         cwd: string;
         sessionId: string;
     }) => Promise<EnsureDaemonResult>;
+    ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>;
     /** Suppress auto-delivery for a GJC-spawned child under `sessionScope=primary`. */
     spawnedByGjc?: boolean;
     controller?: NotificationSessionController;
@@ -344,5 +497,12 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     runEphemeralTurn?: (promptText: string, signal: AbortSignal) => Promise<{
         replyText: string;
     }>;
+    /** Observes settlement of optional session-branch startup after reconciliation completes. */
+    onBranchStartupSettled?: (receipt: {
+        sessionId: string;
+        status: SessionStartResult["status"];
+    }) => void;
+    readNotificationFile?: (path: string) => Promise<Buffer>;
+    readNotificationDiffStat?: (cwd: string) => Promise<string | undefined>;
 }): void;
 export {};