@sayknow-cli/coding-agent 0.4.7 → 0.5.1

package/dist/types/runtime/memory-guard.d.ts

@@ -0,0 +1,39 @@
+import type { Settings } from "../config/settings";
+import type { MemoryGuardDecision, MemoryGuardDomainSnapshot, MemoryGuardPolicy, MemoryGuardSchedulerState } from "./memory-guard-contract";
+type WorkOwner = {
+    generation: number;
+    source: "timer" | "external";
+};
+export interface MemoryGuardHostRegistration {
+    ownerId: string;
+    intervalMs: number;
+}
+export interface MemoryGuardHostOptions {
+    run: () => Promise<void>;
+    logDebug?: (message: string, meta?: Record<string, unknown>) => void;
+    schedulerNow?: () => number;
+}
+export declare function resolveMemoryGuardPolicy(settings: Settings): MemoryGuardPolicy;
+export declare function chooseMemoryGuardAction(input: {
+    domain: MemoryGuardDomainSnapshot;
+    hostSupported: boolean;
+    workerSupported: (workerId: string) => boolean;
+}): MemoryGuardDecision;
+export declare function revalidateMemoryGuardAction(previous: Extract<MemoryGuardDecision, {
+    kind: "execute";
+}>, revalidated: MemoryGuardDecision): MemoryGuardDecision;
+export declare class MemoryGuardHost {
+    #private;
+    constructor(options: MemoryGuardHostOptions);
+    register(registration: MemoryGuardHostRegistration): () => void;
+    updateInterval(ownerId: string, intervalMs: number): void;
+    runTick(generation?: number, source?: WorkOwner["source"]): Promise<void>;
+    runTimerCallbackForTest(owner: {
+        generation: number;
+        token: number;
+    }, deadline: number): Promise<void>;
+    setSchedulerNowForTest(now: () => number): void;
+    getStateForTest(): MemoryGuardSchedulerState;
+    resetForTest(): void;
+}
+export {};

package/dist/types/runtime/memory-limit.d.ts

@@ -0,0 +1,11 @@
+export interface EffectiveMemoryLimitInput {
+    hardCapBytes?: number | null;
+    policyLimitBytes?: number | null;
+}
+export interface EffectiveMemoryLimit {
+    hardCapBytes: number | null;
+    policyLimitBytes: number | null;
+    effectiveBytes: number | null;
+    source: "none" | "hard_cap" | "policy_limit" | "hard_cap_and_policy_limit";
+}
+export declare function resolveEffectiveMemoryLimit(input: EffectiveMemoryLimitInput): EffectiveMemoryLimit;

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

@@ -0,0 +1,7 @@
+export declare const MCP_MAX_CONTENT_BYTES: number;
+export declare const MCP_MAX_ERROR_BYTES: number;
+export declare const MCP_MAX_SSE_REQUEST_MESSAGES = 1024;
+export declare const MCP_MAX_SSE_BATCH_MESSAGES = 1024;
+export declare const MCP_HTTP_TIMEOUT_MS = 30000;
+export declare function cancelMCPStream(stream: ReadableStream<Uint8Array> | null): void;
+export declare function readMCPResponseText(response: Response, limit: number, truncate?: boolean, signal?: AbortSignal): Promise<string>;

package/dist/types/runtime-mcp/discoverable-tool-metadata.d.ts

@@ -6,5 +6,5 @@
  * Upstream v0.11.x renamed `DiscoverableMCP*` → `DiscoverableTool*`; we re-export
  * the new symbols under the legacy names so existing call sites still compile.
  */
-export type { DiscoverableToolSearchDocument as DiscoverableMCPSearchDocument, DiscoverableToolSearchIndex as DiscoverableMCPSearchIndex, DiscoverableToolSearchResult as DiscoverableMCPSearchResult, DiscoverableTool as DiscoverableMCPTool, DiscoverableToolServerSummary as DiscoverableMCPToolServerSummary, DiscoverableToolSummary as DiscoverableMCPToolSummary, } from "../tool-discovery/tool-index";
+export type { DiscoverableTool as DiscoverableMCPTool, DiscoverableToolSearchDocument as DiscoverableMCPSearchDocument, DiscoverableToolSearchIndex as DiscoverableMCPSearchIndex, DiscoverableToolSearchResult as DiscoverableMCPSearchResult, DiscoverableToolServerSummary as DiscoverableMCPToolServerSummary, DiscoverableToolSummary as DiscoverableMCPToolSummary, } from "../tool-discovery/tool-index";
 export { buildDiscoverableToolSearchIndex as buildDiscoverableMCPSearchIndex, collectDiscoverableTools as collectDiscoverableMCPTools, formatDiscoverableToolServerSummary as formatDiscoverableMCPToolServerSummary, getDiscoverableTool as getDiscoverableMCPTool, isMCPBridgeTool, isMCPToolName, searchDiscoverableTools as searchDiscoverableMCPTools, selectDiscoverableToolNamesByServer as selectDiscoverableMCPToolNamesByServer, summarizeDiscoverableTools as summarizeDiscoverableMCPTools, } from "../tool-discovery/tool-index";

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

@@ -1,10 +1,11 @@
-import type { TSchema } from "@sayknow-cli/ai";
+import { type TSchema } from "@sayknow-cli/ai";
 import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";
 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;
 /**
  * Stable, total ordering on MCP tools by name.
  *
@@ -48,6 +49,13 @@ export interface MCPDiscoverOptions {
 export interface MCPManagerOptions {
     /** Restrict this instance to tools from an explicit MCP config. */
     toolsOnly?: boolean;
+    /**
+     * Ceiling for the startup wait, in milliseconds. Only ACP lifecycle launches
+     * set this, so a slow ACP MCP handshake gets the readiness budget while every
+     * other consumer keeps the short default. Non-positive or non-finite values
+     * are ignored and the default applies.
+     */
+    maxStartupTimeoutMs?: number;
 }
 /**
  * MCP Server Manager.

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

@@ -52,8 +52,3 @@ export declare class MCPOAuthFlow extends OAuthCallbackFlow {
     }>;
     exchangeToken(code: string, _state: string, redirectUri: string): Promise<OAuthCredentials>;
 }
-/**
- * Refresh an MCP OAuth token using the standard refresh_token grant.
- * Returns updated credentials; preserves the old refresh token if the server doesn't rotate it.
- */
-export declare function refreshMCPOAuthToken(tokenUrl: string, refreshToken: string, clientId?: string, clientSecret?: string): Promise<OAuthCredentials>;

package/dist/types/runtime-mcp/plugin-network-boundary.d.ts

@@ -0,0 +1,14 @@
+import { type AddressResolver } from "../web/insane/url-guard";
+import type { MCPHttpServerConfig, MCPSseServerConfig } from "./types";
+/** Mark an in-memory plugin-bundle remote MCP config for connection-bound public-network enforcement. */
+export declare function bindPluginMcpToPublicNetwork<T extends MCPHttpServerConfig | MCPSseServerConfig>(config: T): T;
+/** The marker is an internal symbol, so persisted user MCP configs cannot opt into or forge this path. */
+export declare function isPluginMcpPublicNetworkBound(config: MCPHttpServerConfig | MCPSseServerConfig): boolean;
+/**
+ * Fetch a plugin-bundle MCP request through a DNS-pinned public address. Every
+ * redirect is handled manually and revalidated before the next connection.
+ */
+export declare function fetchPluginMcpRequest(rawUrl: string, init: BunFetchRequestInit, options?: {
+    resolver?: AddressResolver;
+    maxRedirects?: number;
+}): Promise<Response>;

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

@@ -0,0 +1,2 @@
+export declare function redactMCPEndpoint(value: string | undefined): string | undefined;
+export declare function redactMCPDiagnosticValue(value: unknown): unknown;

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/final-text.d.ts

@@ -0,0 +1,19 @@
+export declare const ACP_FINAL_TEXT_LIMIT = 100000;
+export interface BoundedAcpFinalText {
+    text: string;
+    truncated: boolean;
+}
+export type AcpFinalTextResolution = {
+    kind: "none";
+    final: BoundedAcpFinalText;
+} | {
+    kind: "emit";
+    final: BoundedAcpFinalText;
+    text: string;
+} | {
+    kind: "divergent";
+    final: BoundedAcpFinalText;
+};
+export declare function boundAcpFinalText(value: string): BoundedAcpFinalText;
+export declare function acpFinalTextFromMessage(message: unknown): BoundedAcpFinalText;
+export declare function resolveAcpFinalText(streamed: string, finalText: string): AcpFinalTextResolution;

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

@@ -0,0 +1,23 @@
+export declare const ACP_MCP_REQUEST_TIMEOUT_MS = 30000;
+export declare const ACP_MCP_LIFECYCLE_TIMEOUT_MS: number;
+/**
+ * Slice of the readiness budget reserved for the work that follows MCP startup
+ * (session wiring, marker publication). The ACP MCP startup ceiling is the
+ * remaining time to `semanticReadyDeadlineAt` minus this headroom, so a slow
+ * MCP handshake cannot consume the whole readiness window.
+ */
+export declare const ACP_MCP_STARTUP_HEADROOM_MS = 250;
+export interface SessionLifecycleMcpStdioServer {
+    type?: "stdio";
+    name: string;
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface SessionLifecycleMcpRemoteServer {
+    type: "http" | "sse";
+    name: string;
+    url: string;
+    headers?: Record<string, string>;
+}
+export type SessionLifecycleMcpServer = SessionLifecycleMcpStdioServer | SessionLifecycleMcpRemoteServer;

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

@@ -1,4 +1,5 @@
 import type { NativeDirectoryTreeSnapshot } from "@sayknow-cli/natives";
+import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -93,6 +94,7 @@ export type BrokerResponse = {
     error: {
         code: BrokerErrorCode;
         message: string;
+        details?: ModelProfileErrorDetails;
         endpoint?: "unavailable";
         cleanup?: BrokerCleanupEvidence;
     };

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

@@ -1,3 +1,4 @@
+import type { SessionLifecycleMcpServer } from "../acp/mcp";
 import type { SdkStartupFailure, SdkStartupRollbackResult } from "../startup-capability";
 import type { Broker, BrokerCleanupEvidence, BrokerResponse } from "./broker";
 import type { LifecycleDurableEffectsReceipt, LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -61,6 +62,7 @@ export interface SessionLifecycleLaunchRequest {
     /** Broker-issued effect marker which the child echoes only after host readiness. */
     effectMarker?: string;
     modelPreset?: string;
+    mcpServers?: SessionLifecycleMcpServer[];
     worktree?: SessionLifecycleWorktreeTarget;
     receivedAt: number;
     requestedReadinessTimeoutMs: number;
@@ -70,6 +72,12 @@ 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>;
@@ -79,6 +87,11 @@ export interface LifecycleTranscriptEvidence {
 }
 /** The child writes bounded startup diagnostics before exiting without readiness. */
 export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string): Promise<void>;
+export declare function readSessionLifecycleFailureForTest(root: string, id: string, expected: {
+    pid: number;
+    effectMarker: string;
+    incarnation: string;
+}): Promise<SdkStartupFailure | undefined>;
 export interface LifecycleExecutionOutcome {
     response: BrokerResponse;
     durableEffects?: LifecycleDurableEffectsReceipt;

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

@@ -8,7 +8,15 @@ export type ChatDaemonAction = "stop" | "reload";
  * Generation 6 carries the retained managed filesystem authority boundary.
  * Generation 7 restores macOS daemon signaling (kill(2) with a start-time
  * incarnation recheck) so a live/hung owner can be replaced without an external
- * `kill -9`.
+ * `kill -9`. Generation 8 adopts Windows expected-identity ACL verification and
+ * repair for shared native authority. Generation 9 refreshes the shared native
+ * authority declaration contract with bounded frame-delivery acknowledgement.
+ * Generation 11 accepts typed retained exact-unlink cleanup authority — a
+ * concrete detached quarantine plus a proven-absent canonical lock pathname —
+ * 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.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

@@ -5,8 +5,8 @@
  * removed), but the user can still adjust per-surface behaviour from inside a
  * session thread with small slash commands:
  *
- * - `/verbose`            switch the mirror to bounded tool-owned summaries + provider-displayable reasoning summaries
- * - `/lean`               switch back to lean (assistant text + tool names)
+ * - `/verbose`            switch the mirror to per-turn assistant text + tool summaries + reasoning summaries
+ * - `/lean`               settled assistant answer at idle + immediate ask lead-ins (no intermediate tool-turn flood)
  * - `/verbosity lean|verbose`
  * - `/redact on|off`      toggle redaction of streamed content
  *

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

@@ -287,6 +287,8 @@ export interface RedactableAction {
     question?: string;
     options?: string[];
     summary?: string;
+    /** Optional zero-based recommendation into the authoritative raw options. */
+    recommendedIndex?: number;
 }
 /**
  * When redact is true, strip sensitive content for remote delivery:

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/conversation-store.d.ts

@@ -56,6 +56,7 @@ export declare class ConversationStore<T extends ConversationRecord> {
         pidAlive?: (pid: number) => boolean;
         sleep?: (ms: number) => Promise<void>;
         lockTimeoutMs?: number;
+        platform?: NodeJS.Platform;
     });
     get filePath(): string;
     load(): Promise<ConversationStoreDocument<T>>;

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

@@ -9,6 +9,7 @@ export interface DaemonPaths {
     dir: string;
     lock: string;
     state: string;
+    heartbeat: string;
     ownership: string;
     roots: string;
     steal: string;

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

@@ -29,7 +29,9 @@ 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";
+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";
@@ -204,6 +206,7 @@ interface UnattendedGatePresentation {
     question: string;
     options: string[];
     controls: readonly AskRemoteControl[];
+    recommendedIndex?: number;
     multi: boolean;
     allowEmpty: boolean;
     navigationLabel?: "Next" | "Done";
@@ -296,6 +299,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`. */
@@ -323,6 +328,12 @@ interface SessionRuntime {
     hostStopped: boolean;
     serverStopped: boolean;
     brokerRegistrationReleased: boolean;
+    /** Managed Telegram root registration released during terminal teardown. */
+    notificationRootRegistration?: {
+        settings: Settings;
+        cwd: string;
+        registrationToken?: string;
+    };
     verbosity: "lean" | "verbose";
     sessionTag: string;
     /** Whether the agent loop is currently running (drives the typing indicator). */
@@ -343,6 +354,21 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     } | undefined) => boolean;
+    /** Transitions the authoritative reconciliation record at lifecycle ingress; terminal outcomes settle once. */
+    notePromptReconciliation: (correlation: {
+        commandId: string;
+        turnId: string;
+    } | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }) => void;
+    /** Settles and emits one sanitized correlated prompt failure. */
+    emitPromptFailure: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, error: unknown) => void;
     /** Records correlated lifecycle frames for replay and delivers them only to the accepted requester after acknowledgement. */
     emitPromptLifecycle: (correlation: {
         commandId: string;
@@ -352,6 +378,7 @@ interface SessionRuntime {
         sessionId: string;
         commandId?: string;
         turnId?: string;
+        finalText?: string;
     } | {
         type: "agent_failed";
         sessionId: string;
@@ -385,6 +412,15 @@ interface SessionRuntime {
         text?: string;
         messageRef?: string;
     };
+    /**
+     * Lean-mode deferred final answer: latest assistant text observed at `turn_end`,
+     * emitted once at `agent_end` so intermediate tool-turn narration does not flood
+     * remote clients. Cleared after flush or when replaced by a newer turn.
+     */
+    pendingSettled?: {
+        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. */
@@ -392,7 +428,8 @@ interface SessionRuntime {
     /** Started tool calls awaiting a terminal activity frame, keyed by tool call id. */
     inFlightTools: Map<string, {
         toolName: string;
-        args: unknown;
+        args?: unknown;
+        pendingPhase?: "completed" | "failed" | "cancelled";
     }>;
     /** Cancels the postmortem cleanup that emits `session_closed` on process teardown. */
     cancelPostmortemCleanup: () => void;
@@ -480,12 +517,24 @@ 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: {
         settings: Settings;
         cwd: string;
         sessionId: string;
+        onRegistered?: (registration: RegisterNotificationRootResult) => void;
     }) => Promise<EnsureDaemonResult>;
     ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>;
     /** Suppress auto-delivery for a SKC-spawned child under `sessionScope=primary`. */
@@ -494,7 +543,7 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     /** Whether this host mode can own the root SDK endpoint. Default: true. */
     sdkHostModeSupported?: boolean;
     onSdkRequest?: (kind: "control" | "query", connectionId: string, frame: Record<string, unknown>) => void;
-    runEphemeralTurn?: (promptText: string, signal: AbortSignal) => Promise<{
+    runBtwTurn?: (question: string, signal: AbortSignal) => Promise<{
         replyText: string;
     }>;
     /** Observes settlement of optional session-branch startup after reconciliation completes. */
@@ -505,4 +554,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,37 @@
+/**
+ * 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 PromptCorrelation, type PromptReconciliationStatus, type TurnPromptReconciliation } 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>;
+    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-commands.d.ts

@@ -62,8 +62,9 @@ export declare function normalizeLifecyclePath(value: string): string | undefine
 /**
  * Map a lifecycle response/error to a user-facing Telegram message (G010).
  *
- * Only derives text from sessionId, mode, reason, a safe message, and candidate
- * {sessionId,path} — never a token or prompt. Each error reason gets tailored,
- * actionable copy; an "in progress" pending response is surfaced distinctly.
+ * Only derives text from sessionId, mode, reason, a safe message, the originating
+ * lifecycle verb, and candidate {sessionId,path} — never a token or prompt. Each
+ * error reason gets tailored, actionable copy; an "in progress" pending response
+ * is surfaced distinctly.
  */
-export declare function formatLifecycleOutcome(r: SessionLifecycleResponse): string;
+export declare function formatLifecycleOutcome(r: SessionLifecycleResponse, verb?: LifecycleCommandVerb): string;

package/dist/types/sdk/bus/notification-orchestration.d.ts

@@ -30,6 +30,7 @@ export interface ProposedTelegramIdentityPreflightInput {
     deps?: {
         fs?: TelegramDaemonFs;
         pidAlive?: (pid: number) => boolean;
+        pidIncarnation?: (pid: number) => string | undefined;
     };
 }
 /**

package/dist/types/sdk/bus/notification-service.d.ts

@@ -74,6 +74,40 @@ export interface NotificationStatusReport {
 export declare function buildNotificationStatusReport(settings: Settings): NotificationStatusReport;
 /** Render a status report as human-readable lines (no secrets). */
 export declare function formatNotificationStatusReport(report: NotificationStatusReport): string;
+export interface NotificationEndpointView {
+    sessionId: string;
+    pid: number | undefined;
+    stale: boolean;
+}
+export type NotificationEndpointLiveness = "live" | "dead" | "unknown";
+/**
+ * Classification used by recovery and startup takeover. A file is an endpoint
+ * only when it has endpoint authority fields; lifecycle/audit records are never
+ * candidates for endpoint cleanup.
+ */
+export type NotificationEndpointClassification = {
+    kind: "endpoint";
+    view: NotificationEndpointView;
+    liveness: NotificationEndpointLiveness;
+    identity: NotificationEndpointFileIdentity;
+} | {
+    kind: "non-endpoint";
+} | {
+    kind: "unreadable";
+};
+/**
+ * Classify an endpoint using owner-proof semantics. An endpoint is only `dead`
+ * with positive proof: an explicit `stale` tombstone, or a recorded pid that is
+ * confirmed not alive. A PID-less endpoint is `unknown` (not provably dead) and
+ * must never be treated as dead — removing it could delete a live session's
+ * discovery file that simply omitted a pid.
+ */
+export declare function notificationEndpointLiveness(view: NotificationEndpointView, pidAlive: (pid: number) => boolean): NotificationEndpointLiveness;
+/**
+ * Read and classify one endpoint candidate. The returned identity belongs to
+ * exactly the bytes inspected and is required for any later deletion.
+ */
+export declare function classifyNotificationEndpoint(fs: Pick<NotificationServiceFs, "readEndpointFile">, file: string, pidAlive: (pid: number) => boolean): Promise<NotificationEndpointClassification>;
 export type HealthLevel = "ok" | "warn" | "error";
 export interface HealthCheck {
     name: string;

package/dist/types/sdk/bus/operator-runtime.d.ts

@@ -47,6 +47,7 @@ export declare class NotificationOperatorRuntime {
     stopInterval(name: string): void;
     stopAllIntervals(): void;
     runExclusive(name: string, fn: () => Promise<void>): Promise<void>;
+    joinExclusive(name: string, timeoutMs: number): Promise<boolean>;
     sleep(ms: number, signal?: AbortSignal): Promise<void>;
     now(): number;
 }