@gajae-code/coding-agent 0.11.7 → 0.11.9

package/dist/types/runtime-mcp/plugin-network-boundary.d.ts

@@ -0,0 +1,14 @@
+import { type AddressResolver } from "../web/insane/url-guard";
+import type { MCPHttpServerConfig, MCPSseServerConfig } from "./types";
+/** Mark an in-memory plugin-bundle remote MCP config for connection-bound public-network enforcement. */
+export declare function bindPluginMcpToPublicNetwork<T extends MCPHttpServerConfig | MCPSseServerConfig>(config: T): T;
+/** The marker is an internal symbol, so persisted user MCP configs cannot opt into or forge this path. */
+export declare function isPluginMcpPublicNetworkBound(config: MCPHttpServerConfig | MCPSseServerConfig): boolean;
+/**
+ * Fetch a plugin-bundle MCP request through a DNS-pinned public address. Every
+ * redirect is handled manually and revalidated before the next connection.
+ */
+export declare function fetchPluginMcpRequest(rawUrl: string, init: BunFetchRequestInit, options?: {
+    resolver?: AddressResolver;
+    maxRedirects?: number;
+}): Promise<Response>;

package/dist/types/runtime-mcp/redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function redactMCPEndpoint(value: string | undefined): string | undefined;
+export declare function redactMCPDiagnosticValue(value: unknown): unknown;

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

@@ -1,4 +1,5 @@
 import type { NativeDirectoryTreeSnapshot } from "@gajae-code/natives";
+import type { ModelProfileErrorDetails } from "../../config/model-profile-contract";
 import { type DirectoryMigrationPolicy } from "../session-directory";
 import { type BrokerDiscovery, type RedactedBrokerDiscovery } from "./discovery";
 import { type LifecycleDurableEffectsReceipt, LifecycleLedger, type LifecycleStartupFailureReceipt } from "./lifecycle-ledger";
@@ -93,6 +94,7 @@ export type BrokerResponse = {
     error: {
         code: BrokerErrorCode;
         message: string;
+        details?: ModelProfileErrorDetails;
         endpoint?: "unavailable";
         cleanup?: BrokerCleanupEvidence;
     };

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

@@ -70,6 +70,7 @@ export interface SessionLifecycleLaunchRequest {
 }
 export declare function readSessionLifecycleLaunchRequest(value: string | undefined, now?: number): SessionLifecycleLaunchRequest;
 type CleanupEvidence = BrokerCleanupEvidence;
+export declare function validateBrokerModelPresetForTest(agentDir: string, requestedProfile: string): string | BrokerResponse;
 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>;
@@ -79,6 +80,11 @@ export interface LifecycleTranscriptEvidence {
 }
 /** The child writes bounded startup diagnostics before exiting without readiness. */
 export declare function writeSessionLifecycleFailure(root: string, id: string, effectMarker: string, failure: SdkStartupFailure, rollback: SdkStartupRollbackResult, transcript?: LifecycleTranscriptEvidence, ownerIncarnation?: string): Promise<void>;
+export declare function readSessionLifecycleFailureForTest(root: string, id: string, expected: {
+    pid: number;
+    effectMarker: string;
+    incarnation: string;
+}): Promise<SdkStartupFailure | undefined>;
 export interface LifecycleExecutionOutcome {
     response: BrokerResponse;
     durableEffects?: LifecycleDurableEffectsReceipt;

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

@@ -9,7 +9,13 @@ export type ChatDaemonAction = "stop" | "reload";
  * Generation 7 restores macOS daemon signaling (kill(2) with a start-time
  * incarnation recheck) so a live/hung owner can be replaced without an external
  * `kill -9`. Generation 8 adopts Windows expected-identity ACL verification and
- * repair for shared native authority.
+ * repair for shared native authority. Generation 9 refreshes the shared native
+ * authority declaration contract with bounded frame-delivery acknowledgement.
+ * Generation 11 accepts typed retained exact-unlink cleanup authority — a
+ * concrete detached quarantine plus a proven-absent canonical lock pathname —
+ * when deleting an observed owner-lock lease. Generation 12 refreshes retained
+ * native path and process authority semantics. Generation 13 rejects special
+ * files before retained native authority opens.
  */
 export declare const CHAT_DAEMON_GENERATIONS: Readonly<Record<ChatDaemonKind, number>>;
 export declare function chatDaemonGeneration(kind: ChatDaemonKind): number;

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

@@ -5,8 +5,8 @@
  * removed), but the user can still adjust per-surface behaviour from inside a
  * session thread with small slash commands:
  *
- * - `/verbose`            switch the mirror to bounded tool-owned summaries + provider-displayable reasoning summaries
- * - `/lean`               switch back to lean (assistant text + tool names)
+ * - `/verbose`            switch the mirror to per-turn assistant text + tool summaries + reasoning summaries
+ * - `/lean`               settled assistant answer at idle + immediate ask lead-ins (no intermediate tool-turn flood)
  * - `/verbosity lean|verbose`
  * - `/redact on|off`      toggle redaction of streamed content
  *

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

@@ -287,6 +287,8 @@ export interface RedactableAction {
     question?: string;
     options?: string[];
     summary?: string;
+    /** Optional zero-based recommendation into the authoritative raw options. */
+    recommendedIndex?: number;
 }
 /**
  * When redact is true, strip sensitive content for remote delivery:

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

@@ -56,6 +56,7 @@ export declare class ConversationStore<T extends ConversationRecord> {
         pidAlive?: (pid: number) => boolean;
         sleep?: (ms: number) => Promise<void>;
         lockTimeoutMs?: number;
+        platform?: NodeJS.Platform;
     });
     get filePath(): string;
     load(): Promise<ConversationStoreDocument<T>>;

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

@@ -204,6 +204,7 @@ interface UnattendedGatePresentation {
     question: string;
     options: string[];
     controls: readonly AskRemoteControl[];
+    recommendedIndex?: number;
     multi: boolean;
     allowEmpty: boolean;
     navigationLabel?: "Next" | "Done";
@@ -343,6 +344,21 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     } | undefined) => boolean;
+    /** Transitions the authoritative reconciliation record at lifecycle ingress; terminal outcomes settle once. */
+    notePromptReconciliation: (correlation: {
+        commandId: string;
+        turnId: string;
+    } | undefined, frame: {
+        type: "agent_start" | "agent_end";
+    } | {
+        type: "agent_failed";
+        error: unknown;
+    }) => void;
+    /** Settles and emits one sanitized correlated prompt failure. */
+    emitPromptFailure: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, error: unknown) => void;
     /** Records correlated lifecycle frames for replay and delivers them only to the accepted requester after acknowledgement. */
     emitPromptLifecycle: (correlation: {
         commandId: string;
@@ -385,6 +401,15 @@ interface SessionRuntime {
         text?: string;
         messageRef?: string;
     };
+    /**
+     * Lean-mode deferred final answer: latest assistant text observed at `turn_end`,
+     * emitted once at `agent_end` so intermediate tool-turn narration does not flood
+     * remote clients. Cleared after flush or when replaced by a newer turn.
+     */
+    pendingSettled?: {
+        text: string;
+        messageRef?: string;
+    };
     /** Durable gates emitted while ownership is provisional; presented only after stable activation. */
     deferredGatePresentations: Array<() => void>;
     /** SDK control frames received during provisional ownership; replayed only after stable activation. */

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

@@ -30,6 +30,7 @@ export interface ProposedTelegramIdentityPreflightInput {
     deps?: {
         fs?: TelegramDaemonFs;
         pidAlive?: (pid: number) => boolean;
+        pidIncarnation?: (pid: number) => string | undefined;
     };
 }
 /**

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

@@ -0,0 +1,105 @@
+/**
+ * Bounded authoritative reconciliation state for Q26 `turn.prompt_status`.
+ *
+ * Separate from the lifecycle delivery buffers (promptSubmissions /
+ * promptTerminalTombstones), which exist to deliver frames and intentionally
+ * forget outcomes. This record preserves accepted/in_flight/terminal_ok/failed
+ * plus bounded sanitized failure metadata so a caller can reconcile a prior
+ * `turn.prompt` after disconnect/reconnect.
+ *
+ * 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
+ *   does a lookup honestly report `unknown`.
+ * - The durability floor is the live session process: restart means `unknown`.
+ * - The clientRef index is session-runtime scoped; a ref conflicts only while
+ *   retained and must never be reused as a retry mechanism.
+ * - Terminal transitions settle once: the first terminal outcome wins.
+ */
+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 declare const PROMPT_FAILURE_CODE_MAX = 64;
+export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+export interface PromptCorrelation {
+    commandId: string;
+    turnId: string;
+}
+export interface PromptReconciliationRecord extends PromptCorrelation {
+    clientRef?: string;
+    status: PromptReconciliationStatus;
+    error?: {
+        code: string;
+        message: string;
+    };
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt?: number;
+}
+export type TurnPromptReconciliation = {
+    status: "accepted";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+} | {
+    status: "in_flight";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+    startedAt: number;
+} | {
+    status: "terminal_ok";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt: number;
+} | {
+    status: "failed";
+    commandId: string;
+    turnId: string;
+    clientRef?: string;
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt: number;
+    error: {
+        code: string;
+        message: string;
+    };
+} | {
+    status: "unknown";
+};
+export interface PromptReconciliation {
+    /** Fail-closed admission BEFORE any execution; holds an identity-bound reservation. */
+    admit(clientRef?: string): void;
+    /** Discard one admission reservation without creating a record (rejection/cancellation). */
+    releaseAdmission(clientRef?: string): void;
+    /** Transition a reservation into the accepted record at preflight acceptance. */
+    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_failed";
+        error: unknown;
+    }): void;
+    lookup(selector: {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): TurnPromptReconciliation;
+    cleanup(): void;
+    activeCount(): number;
+}
+/** Safe-token code capped at 64; arbitrary failure text is never retained. */
+export declare function sanitizePromptFailure(error: unknown): {
+    code: string;
+    message: string;
+};
+export declare function createPromptReconciliation(options?: {
+    now?: () => number;
+}): PromptReconciliation;

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

@@ -24,7 +24,19 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * legacy stopped-lock reclamation in generation 14, Windows expected-identity
  * ACL verification and repair in generation 15, identity-fenced stale endpoint
  * startup recovery in generation 16, Telegram topic recovery authority fencing
- * in generation 17, and fail-closed blank-token validation plus lifecycle-startup
- * stop fencing in generation 18.
+ * in generation 17, fail-closed blank-token validation plus lifecycle-startup
+ * stop fencing in generation 18, recommended ask metadata rendering in
+ * generation 19, authoritative terminal session-close delivery and cleanup
+ * fencing, attested generation-bearing pre-incarnation owner handoff in
+ * generation 20, guarded modern generation-absent predecessor signaling in
+ * generation 21, dead Windows v0.10 owner replacement in generation 22, and
+ * retained native cleanup authority revalidation in generation 23, and typed
+ * retained exact-unlink cleanup authority acceptance (concrete detached
+ * quarantine plus proven canonical absence) in generation 24.
+ * Generation 25 adds startup dead-root prune + leak-artifact self-heal
+ * on TelegramNotificationDaemon.run (#2958). Generation 26 adds bounded reload
+ * cooldown and lazy Telegram topic lifecycle safeguards (#2956, #2960, #2984).
+ * Generation 27 refreshes retained native path and process authority semantics.
+ * Generation 28 rejects special files before retained native authority opens.
  */
-export declare const DAEMON_GENERATION = 18;
+export declare const DAEMON_GENERATION = 28;

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

@@ -24,8 +24,11 @@ export declare function writeTelegramControlRequest(settings: Settings, request:
 export declare function clearTelegramControlRequest(settings: Settings, requestId?: string, fsImpl?: TelegramDaemonFs): Promise<void>;
 export interface DaemonProcessReference {
     incarnation: string;
+    /** Whether the platform delivers the requested signal cooperatively or as a hard termination. */
+    termination: "cooperative" | "hard";
     signalRoot(signal: NodeJS.Signals): void;
 }
+export declare function defaultProcessReference(pid: number, platform?: NodeJS.Platform): DaemonProcessReference | undefined;
 export interface TelegramDaemonControlDeps {
     fs?: TelegramDaemonFs;
     now?: () => number;
@@ -58,6 +61,7 @@ export type TelegramGenerationReloadResult = {
     operation: DaemonOperationResult;
 };
 export declare class TelegramDaemonController implements BuiltInDaemonController {
+    #private;
     private readonly settings;
     private readonly deps;
     readonly kind: "telegram";
@@ -81,7 +85,7 @@ export declare class TelegramDaemonController implements BuiltInDaemonController
     private signalCapturedOwner;
     private result;
     reload(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
-    reloadForGenerationUpgrade(opts?: DaemonOperationOptions): Promise<TelegramGenerationReloadResult>;
+    reloadForGenerationUpgrade(opts?: DaemonOperationOptions, attestedLegacyUpgrade?: boolean): Promise<TelegramGenerationReloadResult>;
     stop(opts?: DaemonOperationOptions): Promise<DaemonOperationResult>;
     private stopOrReload;
     /** Clear only our exact control request; a successor request must survive. */

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

@@ -4,6 +4,7 @@ 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";
@@ -55,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>;
@@ -102,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;
@@ -137,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;
@@ -188,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;
@@ -197,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;
@@ -246,6 +353,7 @@ export declare function acquireDaemonOwnership(input: {
     provisional?: boolean;
     reason?: "identity_mismatch";
     reloadRequired?: boolean;
+    legacyReloadRequired?: boolean;
 }>;
 export declare function renewDaemonHeartbeat(input: {
     settings: Settings;
@@ -322,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;
@@ -339,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[];
@@ -363,6 +489,7 @@ export type TelegramSpawnOwnerResult = {
     runtime: DaemonRuntimeInfo;
     warnings: string[];
     reloadRequired?: boolean;
+    legacyReloadRequired?: boolean;
 } | {
     result: "blocked";
     runtime: DaemonRuntimeInfo;

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/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";