@gajae-code/coding-agent 0.13.3 → 0.14.0

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

@@ -1,11 +1,14 @@
 import type { PromptReconciliationStatus, SdkPromptTerminalOutcome } from "../prompt-status";
+import type { ReceiptState } from "../receipt-state";
 import { type TurnResultContent } from "../turn-result";
 import type { PromptCorrelation } from "./prompt-reconciliation";
-export declare const RECONCILIATION_STORE_VERSION = 1;
+export declare const RECONCILIATION_STORE_VERSION = 2;
+export declare const RECONCILIATION_STORE_VERSION_V1 = 1;
 export declare const RECONCILIATION_SESSION_ID_PATTERN: RegExp;
 export declare const RECONCILIATION_DIR_NAME = ".sdk-reconciliation";
-export type ReconciliationKind = "prompt" | "skill";
-export interface DurableReconciliationRecord extends PromptCorrelation {
+export declare function resolveReconciliationSessionFile(sessionFile: string | undefined | null, stateRoot: string, sessionId: string): string;
+export type ReconciliationKind = "prompt" | "skill" | "terminal";
+export interface DurableExecutionReconciliationRecord extends PromptCorrelation {
     kind: ReconciliationKind;
     clientRef?: string;
     status: PromptReconciliationStatus;
@@ -17,15 +20,98 @@ export interface DurableReconciliationRecord extends PromptCorrelation {
     startedAt?: number;
     terminalAt?: number;
     outcome?: SdkPromptTerminalOutcome;
+    receiptState?: Exclude<ReceiptState, "absent">;
     pendingOutcome?: SdkPromptTerminalOutcome;
+    pendingReceiptState?: Extract<ReceiptState, "present" | "missing">;
     /** Skill-only safe token; never skill args bodies. */
     skillName?: string;
     content?: TurnResultContent;
 }
+/**
+ * Durable terminal scope record (approved abort-SDK plan, v2 document).
+ * Bounded origin/fence and owned-settlement fields only; no prompt text and no
+ * suppressed/deferred receipts for left-running turn work.
+ */
+export interface DurableTerminalScopeRecord {
+    selection: "turn" | "owned";
+    /** SHA-256 of the bounded idempotency key; the raw key is never persisted. */
+    idempotencyKeyHash?: string;
+    /** SHA-256 of the canonicalized normalized input; raw input is never persisted. */
+    idempotencyInputHash?: string;
+    turnDisposition: "pending" | "stopped" | "uncertain" | "no_effect" | "no_effect_reserved" | "no_effect_marker_failure";
+    /** Whether the correlated agent_end event was published (AC 19). */
+    terminalPublished?: boolean;
+    ownedWorkDisposition: "not_requested" | "left_running" | "stopped" | "uncertain";
+    automaticDeliveryDisposition: "enabled" | "none";
+    resumeOnOwnedCompletion: boolean;
+    turnContinuationFence: {
+        state: "retained" | "released";
+        abortedAttemptEpoch: number;
+        blockedContinuationIds: string[];
+        predecessorTombstones: string[];
+        ownedCompletionPolicy: "enabled" | "disabled";
+    };
+    ownedDeliverySettlements?: Array<{
+        keyHash: string;
+        entryIdHash: string;
+        status: "settled" | "absent" | "uncertain";
+        observedAt: number;
+    }>;
+    responseState: "pending" | "sent" | "delivered" | "failed";
+    responsePayloadHash: string;
+    /** Hash of the replay-shaped public result a same-key retry delivers, when
+     *  it differs from the original response (the replay appends metadata). */
+    replayPayloadHash?: string;
+    acceptedAt: number;
+    terminalAt?: number;
+}
+/** Compact evicted-key tombstone with enough disposition metadata to
+ *  reconstruct the original terminal replay result (review thread P2). */
+export interface EvictedTerminalKeyEntry {
+    keyHash: string;
+    inputHash: string;
+    turnDisposition?: "stopped" | "uncertain" | "no_effect" | "no_effect_reserved" | "no_effect_marker_failure";
+    ownedWorkDisposition?: "not_requested" | "left_running" | "stopped" | "uncertain";
+    responseState?: "pending" | "sent" | "delivered" | "failed";
+    responsePayloadHash?: string;
+    replayPayloadHash?: string;
+    terminalPublished?: boolean;
+}
+export interface DurableSteerReconciliationRecord {
+    kind: "steer";
+    clientRef: string;
+    textDigest: string;
+    createdAt: number;
+    status: "dispatching" | "accepted" | "rejected" | "uncertain";
+    settledAt?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+    commandId: string;
+    turnId: string;
+    acceptedAt: number;
+    startedAt?: never;
+    terminalAt?: never;
+    outcome?: never;
+    receiptState?: never;
+    pendingOutcome?: never;
+    pendingReceiptState?: never;
+    skillName?: never;
+}
+export type DurableReconciliationRecord = DurableExecutionReconciliationRecord | DurableSteerReconciliationRecord;
 export interface ReconciliationStoreDocument {
     version: typeof RECONCILIATION_STORE_VERSION;
     sessionId: string;
     records: DurableReconciliationRecord[];
+    terminalScopes?: DurableTerminalScopeRecord[];
+    /**
+     * Compact key tombstones for completed terminal rows evicted by the
+     * retention cap: the key hash is retained durably so a same-key retry
+     * after dispatch-cache expiry/restart still replays instead of aborting an
+     * unrelated later prompt (review thread P2).
+     */
+    evictedTerminalKeys?: EvictedTerminalKeyEntry[];
 }
 export interface ReconciliationStoreFs {
     mkdir(directory: string, options: {
@@ -49,9 +135,15 @@ export declare function isSafeReconciliationSessionId(sessionId: string): boolea
 export declare function reconciliationStorePath(sessionFile: string, sessionId: string): string;
 /**
  * Settle non-terminal durable records after process death.
- * Prompt records preserve a durable pending outcome; skills retain the existing
- * reconciliation-incomplete result.
+ * Any record with a durable pending outcome preserves that exact terminal claim;
+ * outcome-less skills retain the existing reconciliation-incomplete result.
+ */
+/**
+ * Settle incomplete terminal scopes (turnDisposition "pending") to safe
+ * uncertainty after process death. A terminal scope that never finalized its
+ * semantic CAS replays as uncertainty, never as success.
  */
+export declare function settleTerminalScopeRestart(scopes: DurableTerminalScopeRecord[], now: number): DurableTerminalScopeRecord[];
 export declare function settleProcessRestart(records: DurableReconciliationRecord[], now: number): DurableReconciliationRecord[];
 export interface ReconciliationStore {
     readonly path: string | null;
@@ -61,6 +153,22 @@ export interface ReconciliationStore {
     load(): Promise<DurableReconciliationRecord[]>;
     /** Snapshot currently held in memory after last load/transact. */
     snapshot(): DurableReconciliationRecord[];
+    /** Terminal-scope mutations through the same serialized full-document owner. */
+    transactTerminalScopes(mutator: (scopes: DurableTerminalScopeRecord[]) => DurableTerminalScopeRecord[]): Promise<void>;
+    transactTerminalState(mutator: (state: {
+        scopes: DurableTerminalScopeRecord[];
+        keys: EvictedTerminalKeyEntry[];
+    }) => {
+        scopes: DurableTerminalScopeRecord[];
+        keys: EvictedTerminalKeyEntry[];
+    }): Promise<void>;
+    /** Wait until every previously admitted reconciliation transaction settles. */
+    drain?(): Promise<void>;
+    transactTerminalKeys(mutator: (keys: EvictedTerminalKeyEntry[]) => EvictedTerminalKeyEntry[]): Promise<void>;
+    snapshotTerminalKeys(): EvictedTerminalKeyEntry[];
+    loadTerminalScopes(): Promise<DurableTerminalScopeRecord[]>;
+    /** Snapshot of terminal scopes currently held in memory. */
+    snapshotTerminalScopes(): DurableTerminalScopeRecord[];
     delete(): Promise<void>;
 }
 export declare function createReconciliationStore(options: {

package/dist/types/sdk/bus/session-control.d.ts

@@ -14,7 +14,17 @@ export interface BoundNotificationSession<Context extends NotificationSessionCon
     unbind(): void;
 }
 export type NotificationEndpointStartResult = "started" | "already" | "disabled" | "failed";
-export type TelegramDaemonPreflightResult = "ready" | "blocked_identity" | "failed";
+/**
+ * Outcome of the Telegram daemon preflight.
+ *
+ * `pending` means ownership acquisition is in flight and was deliberately NOT
+ * awaited: chat daemons are optional notification adapters, never session
+ * authority, so reconciliation on an awaited session-lifecycle path must never
+ * block on one. A pending preflight neither stops the runtime nor marks it
+ * blocked — the runtime starts, adapters stay withheld while the owner state is
+ * not ready, and the ensure's settle callback re-reconciles.
+ */
+export type TelegramDaemonPreflightResult = "ready" | "pending" | "blocked_identity" | "failed";
 /**
  * The endpoint implementation is deliberately injected. The controller owns
  * policy and session-local state while the extension continues to own its
@@ -24,6 +34,20 @@ export interface NotificationSessionRuntime<Context extends NotificationSessionC
     isRunning(binding: BoundNotificationSession<Context>): boolean;
     start(binding: BoundNotificationSession<Context>): Promise<NotificationEndpointStartResult>;
     stop(binding: BoundNotificationSession<Context>): Promise<boolean>;
+    /**
+     * Provider-neutral ownership re-proof, called for ANY effective chat
+     * provider before the Telegram-specific preflight.
+     *
+     * A credential, destination, or actor-authorization change invalidates the
+     * ownership proof that authorized this runtime's adapters. The runtime must
+     * withhold its LOCAL adapters until the new identity is proved. It does NOT
+     * revoke an already-attached external chat daemon's SessionRouter
+     * attachment, so such a daemon can still observe host events and reach the
+     * host's inbound/control paths during the window; closing that requires an
+     * authenticated chat-attachment authority boundary at the Router layer.
+     * Implementations must not await the daemon ensure itself.
+     */
+    reproveOwnership?(binding: BoundNotificationSession<Context>): Promise<void>;
     /**
      * Proves the complete Telegram owner identity before a generic endpoint can
      * emit a frame. `blocked_identity` is fail-closed and starts nothing.

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

@@ -9,6 +9,7 @@ export interface SlackInboundDispatchReceipt {
     actionId?: string;
     /** The endpoint generation and SDK effect captured before Socket Mode ACK. */
     endpointGeneration: number;
+    attachmentAuthorityId?: string;
     /** Identifier of the protected journal payload; mappings never retain message bodies. */
     effectId: string;
     idempotencyKey: string;
@@ -22,7 +23,10 @@ export interface SlackConversation extends ConversationRecord {
     rootTs?: string;
     sessionId?: string;
     endpointGeneration?: number;
+    attachmentAuthorityId?: string;
     clientMsgId?: string;
+    /** Exact pending Router-removal cleanup; cleared only after the mapping close CAS commits. */
+    cleanupEffectId?: string;
     /** Exclusive, expiring authority for provider reconciliation/publication of the root intent. */
     rootPublicationOwner?: string;
     rootPublicationLeaseExpiresAt?: number;

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

@@ -1,4 +1,4 @@
-import { type SdkSessionEndpoint } from "../client/discovery";
+import { type SessionAttachment } from "../router";
 import { ConversationStore } from "./conversation-store";
 import { type SlackConversation } from "./slack-conversation";
 export type { SlackThreadBindingErrorCode } from "./slack-thread-binding";
@@ -7,16 +7,10 @@ export declare class SlackEndpointBindingError extends Error {
     constructor(message?: string);
 }
 import type { SlackProvider, SlackSocketEnvelope } from "./slack-provider";
-export interface SlackEndpoint extends SdkSessionEndpoint {
-    generation: number;
-}
-export interface SlackSdkClient {
-    send(frame: Record<string, unknown>): void;
-}
-/** Proven right to bind one session at one endpoint generation. */
 export interface SlackBindingAuthority {
     sessionId: string;
     endpointGeneration: number;
+    attachmentAuthorityId?: string;
 }
 export interface SlackNotificationDaemonOptions {
     agentDir: string;
@@ -33,15 +27,10 @@ export interface SlackNotificationDaemonOptions {
     /** Stable identity for the process attempting durable provider publication. */
     publicationOwnerId?: string;
     publicationLeaseMs?: number;
-    resolveEndpoint?: (sessionId: string) => Promise<SlackEndpoint | null>;
-    /**
-     * Exact discovery/attachment authority for adopting an existing root. The
-     * runtime supplies index, endpoint, and attachment proof; without it only the
-     * resolvable endpoint generation can be proven.
-     */
+    resolveAttachment: (sessionId: string) => Promise<SessionAttachment | null>;
+    /** Exact Router proof for adopting an existing root. */
     resolveBindingAuthority?: (sessionId: string) => Promise<SlackBindingAuthority | undefined>;
-    createClient: (endpoint: SlackEndpoint) => SlackSdkClient;
-    onCommand?: (sessionId: string, content: string, endpoint: SlackEndpoint, idempotencyKey: string) => Promise<boolean>;
+    onCommand?: (sessionId: string, content: string, attachment: SessionAttachment, idempotencyKey: string) => Promise<boolean>;
 }
 /**
  * Slack Socket Mode notification daemon. Accepted inbound SDK effects are
@@ -54,6 +43,7 @@ export declare class SlackNotificationDaemon {
     private readonly options;
     readonly store: ConversationStore<SlackConversation>;
     constructor(options: SlackNotificationDaemonOptions);
+    restartBlocked(): boolean;
     start(): Promise<void>;
     stop(): Promise<void>;
     /** Accepted inbound effects are durably claimed before their Socket Mode ACK. */
@@ -78,7 +68,9 @@ export declare class SlackNotificationDaemon {
     /** Posts a safe command outcome to the active mapped root thread. */
     postCommandResult(sessionId: string, content: string): Promise<boolean>;
     resolveAction(sessionId: string, actionId: string): Promise<void>;
-    close(sessionId: string, marker?: string): Promise<boolean>;
+    close(sessionId: string, marker?: string, endpointGeneration?: number): Promise<boolean>;
+    recoverCleanup(sessionId: string, endpointGeneration: number): Promise<void>;
+    retireAttachment(sessionId: string, endpointGeneration: number): Promise<void>;
     resume(sessionId: string, body: string, endpointGeneration?: number, publicationId?: string): Promise<SlackConversation>;
     findSession(sessionId: string, includeInactive: boolean): Promise<{
         key: string;

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

@@ -28,7 +28,7 @@ export interface SlackLiveProviderOptions {
     fetch?: (input: string, init?: RequestInit) => Promise<Response>;
     webSocket?: (url: string) => SlackWebSocket;
     now?: () => number;
-    sleep?: (milliseconds: number) => Promise<void>;
+    sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
     reconnectDelayMs?: number;
     maxRateLimitRetries?: number;
     maxRetryAfterMs?: number;
@@ -57,11 +57,13 @@ export declare class SlackLiveProvider implements SlackProviderClient, SlackDiag
         text: string;
         threadTs?: string;
         clientMsgId: string;
+        signal?: AbortSignal;
     }): Promise<SlackPostedMessage>;
     findMessageByClientMsgId(input: {
         channel: string;
         clientMsgId: string;
         threadTs?: string;
+        signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
     /**
      * Confirm that `ts` addresses a real message in `channel`. Slack answers

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

@@ -44,11 +44,13 @@ export interface SlackProviderClient {
         text: string;
         threadTs?: string;
         clientMsgId: string;
+        signal?: AbortSignal;
     }): Promise<SlackPostedMessage>;
     findMessageByClientMsgId?(input: {
         channel: string;
         clientMsgId: string;
         threadTs?: string;
+        signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
     /**
      * Prove that an operator-supplied timestamp addresses a real message in the
@@ -77,11 +79,13 @@ export declare class SlackProvider {
         text: string;
         threadTs?: string;
         clientMsgId: string;
+        signal?: AbortSignal;
     }): Promise<SlackPostedMessage>;
     findMessageByClientMsgId(input: {
         channel: string;
         clientMsgId: string;
         threadTs?: string;
+        signal?: AbortSignal;
     }): Promise<SlackMessageSearchResult | null>;
     /** Fail-closed root verification: a client without this capability can never confirm a root. */
     findMessageByTimestamp(input: {

package/dist/types/sdk/bus/slack-thread-binding.d.ts

@@ -7,17 +7,15 @@
  *  2. *Daemon*: only the running owner may mutate mappings, and only while it is
  *     still the exact owner (`ownerId`/`pid`/`incarnation`/daemon generation)
  *     captured before the request was published.
- *  3. *Session*: the SDK session must be attachable right now — indexed, live,
- *     non-terminal, with a readable, non-stale endpoint whose pid matches the
- *     indexed host and whose generation has not rolled.
+ *  3. *Session*: the running daemon supplies a redacted Router authority proving
+ *     the exact session and endpoint generation; this module never resolves an
+ *     endpoint or retains its credentials.
  *
  * Provider verification happens before any lock is taken, and the mapping commit
- * re-proves session authority inside the store lock, so an authority that
- * changes mid-flight leaves no mapping behind.
+ * re-proves daemon and session authority inside the store lock, so an authority
+ * that changes mid-flight leaves no mapping behind.
  */
 import type { Settings } from "../../config/settings";
-import type { SessionIndex } from "../broker/session-index";
-import { type SdkSessionEndpoint, type SdkSessionEndpointScope } from "../client/discovery";
 import { type EnsureChatDaemonResult } from "./chat-daemon-control";
 import { ConversationStore } from "./conversation-store";
 import { type SlackConversation } from "./slack-conversation";
@@ -30,39 +28,6 @@ export declare class SlackThreadBindingError extends Error {
 export declare function isBoundedSlackRootTs(value: string): boolean;
 /** Reject a non-addressable root before any authority read or persistence. */
 export declare function assertBoundedSlackRootTs(rootTs: string): void;
-export interface SlackSessionBindingAuthority {
-    sessionId: string;
-    endpointGeneration: number;
-    pid: number;
-    repo: string;
-    /**
-     * The exact endpoint this authority was proven against. Callers must use it
-     * rather than re-reading discovery: a second read can observe a different
-     * process whose endpoint generation happens to repeat, and the numeric
-     * generation alone cannot tell the two apart.
-     */
-    endpoint: SdkSessionEndpoint;
-    scope: SdkSessionEndpointScope;
-    endpointMtimeMs: number;
-}
-export interface SessionBindingAuthorityInput {
-    sessionIndex: SessionIndex;
-    sessionId: string;
-    readEndpoint?: (repo: string, sessionId: string, scope?: SdkSessionEndpointScope) => Promise<SdkSessionEndpoint | null>;
-    statEndpoint?: (endpointPath: string) => Promise<{
-        mtimeMs: number;
-    } | undefined>;
-}
-/**
- * Resolve exact discovery/attachment authority for one session.
- *
- * `IndexedSession.live` alone is only pid liveness, which a terminated or
- * unregistered session can still satisfy through pid reuse or a stale record.
- * Adoption additionally requires an intact index replay, a non-terminal record,
- * and a discovery endpoint that is present, well-formed, not marked stale, and
- * owned by the same host pid the index recorded.
- */
-export declare function resolveSessionBindingAuthority(input: SessionBindingAuthorityInput): Promise<SlackSessionBindingAuthority | undefined>;
 export interface SlackThreadClaimInput {
     store: ConversationStore<SlackConversation>;
     /** The session root-claim key shared with stock root publication. */
@@ -72,6 +37,7 @@ export interface SlackThreadClaimInput {
     sessionId: string;
     rootTs: string;
     endpointGeneration: number;
+    attachmentAuthorityId?: string;
     /**
      * Re-proves session authority inside the store lock, immediately before
      * commit. It may be invoked more than once for one claim: authority here is

package/dist/types/sdk/bus/telegram-adoption-intent.d.ts

@@ -1,41 +1,17 @@
 /**
- * Durable, non-routable sidecar store for "adopt a user-created Telegram forum
- * topic into a preallocated session" intents.
+ * Durable provider-local reservations for Telegram topic adoption.
  *
- * When a user creates a new forum topic, the daemon first records durable
- * pending-topic authorization. After folder selection it preallocates an
- * `intendedSessionId` and records an adoption intent here *before* spawning.
- * Later, the authenticated `ensureTopic` create callback reads that intent and
- * returns the user's existing topicId to `TopicRegistry.getOrCreateTopic`, which
- * is the only authority that commits a topic binding. This keeps the intent out
- * of routing/endpoint authority until commit, so a failed spawn or a late socket
- * never deletes the user's topic and never strands a duplicate.
- *
- * Invariants (see `pending-approval.md`):
- * - One file per intent, named `<intendedSessionId>.adoption-intent.json` under
- *   the daemon notifications dir. Sweep touches files only; never the Telegram API.
- * - Only `{ intendedSessionId, topicId, chatId, target, createdAt, expiresAt }`
- *   is persisted. Bot/control tokens and endpoint digests are never stored.
- * - Owner-only dir (0o700) and 0o600 files; atomic temp→fsync→chmod→rename→parent sync.
- * - `tryClaim` is a synchronous, in-memory claim keyed by topicId; it excludes a
- *   second `intendedSessionId` from winning the same topic across awaits. It
- *   does not delete the sidecar; `releaseClaim` re-enables retry on commit failure.
+ * A reservation is keyed by the stable provider request identity, never by a
+ * preallocated Broker SessionId.  Broker allocates the SessionId; the daemon
+ * CAS-binds that opaque value only after the lifecycle service returns it.
+ * This store owns only presentation mappings and pending-topic authorization.
  */
 import type { SessionCreateTarget } from "./index";
-/** Persisted document version. */
-export declare const TELEGRAM_ADOPTION_INTENT_VERSION = 1;
+export declare const TELEGRAM_ADOPTION_INTENT_VERSION = 2;
 export type TelegramAdoptionTarget = Extract<SessionCreateTarget, {
     kind: "existing_path";
 }>;
-/** Default intent TTL (configurable at write time). Plan starts at 10 minutes. */
 export declare const DEFAULT_ADOPTION_INTENT_TTL_MS: number;
-/**
- * Minimal async filesystem surface the store needs. Structurally a subset of the
- * daemon's `TelegramDaemonFs` / `ConversationStoreFs`, so the daemon can pass its
- * own `fs` straight through and tests can inject a fake. `open`/`sync`/`close`
- * mirror `ConversationStoreFileHandle` so the atomic fsync path reuses the same
- * shape as the conversation store.
- */
 export interface AdoptionIntentFs {
     mkdir(directory: string, options: {
         recursive: true;
@@ -55,43 +31,34 @@ export interface AdoptionIntentFileHandle {
     sync(): Promise<void>;
     close(): Promise<void>;
 }
-/** What gets persisted per intent. No tokens, no digests. */
+/** Persisted before create; `sessionId` is added only by bindSession. */
 export interface TelegramAdoptionIntent {
-    intendedSessionId: string;
-    topicId: number;
-    chatId: string;
-    target: TelegramAdoptionTarget;
-    createdAt: number;
-    expiresAt: number;
+    readonly providerRequestKey: string;
+    readonly topicId: number;
+    readonly chatId: string;
+    readonly target: TelegramAdoptionTarget;
+    readonly createdAt: number;
+    readonly expiresAt: number;
+    readonly sessionId?: string;
 }
-/** Durable authorization that a topic was observed through forum_topic_created. */
 export interface TelegramPendingTopic {
-    topicId: number;
-    chatId: string;
-    createdAt: number;
-    expiresAt: number;
+    readonly topicId: number;
+    readonly chatId: string;
+    readonly createdAt: number;
+    readonly expiresAt: number;
 }
-/** Compose the per-intent sidecar path. Public so callers/tests can inspect it. */
-export declare function adoptionIntentFilePath(agentDir: string, intendedSessionId: string): string;
-/** Compose the sidecar path for a user-created topic awaiting a folder choice. */
+export declare function adoptionIntentFilePath(agentDir: string, providerRequestKey: string): string;
 export declare function pendingTopicFilePath(agentDir: string, topicId: number): string;
-/** Build a fresh intent with `createdAt`/`expiresAt` derived from `now`/`ttlMs`. */
 export declare function buildAdoptionIntent(input: {
-    intendedSessionId: string;
+    providerRequestKey: string;
     topicId: number;
     chatId: string;
     target: TelegramAdoptionTarget;
     now?: number;
     ttlMs?: number;
 }): TelegramAdoptionIntent;
-/** Test-only: filename suffix used to recognize intent sidecars in a directory listing. */
 export declare const ADOPTION_INTENT_FILENAME_SUFFIX = ".adoption-intent.json";
 export declare const PENDING_TOPIC_FILENAME_SUFFIX = ".pending-topic.json";
-/**
- * Durable, non-routable adoption-intent store. Owns durable sidecar files and
- * the synchronous in-memory topicId claim table. The daemon owns Telegram and
- * lifecycle wiring; this store never calls the Telegram API.
- */
 export declare class TelegramAdoptionIntentStore {
     #private;
     constructor(input: {
@@ -100,66 +67,25 @@ export declare class TelegramAdoptionIntentStore {
         now?: () => number;
         platform?: NodeJS.Platform;
     });
-    /** Directory holding the sidecar files. */
     get directory(): string;
-    /** In-memory lookup by intendedSessionId (no disk read). undefined if absent/expired. */
-    bySession(intendedSessionId: string): TelegramAdoptionIntent | undefined;
-    /** In-memory lookup of the (single) non-expired intent for a topicId. */
+    byProviderRequestKey(providerRequestKey: string): TelegramAdoptionIntent | undefined;
+    /** Only a post-create CAS binding makes a reservation visible by SessionId. */
+    bySession(sessionId: string): TelegramAdoptionIntent | undefined;
     byTopic(topicId: number): TelegramAdoptionIntent | undefined;
-    /** `true` if a non-expired intent already references `topicId`. */
     hasNonExpiredTopic(topicId: number): boolean;
-    /** Durable authorization for an observed user-created topic, if still live. */
     pendingTopic(topicId: number): TelegramPendingTopic | undefined;
     hasPendingTopic(topicId: number, chatId: string): boolean;
-    /**
-     * Synchronously claim `topicId` for `intendedSessionId`. Returns false if a
-     * *different* non-expired intendedSessionId already holds the claim (or has a
-     * non-expired intent for the topic). Same intendedSessionId re-claiming its
-     * own topic is idempotent and succeeds. The claim is in-memory only; it never
-     * deletes the sidecar, so a commit failure can `releaseClaim` and retry.
-     */
-    tryClaim(topicId: number, intendedSessionId: string): boolean;
-    /** Release a claim held by `intendedSessionId` on `topicId`. No-op otherwise. */
-    releaseClaim(topicId: number, intendedSessionId: string): void;
-    /**
-     * Durable write of one intent: temp→write→fsync→chmod(0600)→atomic rename→
-     * chmod(final, 0600)→parent-dir fsync, then track it in memory. The dir is
-     * created owner-only (0700). chmod-ing the final path after the rename makes
-     * the 0600 contract durable regardless of whether the platform's rename
-     * preserves the source mode (POSIX does; some test/network filesystems and
-     * the in-memory test double model rename as copy+delete and would otherwise
-     * drop it). The rename is still the atomic commit point; the final chmod only
-     * tightens permissions on the already-durable file. The in-memory map is only
-     * mutated after the atomic persist succeeds. Rejects (does not swallow) so the
-     * daemon can decide fail-closed behavior.
-     */
+    /** Synchronous fail-closed topic claim keyed by provider request identity. */
+    tryClaim(topicId: number, providerRequestKey: string): boolean;
+    releaseClaim(topicId: number, providerRequestKey: string): void;
     put(intent: TelegramAdoptionIntent): Promise<void>;
-    /** Persist authorization for a topic observed through forum_topic_created. */
+    /** CAS-bind the Broker-returned opaque SessionId exactly once. */
+    bindSession(providerRequestKey: string, sessionId: string): Promise<boolean>;
     putPendingTopic(pendingTopic: TelegramPendingTopic): Promise<void>;
-    /**
-     * Read a single intent sidecar from disk and track it if it is non-expired
-     * and well-formed. Returns the parsed intent (or undefined). Used by
-     * `rehydrate`; callers normally use `rehydrate` / `bySession`.
-     */
-    readIntent(intendedSessionId: string): Promise<TelegramAdoptionIntent | undefined>;
+    readIntent(providerRequestKey: string): Promise<TelegramAdoptionIntent | undefined>;
     readPendingTopic(topicId: number): Promise<TelegramPendingTopic | undefined>;
-    /**
-     * Rehydrate all non-expired intents from the notifications dir. Files are the
-     * only source: missing/corrupt/expired entries are skipped (never thrown).
-     * Returns the count of live intents loaded.
-     */
     rehydrate(): Promise<number>;
-    /**
-     * Remove a single intent sidecar and drop its in-memory entry. Safe to call
-     * after a successful registry commit or a definite spawn failure. Missing
-     * files are not an error. Never calls the Telegram API.
-     */
-    remove(intendedSessionId: string): Promise<void>;
-    /** Remove a pending-topic authorization after an adoption intent is durable. */
+    remove(providerRequestKey: string): Promise<void>;
     removePendingTopic(topicId: number): Promise<void>;
-    /**
-     * Sweep expired intent sidecars from disk. Touches files only. Returns the
-     * count of expired sidecars removed. Safe to run at startup and periodically.
-     */
     sweepExpired(): Promise<number>;
 }

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

@@ -1,5 +1,6 @@
 import type { Settings } from "../../config/settings";
 import { type NotificationSettingsReader } from "./config";
+import { type NotificationDebrisSweepReport } from "./notification-service";
 import { type DaemonState, type TelegramDaemonOptions } from "./telegram-daemon";
 type TelegramDaemonRunner = {
     run(): Promise<void>;
@@ -16,6 +17,7 @@ export interface RunDaemonInternalDeps {
     DaemonImpl?: TelegramDaemonConstructor;
     processPid?: number;
     pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
     /** Clock used by the ownership-progress watchdog; defaults to `Date.now`. */
     now?: () => number;
     /** Timer pair backing the ownership-progress watchdog; defaults to globals. */
@@ -25,6 +27,14 @@ export interface RunDaemonInternalDeps {
     readDaemonState?: (settings: Settings) => Promise<DaemonState | undefined>;
     /** Loads the verified machine-local identity; injectable so daemon tests do not touch the host. */
     loadInstallationHostId?: () => Promise<string>;
+    /**
+     * Startup hygiene sweep over the notifications dir; injectable so tests can
+     * prove it is fired, is never awaited by startup, and that a rejection is
+     * logged instead of failing the daemon.
+     */
+    sweepNotificationDebris?: (input: {
+        dir: string;
+    }) => Promise<NotificationDebrisSweepReport>;
 }
 export declare function createLightweightDaemonSettings(input: {
     agentDir: string;