@gajae-code/coding-agent 0.11.6 → 0.11.8

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

@@ -4,11 +4,13 @@ import type { DaemonRuntimeInfo } from "../../daemon/control-types";
 import { HEARTBEAT_TTL_MS } from "./daemon-paths";
 import { type DaemonTransitionLock, type NotificationEndpointFile, type NotificationEndpointFileIdentity, type NotificationExactUnlinkResult } from "./notification-service";
 import { type DaemonProcessReference } from "./telegram-daemon-control";
+import { type TelegramSetupPreflight } from "./telegram-setup";
 export { DAEMON_GENERATION, NOTIFICATION_PROTOCOL_VERSION } from "./telegram-daemon-contract";
 import { type ControlServerLike, type LifecycleControlServerFactory } from "./lifecycle-control-runtime";
 import type { OrchestratorDeps } from "./lifecycle-orchestrator";
 import { NotificationOperatorRuntime, OperatorBackoffPolicy } from "./operator-runtime";
 import { type AliasTable, type CallbackRoute } from "./telegram-reference";
+import { type TopicEndpointBinding } from "./topic-registry";
 export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
 /** Detailed result for orchestration that must distinguish a #2028 handoff from a fresh spawn. */
 export type EnsureTelegramDaemonDetailedResult = "spawned" | "reloaded" | "attached" | "disabled" | "blocked_identity";
@@ -54,6 +56,10 @@ export interface TelegramDaemonFs {
     chmod(path: string, mode: number): Promise<void>;
     stat?(path: string): Promise<{
         mtimeMs: number;
+        size?: number;
+        dev?: number;
+        ino?: number;
+        ctimeMs?: number;
     }>;
     readEndpointFile?(path: string): Promise<NotificationEndpointFile>;
     exactUnlink?(path: string, identity: NotificationEndpointFileIdentity): Promise<NotificationExactUnlinkResult>;
@@ -101,6 +107,21 @@ export declare const ASK_SELECTED_ACK_CAPABILITY = "ask_selected_ack_v1";
 export declare const ASK_CONTROLS_CAPABILITY = "ask_controls_v1";
 /** Capability required for tool lifecycle and reasoning-summary frames. */
 export declare const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v1";
+/**
+ * File-lock options whose acquisition budget covers the full reload-reservation
+ * critical section: the in-lock freshness poll plus the controller's
+ * graceful+kill+readiness sequence, with headroom. A contender must be able to
+ * wait out a legitimate slow reload and then attach, never fail startup.
+ */
+export declare function reloadReservationLockOptions(input: {
+    freshnessWaitMs: number;
+    readinessTimeoutMs: number;
+    retryDelayMs?: number;
+}): {
+    staleMs: number;
+    retries: number;
+    retryDelayMs: number;
+};
 export declare const BTW_QUESTION_MAX_UNICODE_SCALARS = 4096;
 export declare const BTW_QUESTION_MAX_UTF8_BYTES = 16384;
 export declare function endpointAuthorityDigest(url: string, token: string, connectionIdentity?: string): string;
@@ -136,12 +157,22 @@ type LegacyOwnershipLockMetadata = {
     incarnation?: string;
     startedAt: number;
 };
+type V010OwnershipLockMetadata = {
+    size: 0;
+    mtimeMs?: number;
+    dev?: number;
+    ino?: number;
+    ctimeMs?: number;
+};
 type OwnershipLockRead = {
     kind: "missing";
 } | {
     kind: "malformed";
     raw: string;
     mtimeMs?: number;
+} | {
+    kind: "v010";
+    metadata: V010OwnershipLockMetadata;
 } | {
     kind: "legacy";
     metadata: LegacyOwnershipLockMetadata;
@@ -187,7 +218,84 @@ export declare function unregisterNotificationRoot(input: {
     sessionId: string;
     fs?: TelegramDaemonFs;
 }): Promise<UnregisterNotificationRootResult>;
+/**
+ * Leak artifact prefixes left when native exact-unlink cleanup is retained
+ * (#2956). Nothing previously reaped these; they accumulate in the notifications
+ * directory across ownership transitions.
+ */
+export declare const NOTIFICATION_LEAK_ARTIFACT_PREFIXES: readonly [".gjc-delete-daemon-transition-", ".gjc-exact-unlink-placeholder-", ".gjc-delete-notification-endpoint-"];
+/** Grace window before a leak artifact is reaped (covers in-flight unlinks). */
+export declare const NOTIFICATION_LEAK_ARTIFACT_GRACE_MS: number;
+/** True when a path is permanently gone (not a transient I/O blip). */
+export declare function isPermanentMissingPathError(error: unknown): boolean;
+export declare function isNotificationLeakArtifactName(name: string): boolean;
+/**
+ * Drop permanently missing scan roots from the durable registry under the roots
+ * lock. Session map entries that pointed only at those roots are removed too.
+ */
+export declare function pruneMissingNotificationRoots(input: {
+    settings: Settings;
+    fs?: TelegramDaemonFs;
+    /** When set, only these roots are considered; otherwise every registered root is probed. */
+    candidates?: readonly string[];
+}): Promise<{
+    pruned: string[];
+    remaining: number;
+}>;
+/**
+ * Reap retained exact-unlink / ownership-transition quarantine files older than
+ * the grace window from the notifications directory.
+ */
+export declare function reapStaleNotificationArtifacts(input: {
+    settings: Settings;
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    graceMs?: number;
+}): Promise<{
+    removed: string[];
+    skipped: number;
+}>;
+/**
+ * Startup / ownership self-heal: prune dead roots and reap leak artifacts so
+ * `gjc daemon reload` recovers a degraded install without manual surgery (#2956).
+ */
+export declare function healTelegramDaemonNotificationState(input: {
+    settings: Settings;
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    graceMs?: number;
+}): Promise<{
+    prunedRoots: string[];
+    removedArtifacts: string[];
+}>;
 export declare function hasSafeDaemonStateShape(state: unknown): state is DaemonState;
+type ParentDaemonStateBase = Omit<DaemonState, "incarnation" | "acquisitionId" | "ownershipPhase" | "generation" | "launcherPid"> & {
+    incarnation?: undefined;
+    acquisitionId?: undefined;
+    ownershipPhase?: undefined;
+    generation?: unknown;
+    launcherPid?: undefined;
+};
+type GenerationAbsentParentDaemonState = Omit<ParentDaemonStateBase, "generation"> & {
+    generation?: undefined;
+};
+type Generation3ReleaseDaemonState = Omit<ParentDaemonStateBase, "generation"> & {
+    generation: 3;
+};
+export type LegacyParentDaemonState = GenerationAbsentParentDaemonState | Generation3ReleaseDaemonState;
+export interface AttestedLegacyDaemonOwner {
+    state: LegacyParentDaemonState;
+    incarnation: string;
+}
+/** Revalidate the exact two-observation legacy proof immediately before signaling. */
+export declare function readAttestedLegacyDaemonOwner(input: {
+    settings: Settings;
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    pidIncarnation?: (pid: number) => string | undefined;
+    tokenFingerprint: string;
+    chatId: string;
+}): Promise<AttestedLegacyDaemonOwner | undefined>;
 /** True for a physically live owner with this configuration, including legacy generations. */
 export declare function isPhysicalMatchingOwner(input: {
     state: DaemonState | undefined;
@@ -196,7 +304,7 @@ export declare function isPhysicalMatchingOwner(input: {
     pidAlive: (pid: number) => boolean;
     pidIncarnation?: (pid: number) => string | undefined;
 }): boolean;
-/** True only for a signalable legacy owner or this generation's ready bound child. */
+/** True only for a fully-provenanced modern owner outside the generation-3 parent schema. */
 export declare function isSignalableMatchingOwner(input: {
     state: DaemonState | undefined;
     tokenFingerprint: string;
@@ -245,6 +353,7 @@ export declare function acquireDaemonOwnership(input: {
     provisional?: boolean;
     reason?: "identity_mismatch";
     reloadRequired?: boolean;
+    legacyReloadRequired?: boolean;
 }>;
 export declare function renewDaemonHeartbeat(input: {
     settings: Settings;
@@ -321,6 +430,8 @@ export declare function confirmTelegramDaemonSpawn(input: {
     sleep?: (ms: number) => Promise<void>;
     waitStepMs?: number;
     timeoutMs?: number;
+    /** Retain an unproven no-PID child lease during a successor handoff. */
+    preserveOnUnprovenChildExit?: boolean;
 }): Promise<boolean>;
 export declare function releaseDaemonOwnership(input: {
     settings: Settings;
@@ -338,6 +449,22 @@ export declare function releaseDaemonOwnership(input: {
 export declare function readDaemonState(settings: Pick<Settings, "getAgentDir">, fs?: TelegramDaemonFs): Promise<DaemonState | undefined>;
 /** Read the persisted notification roots list. */
 export declare function readDaemonRoots(settings: Pick<Settings, "getAgentDir">, fs?: TelegramDaemonFs): Promise<string[]>;
+/** Injectable readers for {@link resolveTelegramSetupPreflight}, defaulting to the real OS/state probes. */
+export interface ResolveTelegramSetupPreflightDeps {
+    readDaemonState?: (settings: Settings) => Promise<DaemonState | undefined>;
+    pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
+}
+/**
+ * Build the Telegram setup preflight from persisted daemon state. The daemon is
+ * reported live ONLY when its PID is alive AND its current process incarnation
+ * still matches the persisted incarnation. Skipping the incarnation check makes
+ * a stale state file whose PID has been recycled by an unrelated process
+ * masquerade as a live owner, which wrongly blocks discovery pairing. Both the
+ * `notify setup` CLI and the /settings Notifications tab share this resolver so
+ * pairing behaves identically on both surfaces.
+ */
+export declare function resolveTelegramSetupPreflight(settings: Settings, deps?: ResolveTelegramSetupPreflightDeps): Promise<TelegramSetupPreflight>;
 export interface TelegramSpawnOwnerInput {
     settings: Settings;
     roots?: string[];
@@ -362,6 +489,7 @@ export type TelegramSpawnOwnerResult = {
     runtime: DaemonRuntimeInfo;
     warnings: string[];
     reloadRequired?: boolean;
+    legacyReloadRequired?: boolean;
 } | {
     result: "blocked";
     runtime: DaemonRuntimeInfo;
@@ -389,6 +517,29 @@ export declare function buildTelegramDaemonSpawnArgs(input: {
  * already-persisted roots.
  */
 export declare function spawnTelegramDaemonOwner(input: TelegramSpawnOwnerInput, deps?: TelegramDaemonDeps): Promise<TelegramSpawnOwnerResult>;
+/**
+ * Owner-bound reclamation of a confirmed-dead daemon owner, mirroring the
+ * daemon step of `gjc notify recovery`. It returns a structured, actionable
+ * result and removes only identity-verified dead-owner artifacts while holding
+ * the transition fence; live, successor, unknown, or unreadable evidence is
+ * retained.
+ */
+export type DeadOwnerRecoveryResult = {
+    recovered: true;
+    reason: "cleared";
+} | {
+    recovered: false;
+    reason: "not-confirmed-dead" | "unsafe-lock" | "transition-contended" | "owner-superseded" | "unsafe-endpoint" | "endpoint-changed" | "endpoint-directory-unreadable" | "lock-changed";
+};
+/** Preflight cleanup for a confirmed-dead owner, with identity-bound removal. */
+export declare function reclaimDeadDaemonOwner(input: {
+    settings: Settings;
+    endpointDir?: string;
+    fs?: TelegramDaemonFs;
+    now?: () => number;
+    pidAlive?: (pid: number) => boolean;
+    pidIncarnation?: (pid: number) => string | undefined;
+}): Promise<DeadOwnerRecoveryResult>;
 /**
  * Ensure a configured daemon owns this session root, preserving ownership safety
  * while exposing whether a #2028 generation handoff was required.
@@ -469,6 +620,11 @@ export declare class TelegramEventDispatchState {
     readonly busy: Set<string>;
     readonly inboundReactions: Map<number, {
         messageId: number;
+        socketLease?: {
+            session: SessionSocket;
+            token: number;
+            logicalSessionId: string;
+        };
     }>;
     readonly seenUpdateIds: Set<number>;
 }
@@ -551,11 +707,15 @@ interface SessionSocket {
     sessionId: string;
     /** Current logical session carried by valid threaded frames on this transport. */
     logicalSessionId: string;
+    /** Endpoint metadata proved this logical id belongs to this discovery record. */
+    logicalSessionIdTrusted: boolean;
     token: string;
     endpointKey: string;
     endpointDigest: string;
     hostGeneration: number;
     ws: WebSocket;
+    /** Timestamp (via opts.now) at which this socket began connecting. */
+    connectingSince: number;
     pending: Map<string, {
         sessionId: string;
         actionId: string;
@@ -574,6 +734,13 @@ interface SessionSocket {
     /** Queues live frames until startup replay is applied. */
     replayPending: boolean;
     replayQueue: Record<string, unknown>[];
+    /** Trusted recovery may not route until its durable endpoint lease is committed. */
+    recoveryLease?: {
+        state: "pending" | "authorized" | "rejected";
+        logicalSessionId: string;
+        binding: TopicEndpointBinding;
+        token: number;
+    };
 }
 export declare class TelegramNotificationDaemon {
     #private;
@@ -598,12 +765,20 @@ export declare class TelegramNotificationDaemon {
     private readonly pollConflictBackoff;
     private readonly loopBackoff;
     private running;
+    /** Once set, a concurrent startup await can never restore a running daemon. */
+    private stopRequested;
     private readonly fsImpl;
     private readonly botApi;
     private readonly effects;
     private readonly topics;
     /** Serializes registry snapshots so an older atomic write cannot overwrite newer rename state. */
+    /** Legacy sockets have no durable token, so explicit teardown is their revocation fence. */
+    private readonly droppedSessions;
     private topicsPersistQueue;
+    /** Serializes recovery compare/write/publish claims so competing endpoint migrations cannot durably diverge. */
+    private recoveryBindingClaimQueue;
+    /** Durable compensation fences retry under supervision until persistence succeeds. */
+    private readonly compensationFenceRetries;
     /** Daemon edit attempts that can race an accepted user service message. */
     private readonly daemonRenameAttempts;
     private readonly selectedAckPending;
@@ -616,10 +791,17 @@ export declare class TelegramNotificationDaemon {
     private readonly draftStream;
     /** Identity-bearing sessions by repo/branch surface, used to avoid transient duplicate topics. */
     private readonly topicOwnerByIdentity;
+    /** Ephemeral legacy topic owners retained across a same-socket config rekey. */
+    private readonly legacyTopicOwners;
+    /** Preserved initiator topics must not route through a rekeyed transport. */
+    private readonly preservedInitiatorTopics;
     /** Non-identity frames held until identity creates the correct thread. */
     private readonly pendingThreadedFrames;
-    /** Endpoint generation tombstones for sessions that already sent session_closed. */
+    /** Durable endpoint leases for sessions that already sent an authorized session_closed. */
     private readonly closedEndpointKeys;
+    /** Exactly one authorized transport may route each recovered logical session. */
+    private readonly logicalSessionOwners;
+    private nextSocketLeaseToken;
     /** True once the daemon has nudged the user to enable Threaded Mode. */
     private threadedFallbackNoticeSent;
     /** Sessions whose identity header was already sent flat (Threaded Mode off). */
@@ -698,6 +880,7 @@ export declare class TelegramNotificationDaemon {
     private pruneSeenUpdateIds;
     private rememberSeenUpdateId;
     private reserveSeenUpdateId;
+    private releaseSeenUpdateId;
     scanRoots(): Promise<void>;
     connectSession(sessionId: string, url: string, token: string): void;
     /**
@@ -734,7 +917,6 @@ export declare class TelegramNotificationDaemon {
     private topicIdentityKey;
     private topicIdentityBase;
     private topicOwnerForIdentity;
-    private sessionCanClaimIdentity;
     private toolActivityOwner;
     private toolActivityAuthorityIsCurrent;
     private submitThreadedFrame;
@@ -759,7 +941,9 @@ export declare class TelegramNotificationDaemon {
     private deleteTopic;
     private persistTopics;
     loadTopics(): Promise<void>;
-    /** Download a Telegram file by its file_path (from getFile) into memory. */
+    /** Retry crash-interrupted topic deletes; only a definite Telegram result clears the durable fence. */
+    private reconcilePendingTopicDeletes;
+    /** Download one Telegram file with the Bot API's 20 MiB ceiling and one end-to-end deadline. */
     private downloadTelegramFile;
     /**
      * Per-session private temp directories (mode 0700) holding inbound non-image
@@ -781,6 +965,7 @@ export declare class TelegramNotificationDaemon {
      * to append to the injected text.
      */
     private resolveInboundAttachment;
+    private resolveInboundAttachmentSerial;
     /**
      * Serialize all pool flushes. Every caller (`submitThreadedFrame`, the flat
      * fallback, the drain timer's `void this.flushPool()`, topic teardown) goes

package/dist/types/sdk/bus/telegram-reference.d.ts

@@ -73,6 +73,7 @@ export declare function buildActionMessage(action: {
     id: string;
     question?: string;
     options?: string[];
+    recommendedIndex?: unknown;
     controls?: readonly TelegramActionControl[];
     summary?: string;
 }): RenderedMessage;
@@ -81,6 +82,7 @@ export declare function buildActionMarkdown(action: {
     kind: "ask" | "idle";
     question?: string;
     options?: string[];
+    recommendedIndex?: unknown;
     summary?: string;
 }): string;
 /** Send Telegram HTML text chunks sequentially so long messages preserve order. */

package/dist/types/sdk/bus/topic-registry.d.ts

@@ -38,8 +38,22 @@ export interface TopicRecord {
     replaySeq?: number;
     /** Serialized authority epoch; a late create may commit only in its starting epoch. */
     authorityEpoch?: number;
+    /** Immutable authority epoch held when this remote topic create began. */
+    creationLeaseEpoch?: number;
     /** An uncertain delete fences future creation and inbound routing. */
     authorityState?: "active" | "delete_pending";
+    /** Telegram chat and endpoint authority last proven to use this topic. */
+    chatId?: string;
+    /** Canonical endpoint tuple (URL + token) that currently holds the lease. */
+    endpointKey?: string;
+    /** Authenticated endpoint authority digest, excluding transport presentation. */
+    endpointDigest?: string;
+    /** SDK event generation associated with the current endpoint lease. */
+    endpointGeneration?: number;
+    /** Monotonic authenticated endpoint handoffs; legacy bindings begin at zero. */
+    endpointIncarnation?: number;
+    /** True when persisted binding fields were present but malformed; recovery must fail closed. */
+    bindingMalformed?: true;
 }
 /** Serialisable shape persisted to disk. */
 export interface TopicRegistryState {
@@ -47,6 +61,34 @@ export interface TopicRegistryState {
     topics: Record<string, TopicRecord>;
     /** Durable deletion epochs retained after a definite delete. */
     fences?: Record<string, number>;
+    /** Closed transport endpoint leases; unchanged endpoint discovery remains fenced across restart. */
+    closedEndpoints?: Record<string, TopicEndpointBinding>;
+}
+/** Authenticated runtime binding for a durable topic lease. */
+export interface TopicEndpointBinding {
+    chatId: string;
+    endpointKey: string;
+    endpointDigest: string;
+    endpointGeneration?: number;
+}
+/** Discriminated durable endpoint authority for identity-less replay admission. */
+export type TopicEndpointAuthority = {
+    state: "none";
+} | {
+    state: "unique";
+    sessionId: string;
+} | {
+    state: "ambiguous";
+};
+/** Conditional rollback token for a delete fence publication. */
+export interface TopicDeleteAuthoritySnapshot {
+    sessionId: string;
+    topicId?: string;
+    authorityEpoch?: number;
+    authorityState?: TopicRecord["authorityState"];
+    fenceEpoch?: number;
+    /** Exact fenced record, retained to restore an in-memory tombstone after a failed clear publication. */
+    record?: TopicRecord;
 }
 export declare function emptyTopicRegistryState(): TopicRegistryState;
 /**
@@ -61,9 +103,17 @@ export declare class TopicRegistry {
     private readonly byTopic;
     /** In-flight create promises, keyed by session, to dedupe concurrent creates. */
     private readonly inflight;
+    /** Newly-created records being durably published; never routable until committed. */
+    private readonly staged;
+    /** Socket-specific provenance for transient endpoint claims. */
+    private readonly transientClaimants;
+    /** Endpoint claims registered before a remote topic create can publish a record. */
+    private readonly creatingBindings;
     /** Monotonic authority epochs, including deletion fences for absent records. */
     private readonly epochs;
     constructor(state?: TopicRegistryState);
+    /** Replace all runtime state after a successfully persisted staged publication. */
+    replace(state: TopicRegistryState): void;
     /** Merge serialized state and normalize authority fields from older releases. */
     load(state: TopicRegistryState): void;
     private rebuildInboundRoutes;
@@ -71,13 +121,39 @@ export declare class TopicRegistry {
     sessionForTopic(topicId: string): string | undefined;
     /** All session ids with a persisted topic record. */
     sessionIds(): string[];
+    /** Persisted remote deletes that must be reconciled before recovery can proceed. */
+    deletePendingSessionIds(): string[];
     /** The existing topic record for a session, if any. */
     get(sessionId: string): TopicRecord | undefined;
+    /** Current immutable authority epoch for a creation lease. */
+    authorityEpoch(sessionId: string): number;
+    /** Whether this session has an active, unambiguous topic authority. */
+    isActiveUnambiguous(sessionId: string): boolean;
+    /**
+     * Resolve endpoint authority for identity-less replay. An endpoint may bootstrap
+     * only when no committed, staged, or pre-create claim can own it; malformed
+     * partial bindings and deletion fences deliberately fail closed.
+     */
+    endpointAuthority(binding: TopicEndpointBinding, excludedTransientClaimant?: object): TopicEndpointAuthority;
+    /** Resolve a uniquely bound logical owner for callers that only need the owner. */
+    uniqueSessionForEndpoint(binding: TopicEndpointBinding): string | undefined;
+    /** Whether this exact session owns the complete durable endpoint binding. */
+    matchesEndpoint(sessionId: string, binding: TopicEndpointBinding): boolean;
+    /**
+     * Rebind an existing topic to an authenticated successor endpoint. The exact
+     * logical session id is proved by replay before this method is called. A
+     * rotated credential may replace only an inactive incumbent; concurrent
+     * incumbents, cross-chat records, malformed evidence, collisions, and delete
+     * fences remain fail-closed.
+     */
+    bindEndpoint(sessionId: string, binding: TopicEndpointBinding, activeEndpointKeys?: ReadonlySet<string>, allowEndpointRotation?: boolean): "bound" | "unchanged" | "rejected";
+    /** Undo a failed durable endpoint migration without disturbing concurrent metadata writers. */
+    restoreEndpointBinding(sessionId: string, expected: TopicEndpointBinding, previous: Pick<TopicRecord, "chatId" | "endpointKey" | "endpointDigest" | "endpointGeneration" | "endpointIncarnation">): boolean;
     /**
      * Return the existing active topic for `sessionId`, or create one via
      * `create` (called only on first use).
      */
-    getOrCreateTopic(sessionId: string, create: () => Promise<unknown>, now?: () => number, name?: string): Promise<TopicRecord>;
+    getOrCreateTopic(sessionId: string, create: () => Promise<unknown>, now?: () => number, name?: string, binding?: TopicEndpointBinding, commit?: () => Promise<void>, transientClaimant?: object): Promise<TopicRecord>;
     /** Mark the identity header as sent for a session. Idempotent. */
     markIdentitySent(sessionId: string): void;
     /** Whether the identity header still needs sending for this session. */
@@ -109,14 +185,24 @@ export declare class TopicRegistry {
     markUserNamePending(sessionId: string, name: string): boolean;
     /** Commit a successfully-applied daemon topic title. */
     markNameApplied(sessionId: string, name: string): void;
+    /** Capture only authority fields that a failed delete publication may restore. */
+    captureDeleteAuthority(sessionId: string): TopicDeleteAuthoritySnapshot;
+    /** Restore a failed delete fence only while its exact authority mutation remains current. */
+    restoreDeleteAuthority(snapshot: TopicDeleteAuthoritySnapshot): boolean;
+    /** Restore the exact delete fence after a failed compensation publication. */
+    restoreDeleteFence(snapshot: TopicDeleteAuthoritySnapshot): boolean;
     /** Fence new work before the remote delete starts, including an absent in-flight create. */
     beginDelete(sessionId: string): TopicRecord | undefined;
+    /** Retain an accepted create as deletion-fenced before remote compensation can begin. */
+    fenceAcceptedCreate(sessionId: string, topicId: string, now?: () => number, name?: string, binding?: TopicEndpointBinding): TopicRecord;
+    /** Fence an accepted create only when its exact creator lease still owns the record. */
+    fenceAcceptedCreateForLease(sessionId: string, topicId: string, creationLeaseEpoch: number, now?: () => number, name?: string, binding?: TopicEndpointBinding): TopicRecord | undefined;
     /** Wait for a revoked create to settle before admitting a later lifecycle epoch. */
     awaitInflight(sessionId: string): Promise<void>;
     /** Remove only after a definite remote deletion; ambiguity deliberately retains its fence. */
     settleDelete(sessionId: string, topicId: string): boolean;
     /** Remove a topic record immediately for local/test cleanup compatibility. */
     delete(sessionId: string): boolean;
-    /** Serialise for atomic persistence beside the daemon state. */
+    /** Serialise active records plus unpublished staged creates for atomic commit. */
     serialize(): TopicRegistryState;
 }

package/dist/types/sdk/client/discovery.d.ts

@@ -3,6 +3,8 @@ export interface SdkSessionEndpoint {
     sessionId: string;
     url: string;
     token: string;
+    pid?: number;
+    stale?: boolean;
     path: string;
 }
 export interface SdkDiscoveryWarning {

package/dist/types/sdk/client/liveness.d.ts

@@ -0,0 +1,7 @@
+import type { SdkSessionEndpoint } from "./discovery";
+export type SdkEndpointLiveness = "live" | "stale" | "dead" | "unknown";
+export interface SdkEndpointSelectionError {
+    code: "endpoint_stale" | "endpoint_dead" | "endpoint_unknown" | "no_live_endpoint" | "multiple_live_endpoints" | "not_found";
+}
+export declare function classifyEndpoint(endpoint: SdkSessionEndpoint): SdkEndpointLiveness;
+export declare function selectLiveEndpoint(records: readonly SdkSessionEndpoint[], explicitSessionId?: string): SdkSessionEndpoint | SdkEndpointSelectionError;

package/dist/types/sdk/host/control/operations.d.ts

@@ -5,7 +5,7 @@ export type ControlInput = Record<string, unknown>;
  * AgentSession and its controllers without exposing those concrete types here.
  */
 export interface ControlSurface {
-    prompt(text: string, images?: ControlValue): Promise<ControlValue> | ControlValue;
+    prompt(text: string, images?: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     steer(text: string): Promise<ControlValue> | ControlValue;
     followUp(text: string): Promise<ControlValue> | ControlValue;
     abort(): Promise<ControlValue> | ControlValue;

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

@@ -13,7 +13,7 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     onProviderDefinitionsRemoved?: (capability: string) => void;
     onReverseCancel?: (requestId: string, reason: "provider_disconnected" | "lease_released") => void;
     /** Best-effort capabilities mirrored from the native transport for out-of-band consumers. */
-    connectionCapabilities?: (connectionId: string) => ReadonlySet<string>;
+    connectionCapabilities?: (connectionId: string) => ReadonlySet<string> | undefined;
 }
 /** SDK hosting is independent of notification configuration. Only root sessions host an endpoint. */
 export declare function shouldHostSdk(_settings: unknown, isTopLevel: boolean, env?: NodeJS.ProcessEnv): boolean;

package/dist/types/sdk/host/query/handlers.d.ts

@@ -31,6 +31,14 @@ export interface SessionSurface {
         totalBytes: number;
     } | undefined>;
     getJobs(): unknown | Promise<unknown>;
+    /** Q26 keyed lookup of a submitted prompt's authoritative reconciliation status. */
+    getPromptStatus?(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): unknown | Promise<unknown>;
+    /** Q27 effective model-profile catalog from the live session registry. */
+    getModelProfiles?(): unknown[] | Promise<unknown[]>;
     /** Query rows backed by the session's installed binding map. */
     installedQueries?: ReadonlySet<string>;
 }
@@ -57,6 +65,7 @@ export interface QueryResponse {
         code: string;
         message: string;
         restartQuery?: boolean;
+        details?: unknown;
     };
 }
 export declare class QueryHandlers {

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

@@ -1,7 +1,9 @@
+export { MODEL_PROFILE_DISCOVERY_QUERY, MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES, type ModelProfileCatalogItem, type ModelProfileErrorCode, type ModelProfileErrorDetails, ModelProfileRegistryError, type ModelProfileRegistryErrorDetails, type UnknownModelProfileDetails, UnknownModelProfileError, } from "../config/model-profile-contract";
 export * as bus from "./bus";
 export * from "./client";
 export * as host from "./host";
 export * as mcp from "./mcp";
 export type { Q10CurrentThinkingLevel, Q10Model, Q10SettableThinkingLevel, Q10ThinkingCapabilities, Q10ThinkingEffort, Q10ThinkingMode, } from "./models";
+export * from "./prompt-status";
 export * from "./session";
 export * from "./session-directory";