@gajae-code/coding-agent 0.13.2 → 0.14.0

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

@@ -251,6 +251,14 @@ export interface NotificationRecoveryReport {
     endpointsRetainedPlaceholders?: string[];
     /** Cleanup entries retained with unverified or mismatching identity. */
     endpointsRetainedUnknown?: string[];
+    /** Stale quarantine/staging debris removed from the endpoint and daemon dirs. */
+    debrisRemoved?: string[];
+    /** Debris candidates retained by policy (young, live writer). */
+    debrisKept?: number;
+    /** Debris removals attempted without conclusive success (identity/unlink). */
+    debrisFailures?: number;
+    /** At least one debris directory listing failed; the sweep was not exhaustive. */
+    debrisScanFailed?: boolean;
     daemon: {
         action: DaemonRecoveryAction;
         detail: string;
@@ -317,6 +325,50 @@ export declare function acquireDaemonTransitionLock(input: {
     retryDelayMs?: number;
     randomToken?: () => string;
 }): Promise<DaemonTransitionLock | undefined>;
+/**
+ * Minimum age before age-based debris removal. Quarantine artifacts are inert
+ * the moment they are detached, but the age bound keeps the sweep clear of any
+ * recovery pass still holding a `detachedPath` reference in its report.
+ */
+export declare const NOTIFICATION_DEBRIS_MIN_AGE_MS: number;
+export interface NotificationDebrisSweepReport {
+    /** Basenames removed from the swept directory. */
+    removed: string[];
+    /** Debris candidates retained (young, live writer, or identity/unlink refusal). */
+    kept: number;
+    /**
+     * Candidates whose removal was ATTEMPTED and did not conclusively succeed
+     * (identity mismatch, unreadable candidate, unlink error). Distinct from
+     * `kept`-by-policy so a caller can see that a sweep was not fully effective.
+     */
+    failures: number;
+    /** The directory listing itself failed; nothing could be inspected. */
+    scanFailed?: boolean;
+}
+/**
+ * Remove inert filesystem debris from a notification/state directory:
+ * quarantine targets of already-detached markers and endpoints, exact-unlink
+ * exchange placeholders, and leaked atomic-write staging files.
+ *
+ * Removal requires positive staleness proof — a dead recorded writer pid for
+ * staging files, or an mtime older than {@link NOTIFICATION_DEBRIS_MIN_AGE_MS}
+ * for everything else. Canonical files can never match the debris patterns, and
+ * a young staging file with a live writer is kept.
+ *
+ * Age, terminal-scrub proof, and the delete identity all come from ONE
+ * no-follow snapshot of the candidate. Judging age from a separate `stat` would
+ * prove one pathname stale and then bind the delete to whatever occupied that
+ * pathname afterwards, so a live successor could be removed on a predecessor's
+ * staleness. A candidate replaced after the snapshot fails the identity match
+ * and is retained; a symlinked, non-regular, or unreadable candidate is refused
+ * outright. Every inconclusive attempt is counted in `failures` rather than
+ * silently folded into `kept`.
+ */
+export declare function sweepNotificationDebris(input: {
+    dir: string;
+    deps?: NotificationServiceDeps;
+    minAgeMs?: number;
+}): Promise<NotificationDebrisSweepReport>;
 /**
  * Ownership-protected cleanup. Removes only DEAD-owner artifacts:
  * per-session endpoint files with positive proof of death (a stale tombstone or

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

@@ -1,6 +1,6 @@
 export interface NotificationOperatorTimerDeps {
     now?: () => number;
-    setTimeoutImpl?: typeof setTimeout;
+    setTimeoutImpl?: (callback: () => void, ms?: number) => Timer | NodeJS.Timeout;
     clearTimeoutImpl?: typeof clearTimeout;
     setIntervalImpl?: typeof setInterval;
     clearIntervalImpl?: typeof clearInterval;

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

@@ -1,5 +1,6 @@
 /**
- * Bounded authoritative reconciliation state for Q26 `turn.prompt_status`.
+ * Bounded prompt reconciliation state for canonical Q26 `turn.result` with
+ * `kind: "prompt"`, plus the legacy `turn.prompt_status` alias.
  *
  * Separate from the lifecycle delivery buffers (promptSubmissions /
  * promptTerminalTombstones), which exist to deliver frames and intentionally
@@ -9,8 +10,8 @@
  *
  * Semantics (public contract, mirrored in sdk/prompt-status.ts):
  * - Active records are NEVER converted to terminal by age or capacity.
- * - Terminal records are retained for TERMINAL_TTL_MS and bounded to
- *   TERMINAL_CAPACITY, evicted oldest-terminal-first by terminalAt; only then
+ * - Terminal records are bounded to TERMINAL_CAPACITY and evicted
+ *   oldest-terminal-first by terminalAt; only then
  *   does a lookup honestly report `unknown`.
  * - Process-local durability floor is the live session process: restart means `unknown`.
  *   Session-scoped durable retention (kind-aware store) is provided by reconciliation-store.ts (#3032).
@@ -21,10 +22,10 @@
  *   record that has none, but never changes status, terminalAt, or retention.
  */
 import { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure } from "../prompt-failure";
+import type { ReceiptState } from "../receipt-state";
 export { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure };
 export declare const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
 export declare const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;
-export declare const PROMPT_RECONCILIATION_TERMINAL_TTL_MS: number;
 export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
 export interface PromptCorrelation {
     commandId: string;
@@ -40,15 +41,18 @@ export interface PromptReconciliationRecord extends PromptCorrelation {
     acceptedAt: number;
     startedAt?: number;
     terminalAt?: number;
+    receiptState?: Exclude<ReceiptState, "absent">;
 }
 export type TurnPromptReconciliation = {
     status: "accepted";
+    receiptState: "absent";
     commandId: string;
     turnId: string;
     clientRef?: string;
     acceptedAt: number;
 } | {
     status: "in_flight";
+    receiptState: "absent";
     commandId: string;
     turnId: string;
     clientRef?: string;
@@ -56,6 +60,7 @@ export type TurnPromptReconciliation = {
     startedAt: number;
 } | {
     status: "terminal_ok";
+    receiptState: Exclude<ReceiptState, "absent">;
     commandId: string;
     turnId: string;
     clientRef?: string;
@@ -69,6 +74,7 @@ export type TurnPromptReconciliation = {
     };
 } | {
     status: "failed";
+    receiptState: Exclude<ReceiptState, "absent">;
     commandId: string;
     turnId: string;
     clientRef?: string;
@@ -81,6 +87,7 @@ export type TurnPromptReconciliation = {
     };
 } | {
     status: "unknown";
+    receiptState: "unknown";
 };
 export interface PromptReconciliation {
     /** Fail-closed admission BEFORE any execution; holds an identity-bound reservation. */
@@ -91,10 +98,14 @@ export interface PromptReconciliation {
     noteAccepted(correlation: PromptCorrelation, clientRef?: string): void;
     /** Lifecycle transition; terminal outcomes settle exactly once. */
     noteTransition(correlation: PromptCorrelation | undefined, frame: {
-        type: "agent_start" | "agent_end";
+        type: "agent_start";
+    } | {
+        type: "agent_end";
+        finalText?: string;
     } | {
         type: "agent_failed";
         error: unknown;
+        finalText?: string;
     }): void;
     lookup(selector: {
         commandId?: string;

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