@gajae-code/coding-agent 0.13.2 → 0.14.0

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

@@ -24,7 +24,6 @@ export interface ConversationStoreFs {
         mode: number;
     }): Promise<void>;
     rename(from: string, to: string): Promise<void>;
-    link(from: string, to: string): Promise<void>;
     unlink(file: string): Promise<void>;
     open(file: string, flags: string): Promise<ConversationStoreFileHandle>;
     stat?(file: string): Promise<{

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

@@ -16,5 +16,11 @@ export interface DaemonPaths {
     diagnostic: string;
     aliases: string;
     seenUpdates: string;
+    ownerRegistry: string;
+    recoveryReceipt: string;
 }
+export declare function agentDirDigest(agentDir: string): string;
+export declare function telegramDaemonOwnerMarkerPath(agentDir: string, acquisitionId: string): string;
+export declare const daemonOwnerMarkerPath: typeof telegramDaemonOwnerMarkerPath;
+export declare const telegramDaemonProcessMarkerPath: typeof telegramDaemonOwnerMarkerPath;
 export declare function daemonPaths(agentDir: string): DaemonPaths;

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

@@ -8,6 +8,7 @@ export interface DiscordInboundDispatchReceipt {
     actionId?: string;
     actionNonce?: string;
     endpointGeneration: number;
+    attachmentAuthorityId?: string;
     effectId: string;
     idempotencyKey: string;
 }
@@ -25,6 +26,7 @@ export interface DiscordConversation extends ConversationRecord {
     createOwner?: string;
     createLeaseExpiresAt?: number;
     endpointGeneration?: number;
+    attachmentAuthorityId?: string;
     /** Immutable lineage for archive and resume provider effects. */
     effectIncarnationId?: string;
     /** Current archive operation authority. */

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

@@ -1,32 +1,27 @@
+import { type SessionAttachment } from "../router";
 import { type DiscordConversation } from "./discord-conversation";
 import type { DiscordInboundEvent, DiscordProvider } from "./discord-provider";
-export declare class DiscordEndpointBindingError extends Error {
+export declare class DiscordAttachmentBindingError extends Error {
     constructor(message?: string);
 }
-/** A captured live SDK transport. `isCurrent` must fail closed after replacement or removal. */
-export interface DiscordEndpointBinding {
-    generation: number;
-    isCurrent(): boolean;
-    send(frame: Record<string, unknown>): void | Promise<void>;
-}
 export interface DiscordLeaseRecoveryScheduler {
     setTimeout(callback: () => void | Promise<void>, delayMs: number): unknown;
     clearTimeout(handle: unknown): void;
 }
 export interface DiscordNotificationDaemonOptions {
     agentDir: string;
-    repo: string;
     guildId: string;
     parentChannelId: string;
     provider: DiscordProvider;
     now?: () => number;
     leaseRecoveryScheduler?: DiscordLeaseRecoveryScheduler;
-    resolveEndpoint: (sessionId: string, expectedGeneration?: number) => Promise<DiscordEndpointBinding | null>;
-    onCommand?: (sessionId: string, content: string, endpoint: DiscordEndpointBinding, idempotencyKey: string) => Promise<boolean>;
+    resolveAttachment: (sessionId: string, expectedGeneration?: number) => SessionAttachment | null | Promise<SessionAttachment | null>;
+    onCommand?: (sessionId: string, content: string, attachment: SessionAttachment, idempotencyKey: string) => Promise<boolean>;
 }
 export interface DiscordNotificationInput {
     sessionId: string;
     endpointGeneration: number;
+    attachmentAuthorityId?: string;
     content: string;
     threadName?: string;
     actionId?: string;
@@ -38,14 +33,24 @@ export declare class DiscordNotificationDaemon {
     #private;
     private readonly options;
     constructor(options: DiscordNotificationDaemonOptions);
+    restartBlocked(): boolean;
     start(): Promise<void>;
     stop(): Promise<void>;
+    /**
+     * Frame-driven publication work is tracked like inbound events so that stop()
+     * drains it while the Router still holds attachment authority. A session
+     * replayed during teardown otherwise reaches its post-provider binding
+     * revalidation only after Router.stop() has revoked the attachment, turning a
+     * legitimate create into a spurious teardown rejection.
+     */
     notify(input: DiscordNotificationInput): Promise<DiscordConversation>;
     /** Posts a safe command outcome to the active mapped conversation. */
     postCommandResult(sessionId: string, content: string): Promise<boolean>;
-    close(sessionId: string): Promise<void>;
+    close(sessionId: string, endpointGeneration?: number): Promise<void>;
+    recoverCleanup(sessionId: string, endpointGeneration: number): Promise<void>;
+    retireAttachment(sessionId: string, endpointGeneration: number): Promise<void>;
     archive(sessionId: string): Promise<void>;
-    resume(sessionId: string, endpointGeneration: number): Promise<DiscordConversation | undefined>;
+    resume(sessionId: string, endpointGeneration: number, attachmentAuthorityId?: string): Promise<DiscordConversation | undefined>;
     resolveAction(sessionId: string, actionId: string): Promise<void>;
     handleInbound(event: DiscordInboundEvent): Promise<void>;
 }

package/dist/types/sdk/bus/existing-thread-readiness.d.ts

@@ -4,19 +4,14 @@
  * Stock startup publishes a session's readiness immediately, so the running
  * chat daemon surfaces the session and creates its own root before an operator
  * could ever name an existing one. A session that opts in is *prepared*
- * instead: its id, endpoint, and broker registration are discoverable authority
- * while readiness stays withheld, which leaves exactly one root claim for
- * `gjc notify bind-thread` to fill. Activation then publishes readiness once,
- * and the daemon adopts the bound root instead of replacing it.
+ * instead: readiness stays withheld while the provider applies its one root
+ * claim. The SessionRouter owns endpoint authority and activation; this module
+ * only proves that the provider mapping authorizes readiness publication.
  *
  * Nothing here mutates a mapping. The gate only reads the daemon-owned store to
- * prove a binding exists, and the activation client only asks the session's own
- * host to publish the readiness it withheld.
+ * prove a binding exists for the exact session and endpoint generation.
  */
-import type { SessionIndex } from "../broker/session-index";
-import type { SdkSessionEndpoint, SdkSessionEndpointScope } from "../client/discovery";
 import type { SessionActivationGate } from "../host";
-import { type ActivatedPreparedSession, type PreparedSessionActivationClient } from "../session-activation";
 import type { ConversationStore } from "./conversation-store";
 import type { SlackConversation } from "./slack-conversation";
 /** Explicit, session-scoped opt-in for withholding readiness until a root is bound. */
@@ -44,28 +39,3 @@ export interface SlackBindingActivationInput {
  * caller reports unavailable authority instead of an authorization.
  */
 export declare function createSlackBindingActivationGate(input: SlackBindingActivationInput): SessionActivationGate;
-export type { ActivatedPreparedSession, PreparedSessionActivationClient, SessionActivationErrorCode, } from "../session-activation";
-export { requestPreparedSessionActivation, SessionActivationError } from "../session-activation";
-export interface PreparedSessionActivationInput {
-    sessionIndex: SessionIndex;
-    sessionId: string;
-}
-export interface PreparedSessionActivationDeps {
-    readEndpoint?: (repo: string, sessionId: string, scope?: SdkSessionEndpointScope) => Promise<SdkSessionEndpoint | null>;
-    connect?: (endpoint: {
-        url: string;
-        token: string;
-    }) => Promise<PreparedSessionActivationClient>;
-}
-/**
- * Ask a prepared session to publish the readiness it withheld.
- *
- * The same discovery authority the binding requires is resolved first, so an
- * unindexed, terminated, or endpoint-rolled session is refused before any
- * connection is opened. The request names the exact session and endpoint
- * generation, and the answer is accepted only when it proves both, so a
- * replacement session can never be activated in place of the requested one.
- * Activation is idempotent: an exact retry answers `already` without a second
- * readiness signal.
- */
-export declare function activatePreparedSession(input: PreparedSessionActivationInput, deps?: PreparedSessionActivationDeps): Promise<ActivatedPreparedSession>;

package/dist/types/sdk/bus/inbound-reaction-ordering.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure per-update inbound reaction transition ordering.
+ *
+ * Extracted from the Telegram daemon so the serialization and terminal-state
+ * contract is testable without daemon/attachment/topic-lease infrastructure.
+ * The production router dispatches notification frames without awaiting prior
+ * callbacks, so an `accepted` handler can still be in flight when the
+ * `consumed` handler runs. Chaining every transition for one update through a
+ * single promise keeps effects ordered, and skipping nonterminal transitions
+ * after a terminal one makes the terminal state monotonic: a late queued
+ * marker can never overwrite an already-sent consumed marker or retraction.
+ */
+/** A single ordered Bot API reaction transition for one update id. */
+export interface InboundReactionTransition {
+    /** Serialized in submission order per update id. */
+    readonly effect: () => Promise<void>;
+    /** Terminal transitions (consumed / retraction) close the update. */
+    readonly terminal: boolean;
+}
+/**
+ * Terminal tombstones are retained only for a bounded window of recent update
+ * ids. Telegram update ids are monotonically increasing per bot, so a stale
+ * `accepted` ack that could overwrite a terminal state always carries an id at
+ * or below the terminal one; ids far below the window are long-expired updates
+ * whose correction target no longer exists, so the daemon's own target lookup
+ * already ignores them.
+ */
+export declare const INBOUND_REACTION_TOMBSTONE_WINDOW = 512;
+export declare class InboundReactionSequencer {
+    #private;
+    /** True once a terminal transition completed for this update. */
+    isTerminal(updateId: number): boolean;
+    /**
+     * Enqueue one transition. The returned promise settles when the transition
+     * has run (or was skipped because a terminal state already closed it).
+     */
+    apply(updateId: number, transition: InboundReactionTransition): Promise<void>;
+    /** @internal Test-only: number of retained per-update chains. */
+    debugChainCount(): number;
+    /** @internal Test-only: number of retained terminal tombstones. */
+    debugTombstoneCount(): number;
+}
+/** Body for setting an emoji reaction on an inbound Telegram message. */
+export declare function inboundReactionSetPayload(chatId: string, messageId: number, emoji: string): {
+    chat_id: string;
+    message_id: number;
+    reaction: Array<{
+        type: "emoji";
+        emoji: string;
+    }>;
+};
+/**
+ * Body for retracting a reaction. The Bot API clears a bot reaction with the
+ * empty reaction list; an empty `emoji` string is not a valid reaction and is
+ * silently rejected, leaving the stale queued marker visible.
+ */
+export declare function inboundReactionRetractPayload(chatId: string, messageId: number): {
+    chat_id: string;
+    message_id: number;
+    reaction: [];
+};

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

@@ -29,13 +29,30 @@ import type { AskAnswerSource, AskAnswerSourceResult, AskRemoteControl } from ".
 import { type SessionHostRuntimePublication } from "../broker/lifecycle";
 import { type SessionSdkHost } from "../host";
 import { CursorRegistry, RevisionStore } from "../host/query";
+import type { SdkFrame } from "../host/types";
 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";
+import { type EnsureDaemonResult } from "./telegram-daemon";
 export type { IdentityControlSuccessPathInput, IdentityControlTerminalPathInput, TerminalSendOutcome, } from "./control-drain-lease";
 export { isNativeControlDrainAvailable, runIdentityControlSuccessPath, runIdentityControlTerminalPath, } from "./control-drain-lease";
+export type NotificationInboundAdmission = {
+    outcome: "accept";
+} | {
+    outcome: "drop";
+    reason: "inbound_fenced" | "policy_suspended";
+} | {
+    outcome: "defer";
+    reason: "policy_suspended";
+};
+/** Exact production admission decision for daemon-originated session inbound. */
+export declare function notificationInboundAdmission(input: {
+    inboundFenced: boolean;
+    policySuspended: boolean;
+    notificationOrigin: boolean;
+    controlCommand: boolean;
+}): NotificationInboundAdmission;
 type PromptTerminalDiagnostic = {
     reason?: unknown;
     loopStopReason?: string;
@@ -70,10 +87,6 @@ export type SessionCreateTarget = {
 /** Identifies the session a `session_close` targets. */
 export interface SessionCloseTarget {
     sessionId: string;
-    /** Expected GJC-managed tmux session name (defense-in-depth match). */
-    tmuxSession?: string;
-    /** Expected `@gjc-session-state-file` tag (defense-in-depth match). */
-    sessionStateFile?: string;
 }
 /** Identifies the session a `session_resume` targets. */
 export interface SessionResumeTarget {
@@ -81,107 +94,34 @@ export interface SessionResumeTarget {
     /** Optional repo/working-dir hint to disambiguate matches. */
     path?: string;
 }
-/** Create a new session. */
-export interface SessionCreateFrame {
-    type: "session_create";
-    requestId: string;
-    /** Deterministic lifecycle marker preallocated by the daemon before spawn. */
-    lifecycleRequestId: string;
-    /** Session id the daemon preallocated and propagates to the child. */
-    intendedSessionId: string;
-    /** Telegram update id (idempotency key on the daemon side). */
-    updateId: number;
-    chatId: string;
-    /** Control-endpoint token authorizing this frame. */
-    token: string;
-    target: SessionCreateTarget;
-    /** Reserved for a future capability transport; any supplied value is rejected before lifecycle acceptance. */
-    startupPromptRef?: string;
-    /** Model profile preset to activate for the spawned session (--mpreset). */
-    modelPreset?: string;
-}
-/** Close (hard-kill, history preserved) a session. */
-export interface SessionCloseFrame {
-    type: "session_close";
-    requestId: string;
-    updateId: number;
-    chatId: string;
-    token: string;
-    target: SessionCloseTarget;
-    /** Required force-only close flag; false/omitted is rejected by daemon policy. */
-    force?: boolean;
-}
-/** Resume a session (reattach if alive, else cold-restart from history). */
-export interface SessionResumeFrame {
-    type: "session_resume";
-    requestId: string;
-    updateId: number;
-    chatId: string;
-    token: string;
-    target: SessionResumeTarget;
-    /** Reserved for a future capability transport; any supplied value is rejected before lifecycle acceptance. */
-    startupPromptRef?: string;
-}
-/** Any client -> ingress lifecycle request frame. */
-export type SessionLifecycleRequest = SessionCreateFrame | SessionCloseFrame | SessionResumeFrame;
-/** Terminal status of a lifecycle request. */
 export type LifecycleStatus = "ok" | "error";
-/** A connected session's per-session endpoint, returned to the control client. */
-export interface LifecycleEndpoint {
-    url: string;
-    token: string;
-}
-/** The Telegram topic/thread a session is surfaced in. */
-export interface LifecycleTopic {
-    chatId: string;
-    threadId: string;
-}
-/** How a create request was correlated to its spawned session. */
-export type MatchedBy = "spawn_marker" | "session_ready";
-/** Response to a successful `session_create`. */
 export interface SessionCreateResponseFrame {
     type: "session_create_response";
     requestId: string;
     status: LifecycleStatus;
-    lifecycleRequestId: string;
     sessionId: string;
-    matchedBy: MatchedBy;
-    endpoint: LifecycleEndpoint;
-    topic: LifecycleTopic;
     target: SessionCreateTarget;
 }
-/** Response to a successful `session_close`. */
 export interface SessionCloseResponseFrame {
     type: "session_close_response";
     requestId: string;
     status: LifecycleStatus;
     sessionId: string;
-    processGone: boolean;
-    historyPreserved: boolean;
-    endpointStale: boolean;
 }
-/** Whether a resume reattached to a live session or cold-restarted a dead one. */
 export type ResumeMode = "reattached" | "cold_restarted";
-/** Response to a successful `session_resume`. */
 export interface SessionResumeResponseFrame {
     type: "session_resume_response";
     requestId: string;
     status: LifecycleStatus;
     sessionId: string;
     mode: ResumeMode;
-    endpoint: LifecycleEndpoint;
-    topic: LifecycleTopic;
 }
-/** Machine-readable reason a lifecycle request failed. */
 export type LifecycleErrorReason = "unauthorized" | "rate_limited" | "duplicate_conflict" | "invalid_target" | "ambiguous_target" | "spawn_failed" | "discovery_timeout" | "readiness_timeout" | "close_refused" | "not_found" | "terminal_uncertain" | "unsupported_platform";
-/** A candidate returned with an `ambiguous_target` resume error. */
 export interface ResumeCandidate {
     sessionId: string;
     path?: string;
-    /** Last-activity epoch-millis (session history file mtime), if known. */
     mtimeMs?: number;
 }
-/** A structured lifecycle error frame. */
 export interface SessionLifecycleErrorFrame {
     type: "session_lifecycle_error";
     requestId: string;
@@ -190,7 +130,6 @@ export interface SessionLifecycleErrorFrame {
     message: string;
     candidates?: ResumeCandidate[];
 }
-/** Any ingress -> client lifecycle response frame. */
 export type SessionLifecycleResponse = SessionCreateResponseFrame | SessionCloseResponseFrame | SessionResumeResponseFrame | SessionLifecycleErrorFrame;
 /**
  * Replayable per-session readiness signal (mirror of the Rust `session_ready`
@@ -327,6 +266,9 @@ export declare class PresentationArbiter {
 interface SessionRuntime {
     server: NotificationServer;
     host: SessionSdkHost;
+    /** Delivers one ring-positioned event envelope to every attached subscriber
+     *  connection, applying the same capability gate as event replay. */
+    broadcastEventFrame: (event: SdkFrame) => void;
     /** Owns stateRoot-backed revisions and removes their spills on terminal shutdown. */
     revisions: RevisionStore;
     /** Releases all snapshot pins before the revision store is closed. */
@@ -336,6 +278,8 @@ interface SessionRuntime {
     /** Discovery scope is fixed before publication; a live default endpoint is never rotated in place. */
     endpointScope: "default" | "chat";
     idleSeq: number;
+    /** Stops delayed session-name observation when this runtime loses authority. */
+    stopSessionNameObserver: () => void;
     /** Interactive asks awaiting a remote answer, by action id. */
     pendingInteractive: Map<string, PendingInteractiveAsk>;
     /** Deregisters this session's ask answer source. */
@@ -348,6 +292,12 @@ interface SessionRuntime {
     notificationsActive: boolean;
     /** Provider ownership state is independent from the already-published core SDK runtime. */
     notificationOwnerState: "ready" | "retry" | "blocked";
+    /**
+     * Ownership-relevant configuration identity this runtime's owner state was
+     * proved under. A settled outcome may only be applied while it still matches,
+     * so a credential/destination/enablement change forces a re-proof.
+     */
+    notificationOwnerKey?: string;
     /** Rejects new SDK frames while a leased terminal response drains. */
     inboundFenced: boolean;
     /** Set as soon as terminal teardown is requested, before startup settles. */
@@ -381,12 +331,6 @@ interface SessionRuntime {
     /** This runtime's own host-liveness publication; only its teardown may retract it. */
     evidencePublication?: SessionHostRuntimePublication;
     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). */
@@ -396,6 +340,11 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     }>;
+    /** SDK run tokens bind an accepted queued follow-up to only its matching agent_start. */
+    pendingPromptCorrelationsBySdkRunToken: Map<string, {
+        commandId: string;
+        turnId: string;
+    }>;
     /** Identity bound to the agent lifecycle currently in flight. */
     activePromptCorrelation?: {
         commandId: string;
@@ -425,7 +374,7 @@ interface SessionRuntime {
     } | {
         type: "agent_failed";
         error: unknown;
-    }) => void;
+    }) => void | Promise<void>;
     /** Settles and emits one sanitized correlated prompt failure. */
     emitPromptFailure: (correlation: {
         commandId: string;
@@ -473,17 +422,33 @@ interface SessionRuntime {
     turnClosed?: boolean;
     /** Finalized while provisional policy was held; flush exactly once on stable activation. */
     pendingFinal?: {
-        text?: string;
-        messageRef?: string;
+        window: number;
+        receipts: Array<{
+            text: string;
+            messageRef?: string;
+            origin: "user" | "autonomous" | "continuation";
+        }>;
     };
+    /** Monotonic user-request boundary for deferred lean delivery. */
+    settlementWindow: number;
+    /** Provenance of the currently executing assistant turn. */
+    currentTurnSettlementOrigin?: "user" | "autonomous" | "continuation";
+    /** Immutable settlement boundary captured when the current turn begins. */
+    currentTurnSettlementWindow?: number;
     /**
-     * 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.
+     * Lean-mode deferred receipts for the current user-request settlement window.
+     * Ordinary tool-loop turns retain latest-turn-wins behaviour. An autonomous
+     * continuation has no new user request, so it appends instead of erasing the
+     * prior receipt. The small fixed receipt bound prevents an unbounded idle wait
+     * from retaining the full transcript.
      */
     pendingSettled?: {
-        text: string;
-        messageRef?: string;
+        window: number;
+        receipts: Array<{
+            text: string;
+            messageRef?: string;
+            origin: "user" | "autonomous" | "continuation";
+        }>;
     };
     /** SDK control frames received during provisional ownership; replayed only after stable activation. */
     deferredInboundControls: Array<() => void>;
@@ -594,9 +559,13 @@ export declare class EphemeralTurnHost {
     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.
+ * Ensures every configured chat-provider daemon is ready.
+ *
+ * This runs strictly AFTER the SDK publishes session identity and its core
+ * endpoint, through the detached ownership coordinator: chat providers are
+ * optional notification adapters, never session authority. A rejected ensure
+ * therefore degrades notification delivery only — the coordinator records it
+ * as `failed`, adapters stay withheld, and a later reconcile re-attempts.
  */
 export declare function ensureConfiguredProviderDaemons(settings: Settings, cfg: NotificationConfig, ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>): Promise<void>;
 /**
@@ -614,9 +583,6 @@ 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 GJC-spawned child under `sessionScope=primary`. */
@@ -635,4 +601,24 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     }) => void;
     readNotificationFile?: (path: string) => Promise<Buffer>;
     readNotificationDiffStat?: (cwd: string) => Promise<string | undefined>;
+    /**
+     * INTERNAL terminal-abort session seams, threaded directly from the owning
+     * session — deliberately NOT on the public ExtensionContext so third-party
+     * extensions cannot observe attempt epochs or cancel the session-global
+     * preflight outside the durable admission path (review thread P2).
+     */
+    terminalAbortSeams?: {
+        getTerminalTurnEpoch: () => number | undefined;
+        cancelPendingPreflightForTerminalAbort: () => void;
+        captureTerminalAbortSteeringSnapshot?: () => void;
+        discardTerminalAbortSteeringSnapshot?: (token: number) => void;
+        rebindTerminalAbortSteeringSnapshot?: (token: number) => void;
+        abortPromptAndWaitWithTerminal: (handle: string, options: {
+            graceMs: number;
+            terminal?: {
+                scope: "turn" | "owned";
+                expectedEpoch?: number;
+            };
+        }) => Promise<RunSettlementProof>;
+    };
 }): void;

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

@@ -1,8 +1,5 @@
-/**
- * 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 { ReceiptState } from "../receipt-state";
 import { type TurnResultContent, type TurnResultPage } from "../turn-result";
 import { type PromptCorrelation } from "./prompt-reconciliation";
 import type { ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
@@ -11,6 +8,18 @@ export interface KindCorrelation extends PromptCorrelation {
     kind: ReconciliationKind;
     content?: TurnResultContent;
 }
+export interface SteerReconciliationResult {
+    commandId: string;
+    turnId: string;
+    clientRef: string;
+    status: "accepted" | "rejected" | "uncertain";
+    acceptedAt: number;
+    terminalAt?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
 export interface KindAwareReconciliation {
     admit(kind: ReconciliationKind, clientRef?: string): void;
     releaseAdmission(kind: ReconciliationKind, clientRef?: string): void;
@@ -25,12 +34,12 @@ export interface KindAwareReconciliation {
         error: unknown;
         content?: TurnResultContent;
     }): Promise<void>;
-    claimPendingOutcome(correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome): Promise<SdkPromptTerminalOutcome>;
-    finalizePromptOutcome(correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {
+    claimPendingOutcome(kind: ReconciliationKind, correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome, receiptState?: Extract<ReceiptState, "present" | "missing">): Promise<SdkPromptTerminalOutcome>;
+    finalizeOutcome(kind: ReconciliationKind, correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {
         code: string;
         message: string;
     }, content?: unknown): Promise<void>;
-    peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
+    peekPendingOutcome(kind: ReconciliationKind, correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
     lookup(kind: ReconciliationKind, selector: {
         commandId?: string;
         turnId?: string;
@@ -41,6 +50,19 @@ export interface KindAwareReconciliation {
         turnId?: string;
         clientRef?: string;
     }): TurnResultPage;
+    reserveSteer(clientRef: string, text: string): Promise<{
+        replay: boolean;
+        result: SteerReconciliationResult;
+    }>;
+    settleSteer(clientRef: string, status: "accepted" | "rejected" | "uncertain", error?: unknown): Promise<SteerReconciliationResult>;
+    lookupSteer(selector: string | {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): SteerReconciliationResult | {
+        clientRef?: string;
+        status: "unknown";
+    };
     cleanup(): void;
     activeCount(kind: ReconciliationKind): number;
     /** Hydrate from durable store (call once at session host start). */

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

@@ -1,48 +1,18 @@
-import type { Settings } from "../../config/settings";
 import { RateLimitPool } from "./rate-limit-pool";
 import { type ThreadedSend } from "./threaded-render";
-export interface ManagedNotificationDaemonFs {
-    readdir(path: string): Promise<string[]>;
-}
-export interface ManagedSessionSocket {
-    sessionId: string;
-    token: string;
-    ws: WebSocket;
-    pending: Map<string, {
-        sessionId: string;
-        actionId: string;
-    }>;
-    capable: boolean;
-    lastPongAt: number;
-    awaitingNonce: string | undefined;
-    pingTimer: ReturnType<typeof setInterval> | undefined;
-}
+/** Shared presentation engine for managed notification providers. */
 export interface ManagedNotificationDaemonOptions {
-    settings: Settings;
-    fs: ManagedNotificationDaemonFs;
-    WebSocketImpl?: typeof WebSocket;
     now?: () => number;
-    setIntervalImpl?: typeof setInterval;
-    clearIntervalImpl?: typeof clearInterval;
     rateLimitPool?: RateLimitPool<{
         send: ThreadedSend;
         topicId?: string;
     }>;
 }
 export declare abstract class ManagedNotificationDaemon {
-    protected readonly opts: ManagedNotificationDaemonOptions;
-    readonly sessions: Map<string, ManagedSessionSocket>;
     readonly pool: RateLimitPool<{
         send: ThreadedSend;
         topicId?: string;
     }>;
-    protected constructor(opts: ManagedNotificationDaemonOptions);
-    scanRoots(): Promise<void>;
-    connectSession(sessionId: string, url: string, token: string): ManagedSessionSocket;
-    protected handleSessionMessage(session: ManagedSessionSocket, msg: Record<string, unknown>): Promise<boolean>;
+    protected constructor(opts?: ManagedNotificationDaemonOptions);
     protected renderFrame(frame: Record<string, unknown>): ThreadedSend | undefined;
-    protected dropSession(session: ManagedSessionSocket): void;
-    protected abstract readRoots(): Promise<string[]>;
-    private sendHello;
-    private startLiveness;
 }