@gajae-code/coding-agent 0.13.3 → 0.14.0

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

@@ -1,12 +1,8 @@
 import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
 import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
-import { type ElevationOperation } from "../elevation/digest";
-import { type ElevationAnswerAuthority, type ElevationDispatchOutcome } from "../elevation/dispatch-receipt";
-import { ElevationLedger, type ElevationRequester } from "../elevation/grant-ledger";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type BrokerPublicationObservation, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
-import { OperationReceiptLedger } from "./operation-receipt-ledger";
 import { SessionIndex } from "./session-index";
 export interface BrokerSettings {
     agentDir: string;
@@ -23,7 +19,7 @@ type ResolvedBrokerSettings = {
     heartbeatTtlMs: number;
     resolveDirectoryMigration: (_cwd: string) => Promise<DirectoryMigrationPolicy>;
 };
-export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "startup_admission_timeout" | "startup_admission_refused" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | "ambiguous_session" | (string & {});
+export type BrokerErrorCode = "idempotency_conflict" | "terminal_uncertain" | "broker_restarting" | "unavailable" | "endpoint_stale" | "resource_gone" | "invalid_input" | "spawn_failed" | "startup_admission_timeout" | "startup_admission_refused" | "readiness_timeout" | "close_refused" | "not_found" | "live_session" | "cleanup_pending" | (string & {});
 export type BrokerCleanupIdentity = {
     dev: string;
     ino: string;
@@ -200,8 +196,6 @@ export declare class Broker {
     readonly settings: ResolvedBrokerSettings;
     readonly index: SessionIndex;
     readonly ledger: LifecycleLedger;
-    readonly elevation: ElevationLedger;
-    readonly operationReceipts: OperationReceiptLedger;
     discovery: BrokerDiscovery | null;
     constructor(settings: BrokerSettings);
     runStartup<T>(queueWaitMs: number, timing: StartupAdmissionTiming, task: (admittedAt: number) => Promise<T>): Promise<StartupAdmissionResult<T>>;
@@ -210,14 +204,7 @@ export declare class Broker {
     get completion(): Promise<void>;
     status(): RedactedBrokerDiscovery | null;
     heartbeat(): Promise<void>;
-    /**
-     * Production coalesced heartbeat checkpoint seam (C2): delegates to the session
-     * index writer, which appends at most one `host_heartbeat` per session per
-     * {@link SESSION_HEARTBEAT_INTERVAL_MS} for hosts that are alive and, when recorded,
-     * still carry the same OS process incarnation. Returns the number of checkpoints
-     * written. Used by the periodic publication watch, by session reads so a fresh
-     * registration is observed as live, and by tests.
-     */
+    /** Re-observes provably live session hosts and checkpoints their liveness. */
     heartbeatSessions(now?: number): Promise<number>;
     /**
      * Revalidate retained publication ownership and begin one synchronous effect in
@@ -238,46 +225,7 @@ export declare class Broker {
      * spawns a child the broker has no authority over.
      */
     stop(): Promise<void>;
-    handleRequest(operation: string, input: Record<string, unknown>, idempotencyKey?: string, elevationRequestId?: string): Promise<BrokerResponse>;
-    /**
-     * Elevation issuance (internal). Binds the exact endpoint identity
-     * (endpointStateRoot/generation/incarnation) from the live index record;
-     * the request digest is broker-computed from the full `{kind,sdkId,input}`
-     * triple with the top-level `elevationRequestId` excluded.
-     */
-    elevationIssue(params: {
-        sessionId: string;
-        operation: ElevationOperation;
-        input: Record<string, unknown>;
-        requester: ElevationRequester;
-        elevationRequestId?: string;
-        expiresInMs?: number;
-    }): Promise<BrokerResponse>;
-    /**
-     * Elevation answer (internal, operator-only). There is no public
-     * `elevation.answer` operation: this entry point is reserved for the local
-     * operator approval surface and the separately authorized gate-answer
-     * source, and the ledger enforces the distinct-answer-source boundary.
-     */
-    elevationAnswer(params: {
-        elevationRequestId: string;
-        answer: "approve" | "deny";
-        presentedDigest: string;
-        answerer: ElevationAnswerAuthority;
-    }): Promise<BrokerResponse>;
-    /** Single-use grant claim (internal): consumes the grant before dispatch. */
-    elevationClaim(params: {
-        elevationRequestId: string;
-    }): Promise<BrokerResponse>;
-    /** Records the dispatch outcome for a claimed grant (internal). */
-    elevationDispatch(params: {
-        elevationRequestId: string;
-        outcome: ElevationDispatchOutcome;
-    }): Promise<BrokerResponse>;
-    /** Truthful elevation status read (internal; reconciles expiry and crash state). */
-    elevationResolve(elevationRequestId: string): Promise<BrokerResponse>;
-    /** Truthful elevation listing (internal). */
-    elevationList(): Promise<BrokerResponse>;
+    handleRequest(operation: string, input: Record<string, unknown>, idempotencyKey?: string): Promise<BrokerResponse>;
 }
 /** Test-only hook for simulating a process crash after terminal persistence verification. */
 export declare function setTerminalPersistenceHookForTest(broker: Broker, hook: (() => void) | undefined): void;

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

@@ -94,6 +94,7 @@ export declare function sdkSessionCommandOverrideForTest(): {
     file: string;
     args: string[];
 } | undefined;
+type BrokerIndex = Pick<Broker, "index">;
 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>;
@@ -165,14 +166,21 @@ export declare function sessionHostWorkInFlight(): boolean;
  * How often a live broker re-checks its own session registrations against OS
  * process liveness.
  *
- * This sweep can never disturb healthy work: a registration is only dropped
- * when `process.kill(pid, 0)` proves the exact published pid is gone, and a
- * working host answers that probe for its entire life no matter how long a turn
- * runs. One minute keeps `gjc_sessions`/`session.get_endpoint` from advertising
- * a corpse for longer than a single poll while costing one index refresh per
- * minute on an otherwise idle broker.
+ * This sweep can never disturb healthy work: a registration is dropped only when
+ * `observeProcess` proves its exact published process identity exited. A live
+ * replacement at the same pid retires the stale registration without being
+ * signaled. One minute keeps `gjc_sessions`/`session.get_endpoint` from
+ * advertising a corpse for longer than a single poll while costing one index
+ * refresh per minute on an otherwise idle broker.
  */
 export declare const BROKER_DEAD_REGISTRATION_SWEEP_MS = 60000;
+/**
+ * Registrations reaped per sweep. Every reap is its own locked index transaction,
+ * so an uncapped sweep over a long-lived index turns one broker into a continuous
+ * holder of the shared session-index lock and starves unrelated `gjc` launches out
+ * of their bounded retry budget. Surplus dead rows are reaped by later sweeps.
+ */
+export declare const BROKER_DEAD_REGISTRATION_SWEEP_LIMIT = 64;
 /** One reaped registration, as recorded by {@link reapDeadSessionRegistrations}. */
 export interface ReapedSessionRegistration {
     sessionId: string;
@@ -188,13 +196,11 @@ export interface ReapedSessionRegistration {
  * missing heartbeat merely makes a session read as not-live — the host may
  * still be running ahead of the next heartbeat checkpoint pass, so it is never
  * grounds for a reap. EPERM and unreadable incarnations stay "uncertain", so an
- * alien or unreadable process is never mistaken for a dead one. Registrations
- * already terminal or marked `terminalUncertain` are left alone: their
- * disposition belongs to the terminal-uncertainty reconciliation path, and
- * silently dropping them would turn a fail-closed `session.close`/
- * `session.delete` refusal into `not_found`.
+ * alien or unreadable process is never mistaken for a dead one. Terminal and
+ * terminal-uncertain identities are retained. Identity-level rows let the sweep
+ * retire a dead losing root without disturbing the surviving authority.
  */
-export declare function reapDeadSessionRegistrations(broker: Pick<Broker, "index">): Promise<ReapedSessionRegistration[]>;
+export declare function reapDeadSessionRegistrations(broker: BrokerIndex, limit?: number): Promise<ReapedSessionRegistration[]>;
 /**
  * Runs {@link reapDeadSessionRegistrations} on {@link BROKER_DEAD_REGISTRATION_SWEEP_MS}.
  * The timer is unref'd, so it never keeps an otherwise idle broker process alive.

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

@@ -68,11 +68,13 @@ export interface IndexedSession {
     activity?: SessionActivity;
     /** Wall-clock timestamp of the latest admitted heartbeat, when one exists. */
     lastHeartbeatAt?: number;
-    /** True when the same sessionId maps to more than one stateRoot (cross-repo duplicate). */
+    /** True when more than one unresolved authority-fencing state-root identity claims this session id. */
     ambiguous: boolean;
-    /** True when the identity's latest event is host_unregistered or session_closed (DR-1: stopped rows are retained). */
+    /** True when the identity's latest event is terminal (DR-1 retains stopped rows for inspection/offline tail). */
     terminal: boolean;
 }
+/** A session can grant endpoint or lifecycle authority only when one authority-fencing state root claims its id. */
+export declare function isSessionAuthorityEligible(session: Pick<IndexedSession, "ambiguous">): boolean;
 export interface SessionList {
     indexSeq: number;
     sessions: IndexedSession[];
@@ -119,6 +121,7 @@ export declare class SessionIndex {
     refresh(): Promise<void>;
     get indexSeq(): number;
     append(input: Omit<SessionIndexEvent, "version" | "indexSeq" | "checksum" | "ts"> & Partial<Pick<SessionIndexEvent, "ts">>): Promise<SessionIndexEvent>;
+    unregisterIfCurrent(expected: IndexedSession): Promise<boolean>;
     /** Hold the canonical index lock across an authority-sensitive operation. */
     withLocked<T>(callback: () => Promise<T>): Promise<T>;
     snapshot(): Promise<void>;
@@ -128,19 +131,25 @@ export declare class SessionIndex {
      */
     compact(): Promise<void>;
     listSessions(): SessionList;
+    /**
+     * Broker-internal current composite-identity rows. Unlike {@link listSessions},
+     * this retains losing roots so an exact dead registration can be retired without
+     * disturbing the surviving authority.
+     */
+    listSessionIdentities(probedIncarnations?: ReadonlyMap<string, string | undefined>): IndexedSession[];
     /**
      * Production coalesced heartbeat checkpoint pass (C2): appends one
      * `host_heartbeat` per session at most once per {@link SESSION_HEARTBEAT_INTERVAL_MS}.
      * The pass observes liveness the same way the projection does — the host process
      * must be alive and, for composite identities, still carry the recorded OS process
-     * incarnation (a reused PID is never checkpointed). Stopped/terminal rows and rows
-     * whose heartbeat is still fresh are skipped. After a broker restart, sessions whose
+     * incarnation (a reused PID is never checkpointed). Stopped, terminal, and ambiguous rows
+     * and rows whose heartbeat is still fresh are skipped. After a broker restart, sessions whose
      * host survived are re-observed as live on the first pass; sessions whose host died
      * while the broker was down keep their stale or missing heartbeat and read as
      * unknown/not-live (never fresh forever). Returns the number of checkpoints written.
      */
     checkpointLiveHeartbeats(now?: number): Promise<number>;
-    hostUnregisteredAfter(registration: Pick<IndexedSession, "sessionId" | "endpointGeneration" | "pid" | "indexSeq" | "lifecycleRequestId">): {
+    hostUnregisteredAfter(registration: Pick<IndexedSession, "sessionId" | "locator" | "endpointGeneration" | "pid" | "indexSeq" | "lifecycleRequestId" | "hostIncarnation" | "processIncarnation">): {
         indexSeq: number;
         lifecycleRequestId?: string;
     } | undefined;

package/dist/types/sdk/broker/startup-failure.d.ts

@@ -4,13 +4,28 @@ export interface BrokerStartupFailureMarker {
     exitCode: number | null;
     signal: string | null;
     writtenAt: number;
+    /**
+     * pid of the exact broker process that wrote this marker. `ensureBroker`
+     * only trusts a marker whose pid matches the exact spawned child it just
+     * reaped -- a marker left behind by a stale or foreign broker process (for
+     * example a losing racer from a concurrent spawn, or a marker predating the
+     * pre-spawn clear) must never be misattributed to a different spawn's
+     * failure.
+     */
+    pid: number;
 }
 export declare function brokerStartupFailurePath(agentDir: string): string;
-/** Best-effort durable marker write; never throws (diagnostics must not mask the exit itself). */
+/**
+ * Best-effort durable marker write; never throws (diagnostics must not mask the
+ * exit itself). `pid` must be the writing broker process's own pid
+ * (`process.pid`) so a later reader can bind the marker to the exact spawned
+ * child it is attributing the failure to.
+ */
 export declare function writeBrokerStartupFailureMarker(agentDir: string, failure: {
     reason: string;
     exitCode: number | null;
     signal: string | null;
+    pid: number;
 }): Promise<void>;
 /** Reads a bounded startup-failure marker; `undefined` when absent or malformed. */
 export declare function readBrokerStartupFailureMarker(agentDir: string): Promise<BrokerStartupFailureMarker | undefined>;

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

@@ -45,7 +45,57 @@ export type ChatDaemonAction = "stop" | "reload";
  * generation 29 / slack generation 28 advance the replay cursor only after a frame is
  * published, so an owner at an earlier generation acknowledges an event before delivering
  * it and loses that event for good the first time a surface refuses it. Discord generation 30 /
- * slack generation 29 invalidate existing owners after SDK discovery validation changes.
+ * slack generation 29 move lifecycle and attachment authority into SDK core; generation 30 also
+ * isolates per-session Router attachment failures so one stale endpoint cannot block healthy sessions.
+ * Discord generation 31 bounds one REST operation across response parsing and multi-request flows.
+ * Slack generation 30 bounds shutdown, tracks outbound work, and fences late effect commits.
+ * Slack generation 31 fences late post admission and tracks close-marker shutdown work.
+ * Slack generation 32 bounds provider teardown and preserves close markers after Router revocation.
+ * Slack generation 33 bounds lifecycle predecessors under the shutdown deadline.
+ * Slack generation 34 CAS-fences cleanup mapping commits against successors.
+ * Slack generation 35 identity-fences detached startup cleanup from restarted daemon state.
+ * Slack generation 36 retains stop ownership for every detached lifecycle generation.
+ * Discord generation 32 / Slack generation 37 bind cleanup to the removed attachment generation.
+ * Discord generation 33 / Slack generation 38 identity-fence cleanup callbacks on exact attachments.
+ * Discord generation 34 / Slack generation 39 clear stale attachment identity before provider reassignment.
+ * Discord generation 35 / Slack generation 40 capture provider ownership before cleanup awaits.
+ * Discord generation 36 / Slack generation 41 drain prior cleanup before provider restart.
+ * Discord generation 37 / Slack generation 42 serialize successor attachment visibility after cleanup.
+ * Discord generation 38 / Slack generation 43 hold successor frames behind cleanup settlement.
+ * Discord generation 39 / Slack generation 44 recover durable cleanup before attachment publication.
+ * Slack generation 45 persists exact pending cleanup intent through recovery.
+ * Discord generation 40 bounds provider lifecycle joins before Router revocation.
+ * Discord generation 41 / Slack generation 46 revoke Router authority despite provider shutdown failure.
+ * Discord generation 42 / Slack generation 47 retain daemon objects across restart to preserve detached lifecycle fences.
+ * Discord generation 43 / Slack generation 48 fence Router attachment publication and Broker-adopted endpoint authority.
+ * Discord generation 44 / Slack generation 49 retain provider shutdown tails and rejected lifecycle errors so no successor transport starts before ownership settles.
+ * Discord generation 45 / Slack generation 50 clean predecessor presentation authority before exact Router replacement and reject post-stop Discord callbacks.
+ * Discord generation 46 / Slack generation 51 establish replay barriers before reconnect awaits, distinguish replacement from terminal cleanup, and await lifecycle-fenced Discord inbound work.
+ * Discord generation 47 / Slack generation 52 preserve presentation continuity across replacement while exact opaque authority fences stale work.
+ * Discord generation 48 / Slack generation 53 allow exact publication-time requests without reconciliation deadlock.
+ * Discord generation 49 / Slack generation 54 revalidate endpoint authority before exact publication-time requests.
+ * Discord generation 50 / Slack generation 55 terminalize predecessor routes only for a changed same-generation endpoint incarnation.
+ * Slack generation 56 clears predecessor inbound receipts before same-generation successor publication.
+ * Discord generation 51 / Slack generation 57 persist restart-stable Router endpoint-incarnation authority in provider mappings.
+ * Discord generation 52 / Slack generation 58 classify reconnect-time endpoint changes before provider retirement.
+ * Discord generation 53 / Slack generation 59 serialize successor attach behind predecessor provider retirement.
+ * Discord generation 54 / Slack generation 60 version-fence attaches already in flight when retirement begins.
+ * Discord generation 55 / Slack generation 61 fence durable inbound work by exact attachment identity.
+ * Discord generation 56 / Slack generation 62 fence durable provider-post and thread-effect recovery by attachment identity.
+ * Discord generation 57 removes missing-authority wildcard behavior from durable binding checks.
+ * Discord generation 58 preserves exact authority through unarchive replacement fallback.
+ * Discord generation 59 / Slack generation 63 derive attachment authority ids from one Router function so persisted provider bindings and live attachments cannot drift apart.
+ * Discord generation 62 / Slack generation 65 fence the Windows process-incarnation
+ * authority change (#4362): the native binding fallback no longer spawns powershell.exe.
+ * Discord generation 63 / Slack generation 66 retain the shared ownership fence
+ * unless a zero-signal process probe returns ESRCH. EPERM and unknown failures are
+ * indeterminate, so earlier owners must not reclaim, replace, or spawn through them.
+ * Discord generation 64 / Slack generation 67 contain synchronous provider-
+ * subscription admission and ready-hook failures without revoking shared Router
+ * attachment authority.
+ * Discord generation 65 / Slack generation 68 fence the off-reconcile-tail
+ * initial attachment replay introduced by #4542 so pre-upgrade daemon owners
+ * cannot retain the earlier SessionRouter attachment contract.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

@@ -1,5 +1,4 @@
-import { SessionIndex } from "../broker/session-index";
-import { type SdkSessionEndpoint } from "../client/discovery";
+import type { SessionRouterDeps } from "../router";
 import type { ChatDaemonCommandBindInput, ChatDaemonCommandOutcome } from "./chat-daemon-command-channel";
 import type { ChatDaemonKind } from "./chat-daemon-control";
 import type { DiscordProvider } from "./discord-provider";
@@ -26,22 +25,6 @@ export interface ChatDaemonRuntimeConfig {
         verbosity: "lean" | "verbose";
     };
 }
-export interface ChatDaemonSdkClient {
-    onFrame(handler: (frame: Record<string, unknown>) => void): () => void;
-    /**
-     * Announces that a replacement socket is live. Optional because command-scoped
-     * clients (the broker client, one-shot doubles) never outlive one socket, while
-     * every long-lived attachment's client carries it.
-     */
-    onReconnect?(handler: () => void): () => void;
-    /** Re-dials a retired socket; a no-op on a live one. */
-    connect?(): Promise<void>;
-    request(frame: Record<string, unknown>, options?: {
-        timeoutMs?: number;
-    }): Promise<Record<string, unknown>>;
-    close(): Promise<void>;
-    send(frame: Record<string, unknown>): void;
-}
 export type ChatDeliveryPhase = "pre_send" | "ambiguous";
 /** An authorized SDK command could not be conclusively delivered. */
 export declare class ChatDeliveryError extends Error {
@@ -51,19 +34,11 @@ export declare class ChatDeliveryError extends Error {
 export interface ChatDaemonRuntimeDeps {
     createDiscordProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["discord"]>) => DiscordProvider;
     createSlackProvider?: (config: NonNullable<ChatDaemonRuntimeConfig["notifications"]["slack"]>) => SlackProviderClient;
-    createClient?: (endpoint: SdkSessionEndpoint) => Promise<ChatDaemonSdkClient>;
-    createIndex?: (agentDir: string) => SessionIndex;
-    createBrokerClient?: (endpoint: {
-        url: string;
-        token: string;
-    }) => Promise<ChatDaemonSdkClient>;
-    onReconciled?: () => void;
-    setInterval?: typeof setInterval;
-    clearInterval?: typeof clearInterval;
+    routerDeps?: SessionRouterDeps;
 }
 /**
  * Worker-owned session discovery and event fanout. It connects only through the
- * public SDK transport and retains endpoint tokens solely in live client objects.
+ * public SDK transport and retains SDK credentials solely in live client objects.
  */
 export declare class ChatDaemonRuntime {
     #private;
@@ -77,18 +52,6 @@ export declare class ChatDaemonRuntime {
     start(): Promise<void>;
     transportHealthy(): boolean;
     stop(): Promise<void>;
-    private reconcile;
-    private attach;
-    private resolveEndpoint;
-    /**
-     * Adopt an operator-supplied Slack root for one attached session. Returns a
-     * machine-readable rejection instead of throwing so the daemon control plane
-     * can answer without exposing internal failure detail.
-     */
+    /** Adopt an operator-supplied Slack root through the provider's presentation store. */
     bindExistingRoot(request: ChatDaemonCommandBindInput): Promise<ChatDaemonCommandOutcome>;
-    private schedule;
-    private enqueueFrame;
-    private handleFrame;
-    private close;
-    private resume;
 }

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

@@ -10,6 +10,17 @@ import { type LoadResult } from "../../config/config-file";
  * site marks it, never by inheriting a marked ancestor's environment.
  */
 export declare const SPAWN_PROVENANCE_ENV = "GJC_SPAWNED_BY_SESSION";
+/**
+ * Telegram session eligibility: whether a session may own a forum topic and be
+ * admitted by the notification daemon.
+ *
+ * This follows the user's configuration, never how the session was launched.
+ * Gating it on coordinator/lifecycle provenance made every ordinary
+ * interactive session declare itself ineligible, and the daemon refuses an
+ * identity header that does so — so no notification was ever delivered even
+ * though the daemon looked healthy and attached.
+ */
+export declare function isTelegramSessionEligible(cfg: NotificationConfig): boolean;
 export type TelegramActivationState = "inactive" | "blocked";
 export type TelegramActivationReason = "saved_inactive" | "identity_mismatch";
 /** Non-secret, identity-specific durable Telegram activation state. */

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: [];
+};