@gajae-code/coding-agent 0.11.11 → 0.12.1

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

@@ -0,0 +1,69 @@
+import type { PromptReconciliationStatus, SdkPromptTerminalOutcome } from "../prompt-status";
+import type { PromptCorrelation } from "./prompt-reconciliation";
+export declare const RECONCILIATION_STORE_VERSION = 1;
+export declare const RECONCILIATION_SESSION_ID_PATTERN: RegExp;
+export declare const RECONCILIATION_DIR_NAME = ".sdk-reconciliation";
+export type ReconciliationKind = "prompt" | "skill";
+export interface DurableReconciliationRecord extends PromptCorrelation {
+    kind: ReconciliationKind;
+    clientRef?: string;
+    status: PromptReconciliationStatus;
+    error?: {
+        code: string;
+        message: string;
+    };
+    acceptedAt: number;
+    startedAt?: number;
+    terminalAt?: number;
+    outcome?: SdkPromptTerminalOutcome;
+    pendingOutcome?: SdkPromptTerminalOutcome;
+    /** Skill-only safe token; never skill args bodies. */
+    skillName?: string;
+}
+export interface ReconciliationStoreDocument {
+    version: typeof RECONCILIATION_STORE_VERSION;
+    sessionId: string;
+    records: DurableReconciliationRecord[];
+}
+export interface ReconciliationStoreFs {
+    mkdir(directory: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<unknown>;
+    readFile(file: string, encoding: "utf8"): Promise<string>;
+    writeFile(file: string, data: string, options: {
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(file: string): Promise<void>;
+    open(file: string, flags: string): Promise<{
+        sync(): Promise<void>;
+        close(): Promise<void>;
+        writeFile(data: string, encoding: "utf8"): Promise<void>;
+    }>;
+}
+export declare function isSafeReconciliationSessionId(sessionId: string): boolean;
+/** Derive private store path; throws if sessionId is unsafe (path escape). */
+export declare function reconciliationStorePath(sessionFile: string, sessionId: string): string;
+/**
+ * Settle non-terminal durable records after process death.
+ * Prompt records preserve a durable pending outcome; skills retain the existing
+ * reconciliation-incomplete result.
+ */
+export declare function settleProcessRestart(records: DurableReconciliationRecord[], now: number): DurableReconciliationRecord[];
+export interface ReconciliationStore {
+    readonly path: string | null;
+    readonly sessionId: string;
+    /** Serialize mutations; reload not required for single-process host (in-memory + write). */
+    transact(mutator: (records: DurableReconciliationRecord[]) => DurableReconciliationRecord[]): Promise<void>;
+    load(): Promise<DurableReconciliationRecord[]>;
+    /** Snapshot currently held in memory after last load/transact. */
+    snapshot(): DurableReconciliationRecord[];
+    delete(): Promise<void>;
+}
+export declare function createReconciliationStore(options: {
+    sessionFile: string | null | undefined;
+    sessionId: string;
+    fs?: ReconciliationStoreFs;
+    now?: () => number;
+}): ReconciliationStore;

package/dist/types/sdk/bus/rich-draft.d.ts

@@ -63,6 +63,7 @@ export declare class DraftStreamState {
 export declare function deliverDraft(botApi: BotApi, base: {
     chat_id: string | number;
     message_thread_id?: number;
+    disable_notification?: true;
 }, draftId: number, raw: string, log?: {
     warn(msg: string): void;
 }): Promise<void>;

package/dist/types/sdk/bus/rich-render.d.ts

@@ -43,6 +43,7 @@ export declare function shouldPromoteRich(input: {
 export declare function deliverRichWithFallback(botApi: BotApi, base: {
     chat_id: string | number;
     message_thread_id?: number;
+    disable_notification?: true;
 }, send: ThreadedSend, signal: AbortSignal, fallbackDeliver: () => Promise<void>, log?: {
     warn(msg: string): void;
 }): Promise<number | undefined>;
@@ -55,6 +56,7 @@ export declare function deliverRichWithFallback(botApi: BotApi, base: {
 export declare function deliverRichActionWithFallback(botApi: BotApi, base: {
     chat_id: string | number;
     message_thread_id?: number;
+    disable_notification?: true;
 }, opts: {
     markdown: string;
     replyMarkup?: unknown;

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

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

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

@@ -16,4 +16,16 @@
  * If neither --endpoint-file nor --session-id is given, the newest endpoint file
  * under <repo>/.gjc/state/sdk/ is used.
  */
+import { type TelegramNotificationSound } from "./telegram-reference";
+interface CliArgs {
+    botToken?: string;
+    chatId?: string;
+    endpointFile?: string;
+    sessionId?: string;
+    repo: string;
+    apiBase?: string;
+    sound: TelegramNotificationSound;
+    force: boolean;
+}
+export declare function parseArgs(argv: string[]): CliArgs;
 export {};

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

@@ -38,12 +38,19 @@ export declare const NOTIFICATION_PROTOCOL_VERSION = 3;
  * Generation 29 adds serving-epoch compatibility, sidecar heartbeat, root GC,
  * and Bot API cooldown structural fixes (#2956, #2960, #3048).
  * Generation 30 adds opt-in tool activity delivery, closed lifecycle phases,
- * and capability-versioned mixed-host compatibility.
+ * and capability-versioned mixed-host compatibility. Generation 31 rolls out
+ * non-Linux direct tmux lifecycle cleanup semantics. Generation 32 applies
+ * Telegram sound-notification policy across daemon delivery paths. Generation
+ * 33 adds action-bound multi-select state rendering and replay-safe option
+ * snapshots. Generation 34 converts non-photo image formats (including WebP)
+ * into Telegram-compatible photo uploads when possible. Generation 35 adds
+ * user-created topic adoption (forum-topic folder picker).
  */
-export declare const DAEMON_GENERATION = 30;
+export declare const DAEMON_GENERATION = 35;
 /**
  * Serving-compatibility boundary for daemon lifecycle requests. Epoch 1 covers
  * all builds published before this field existed; epoch 2 covered generation 29;
- * bump this to force serving convergence and reload of compatible live predecessors.
+ * epoch 3 covered generation 30; bump this to force serving convergence and
+ * reload of compatible live predecessors.
  */
-export declare const SERVING_EPOCH = 3;
+export declare const SERVING_EPOCH = 4;

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

@@ -62,6 +62,7 @@ export interface TelegramDaemonFs {
         dev?: number;
         ino?: number;
         ctimeMs?: number;
+        isDirectory?: () => boolean;
     }>;
     readEndpointFile?(path: string): Promise<NotificationEndpointFile>;
     exactUnlink?(path: string, identity: NotificationEndpointFileIdentity): Promise<NotificationExactUnlinkResult>;
@@ -722,6 +723,8 @@ export interface TelegramDaemonOptions {
         enabled: boolean;
     };
     idleTimeoutMs?: number;
+    /** TTL for durable topic-adoption intents (default 10 minutes). Observed, not a fixed contract. */
+    adoptionIntentTtlMs?: number;
     scanIntervalMs?: number;
     pid?: number;
     /** Liveness probe for skipping dead-PID endpoint records in {@link TelegramNotificationDaemon.scanRoots}. */
@@ -758,6 +761,8 @@ export interface TelegramDaemonOptions {
     toolActivity?: {
         enabled: boolean;
     };
+    /** Controls which Telegram sends play an audible notification. Defaults to all. */
+    sound?: "all" | "important" | "none";
     /**
      * Per-session Telegram forum-topic naming. `nameTemplate` supports the
      * `{repo}`, `{branch}`, and `{title}` placeholders; unset preserves the
@@ -958,7 +963,7 @@ export declare class TelegramNotificationDaemon {
     private reserveSeenUpdateId;
     private releaseSeenUpdateId;
     scanRoots(): Promise<void>;
-    connectSession(sessionId: string, url: string, token: string): void;
+    connectSession(sessionId: string, url: string, token: string): SessionSocket;
     /**
      * Start ack-based liveness for a session whose server advertised the
      * `client_ping_pong` capability. Each interval drops the session when no pong
@@ -1030,6 +1035,16 @@ export declare class TelegramNotificationDaemon {
     private deleteTopic;
     private persistTopics;
     loadTopics(): Promise<void>;
+    /**
+     * Rehydrate durable adoption intents after restart, then reconcile: a
+     * non-expired sidecar whose target session already has a committed topic
+     * record is a stale leftover (commit succeeded but sidecar cleanup failed)
+     * and is removed safely without touching the user topic.
+     */
+    loadAdoptionIntents(): Promise<void>;
+    /** Periodic sweep of expired adoption-intent sidecars (files only; no Telegram API). */
+    private startAdoptionSweepTimer;
+    private stopAdoptionSweepTimer;
     /** 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. */
@@ -1117,6 +1132,15 @@ export declare class TelegramNotificationDaemon {
     handleSessionMessage(session: SessionSocket, msg: any): Promise<void>;
     private answerCallbackQueryBestEffort;
     private sendStaleGuidance;
+    /**
+     * Consume a user-created forum topic (`forum_topic_created` service message)
+     * before edited/text routing. Authenticates the chat, user, privacy, and
+     * lifecycle state; offers home, recent folders, or explicit path entry. The
+     * selected path (or an exact `/session_create path <dir>`) creates a session
+     * that adopts this topic — never a duplicate topic. Non-routable durable
+     * intents prevent duplicate creation across concurrent first frames.
+     */
+    private handleForumTopicCreatedUpdate;
     /** Consume Telegram forum-topic rename service messages before text routing. */
     private handleForumTopicEdited;
     private processTelegramUpdate;

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

@@ -85,8 +85,17 @@ export declare function buildActionMarkdown(action: {
     recommendedIndex?: unknown;
     summary?: string;
 }): string;
+export type TelegramNotificationSound = "all" | "important" | "none";
+export type TelegramDeliveryLane = "ask" | "idle" | "live" | "finalized";
+/**
+ * Resolve Telegram's optional silent-delivery flag. `finalChunk` silences
+ * non-final actionable chunks under the `important` policy; `undefined`
+ * intentionally omits the field so Telegram uses its normal audible delivery
+ * behavior.
+ */
+export declare function telegramDisableNotification(sound: TelegramNotificationSound | undefined, lane: TelegramDeliveryLane, finalChunk?: boolean): true | undefined;
 /** Send Telegram HTML text chunks sequentially so long messages preserve order. */
-export declare function sendTelegramHtmlChunks(send: TelegramSend, chatId: string, text: string, inlineKeyboard?: InlineButton[][]): Promise<void>;
+export declare function sendTelegramHtmlChunks(send: TelegramSend, chatId: string, text: string, inlineKeyboard?: InlineButton[][], sound?: TelegramNotificationSound, lane?: TelegramDeliveryLane): Promise<void>;
 /** A protocol `reply` frame the client should send to the server. */
 export interface ReplyFrame {
     type: "reply";
@@ -128,6 +137,7 @@ export interface TelegramReferenceOptions {
     endpointFile: string;
     apiBase?: string;
     fetchImpl?: typeof fetch;
+    sound?: TelegramNotificationSound;
 }
 /**
  * Run the reference bridge until the WebSocket closes. Sends `action_needed` to

package/dist/types/sdk/bus/threaded-render.d.ts

@@ -14,13 +14,13 @@ export interface ThreadedSend {
     method: "sendMessage" | "sendPhoto" | "sendDocument";
     /** Rate-limit lane for prioritisation/fairness. */
     lane: RateLimitLane;
-    /** Message text (sendMessage) or photo caption (sendPhoto). */
+    /** Message text (sendMessage) or media caption (sendPhoto/sendDocument). */
     text?: string;
     /** Base64 image bytes for sendPhoto. */
     photoBase64?: string;
     /** Base64 file bytes for sendDocument. */
     documentBase64?: string;
-    /** Image MIME type for sendPhoto. */
+    /** Uploaded media MIME type. */
     mime?: string;
     /** Suggested document filename. */
     fileName?: string;
@@ -83,6 +83,7 @@ interface ThreadedFrame {
     status?: unknown;
     message?: unknown;
 }
+export declare function supportsTelegramPhotoUpload(mime: string | undefined): boolean;
 /** Format the one-time identity header as pinned bullets. */
 export declare function formatIdentityHeader(frame: {
     repo?: unknown;

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

@@ -42,6 +42,8 @@ export interface TopicRecord {
     creationLeaseEpoch?: number;
     /** An uncertain delete fences future creation and inbound routing. */
     authorityState?: "active" | "delete_pending";
+    /** Provenance for topics created by the user and adopted by GJC. Missing means daemon-created. */
+    topicOrigin?: "user_created";
     /** Telegram chat and endpoint authority last proven to use this topic. */
     chatId?: string;
     /** Canonical endpoint tuple (URL + token) that currently holds the lease. */
@@ -129,6 +131,14 @@ export declare class TopicRegistry {
     authorityEpoch(sessionId: string): number;
     /** Whether this session has an active, unambiguous topic authority. */
     isActiveUnambiguous(sessionId: string): boolean;
+    /**
+     * Pure read-only availability check for user-topic adoption. Rejects invalid
+     * ids and any id already committed, delete-pending/fenced, staged, or
+     * ambiguous, without mutating maps, epochs, or persistence. Used inside the
+     * {@link getOrCreateTopic} create callback to fail-closed before adopting a
+     * user-created topic id.
+     */
+    isTopicIdAvailable(topicId: 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
@@ -153,7 +163,7 @@ export declare class TopicRegistry {
      * 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, binding?: TopicEndpointBinding, commit?: () => Promise<void>, transientClaimant?: object): Promise<TopicRecord>;
+    getOrCreateTopic(sessionId: string, create: () => Promise<unknown>, now?: () => number, name?: string, binding?: TopicEndpointBinding, commit?: () => Promise<void>, transientClaimant?: object, topicOrigin?: TopicRecord["topicOrigin"]): 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. */

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

@@ -13,7 +13,7 @@ export interface ControlSurface {
     answerAsk(id: string, answer: ControlValue): Promise<ControlValue> | ControlValue;
     answerGate(id: string, response: ControlValue, expectedSessionId?: string, idempotencyKey?: string): Promise<ControlValue> | ControlValue;
     approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
-    invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+    invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
     setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
     operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
     replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;

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

@@ -7,6 +7,8 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
     query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
     /** Best-effort diagnostic observation of accepted control/query frames. */
     onRequest?: SdkRequestObserver;
+    /** Runs before a control response is sent; identity transitions use sendTerminal. */
+    beforeControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame, sendTerminal: () => Promise<void>) => void | Promise<void>;
     /** Runs only after a successful control response has been sent to the client. */
     afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
     installProviderDefinitions?: (capability: string, definitions: unknown) => void;

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

@@ -37,6 +37,11 @@ export interface SessionSurface {
         turnId?: string;
         clientRef?: string;
     }): unknown | Promise<unknown>;
+    getSkillInvokeStatus?(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. */

package/dist/types/sdk/host/query/revision-store.d.ts

@@ -1,3 +1,5 @@
+/** Test seam: spill directories currently tracked for postmortem cleanup. */
+export declare function trackedSpillDirectoriesForTest(): string[];
 export declare const MAX_REVISIONS_PER_RESOURCE = 8;
 export declare const MAX_PINNED_REVISIONS = 128;
 export declare const MAX_MEMORY_BYTES: number;

package/dist/types/sdk/host/reverse-leases.d.ts

@@ -33,7 +33,7 @@ export declare class ReverseLeaseRuntime {
     heartbeat(connectionId: string, leaseId: string): ProviderLease;
     release(connectionId: string, leaseId: string, handoffTo?: string): ProviderLease;
     disconnect(connectionId: string): void;
-    request(capability: string, method: string, payload: unknown): Promise<unknown>;
+    request(capability: string, method: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
     respond(connectionId: string, id: string, leaseId: string, result: unknown, error?: {
         code: string;
         message: string;

package/dist/types/sdk/prompt-status.d.ts

@@ -17,8 +17,10 @@
  *   prior outcome unknown — callers MUST NOT reuse a clientRef as a retry
  *   mechanism and MUST treat `unknown` as uncertainty, not proof of
  *   non-execution.
- * - The durability floor is the live session process: after restart or
- *   retained-record eviction, a lookup honestly reports `unknown`.
+ * - Prompt records survive process restart: an active prompt is finalized from its
+ *   durable pending outcome, or as `prompt_failed` when it has none. Only skill
+ *   records settle as `process_restart`, and a lookup reports `unknown` only after
+ *   retained-record TTL/capacity eviction.
  * - Q26 tracks prompts accepted through the SDK control surface (which always
  *   carries a requesting connection); submissions without a delivery owner are
  *   outside the reconciliation contract and hold no reservation.
@@ -34,8 +36,24 @@ export interface TurnPromptInput {
     images?: TurnPromptImageInput[];
     clientRef?: string;
 }
-/** Terminal outcome is preserved exactly; active records never age into terminal. */
+/**
+ * Terminal outcome is preserved exactly; active records never age into terminal. A
+ * prompt that is active at process restart is finalized from its durable pending
+ * outcome (or `prompt_failed` when it has none), so it never reports as unknown.
+ */
 export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
+export type SdkPromptStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
+export type SdkPromptFailureCode = "prompt_failed" | "prompt_deadline_exceeded";
+export type SdkPromptTerminalOutcome = {
+    kind: "stopped";
+    reason: SdkPromptStopReason;
+    provenance: "agent" | "client_cancel";
+} | {
+    kind: "failed";
+    code: SdkPromptFailureCode;
+    message: string;
+    provenance: "agent_failed" | "deadline";
+};
 /** Exactly one selector per lookup. */
 export type TurnPromptStatusSelector = {
     clientRef: string;
@@ -63,6 +81,7 @@ export interface TurnPromptReconciliationTerminalOk extends TurnPromptReconcilia
     startedAt?: number;
     /** Epoch milliseconds of the terminal transition. */
     terminalAt: number;
+    outcome?: SdkPromptTerminalOutcome;
 }
 export interface TurnPromptReconciliationFailed extends TurnPromptReconciliationIdentity {
     status: "failed";
@@ -73,6 +92,7 @@ export interface TurnPromptReconciliationFailed extends TurnPromptReconciliation
         code: string;
         message: string;
     };
+    outcome?: SdkPromptTerminalOutcome;
 }
 export interface TurnPromptReconciliationUnknown {
     status: "unknown";

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

@@ -12,6 +12,7 @@ import type { CustomCommandsLoadResult } from "../extensibility/custom-commands"
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { type ExtensionFactory, type ExtensionUIContext, type LoadExtensionsResult, type ToolDefinition } from "../extensibility/extensions";
 import { type ConstrainedPluginHook } from "../extensibility/gjc-plugins/constrained-hooks";
+import { type GjcRuntimeSnapshotProvider } from "../extensibility/gjc-plugins/runtime-quarantine";
 import { type Skill, type SkillWarning } from "../extensibility/skills";
 import type { FileSlashCommand } from "../extensibility/slash-commands";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -207,6 +208,11 @@ export interface CreateAgentSessionResult {
     lspServers?: LspStartupServerInfo[];
     /** Shared event bus for tool/extension communication */
     eventBus: EventBus;
+    /**
+     * Read-only view of GJC bundle runtime evidence for the activation generation
+     * this session published. Undefined when no GJC bundles participated.
+     */
+    gjcRuntimeSnapshot?: GjcRuntimeSnapshotProvider;
 }
 export type { PromptTemplate } from "../config/prompt-templates";
 export { Settings, type SkillsSettings } from "../config/settings";