@gajae-code/coding-agent 0.12.0 → 0.12.2

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

@@ -28,6 +28,7 @@ export interface NotificationSettingsSnapshot {
         botToken?: string;
         chatId?: string;
         activation?: Record<string, unknown>;
+        sound: "all" | "important" | "none";
         btw: {
             enabled: boolean;
         };
@@ -105,6 +106,7 @@ export interface NotificationConfig {
      * (those carrying {@link SPAWN_PROVENANCE_ENV}) unless they explicitly opt in.
      */
     sessionScope: "all" | "primary";
+    sound: "all" | "important" | "none";
     idleTimeoutMs: number;
     btw: {
         enabled: boolean;
@@ -177,7 +179,7 @@ export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is No
     chatId: string;
 };
 /** Is Discord configured with all credentials and routing identifiers required by its daemon. */
-export declare function isDiscordConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export declare function isDiscordConfigured(cfg: Pick<NotificationConfig, "enabled" | "discord">): cfg is Pick<NotificationConfig, "enabled"> & {
     discord: {
         botToken: string;
         applicationId: string;
@@ -186,7 +188,7 @@ export declare function isDiscordConfigured(cfg: NotificationConfig): cfg is Not
     };
 };
 /** Is Slack configured with both SDK tokens and its workspace/channel routing identifiers. */
-export declare function isSlackConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+export declare function isSlackConfigured(cfg: Pick<NotificationConfig, "enabled" | "slack">): cfg is Pick<NotificationConfig, "enabled"> & {
     slack: {
         botToken: string;
         appToken: string;
@@ -286,6 +288,8 @@ export interface RedactableAction {
     workflowGateId?: string;
     question?: string;
     options?: string[];
+    /** Selected zero-based option positions for transport-specific multi-select rendering. */
+    selectedOptionIndices?: number[];
     summary?: string;
     /** Optional zero-based recommendation into the authoritative raw options. */
     recommendedIndex?: number;

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

@@ -26,6 +26,7 @@ import type { AgentSessionEvent } from "../../session/agent-session";
 import type { AskAnswerSourceResult, AskRemoteControl } from "../../tools";
 import { SessionSdkHost } from "../host";
 import { CursorRegistry, RevisionStore } from "../host/query";
+import { type SdkPromptTerminalOutcome } from "../prompt-status";
 import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
@@ -348,6 +349,23 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     };
+    /** Binds the executing Agent run to a correlated prompt so cleanup targets only it. */
+    bindPromptExecutionHandle: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, handle: string | undefined) => void;
+    /** Reads the durable non-terminal claim for a correlated prompt, if any. */
+    peekPromptPendingOutcome: (correlation: {
+        commandId: string;
+        turnId: string;
+    }) => SdkPromptTerminalOutcome | undefined;
+    /** Claims, fences, finalizes, and publishes exactly one normalized prompt terminal. */
+    terminalizePrompt: (correlation: {
+        commandId: string;
+        turnId: string;
+    }, outcome: SdkPromptTerminalOutcome, extra?: {
+        finalText?: string;
+    }) => Promise<void>;
     /** Records a correlated prompt terminal boundary after agent unwind. */
     /** Atomically claims a correlated prompt terminal boundary after agent unwind. */
     recordPromptTerminal: (correlation: {
@@ -379,6 +397,7 @@ interface SessionRuntime {
         commandId?: string;
         turnId?: string;
         finalText?: string;
+        outcome?: SdkPromptTerminalOutcome;
     } | {
         type: "agent_failed";
         sessionId: string;
@@ -388,6 +407,7 @@ interface SessionRuntime {
             code: string;
             message: string;
         };
+        outcome?: SdkPromptTerminalOutcome;
     }) => void;
     /** Publishes one canonical agent-wire event to the client that owns the active prompt. */
     emitPromptEvent: (event: AgentSessionEvent) => void;
@@ -446,6 +466,15 @@ type SessionStartResult = {
     failure?: SdkStartupFailure;
     suppressExtensionError?: boolean;
 };
+/**
+ * Whether the notifications control channel is enabled.
+ *
+ * Trusted sources only: enabling it opens the session control/answer channel, so
+ * a repository must not be able to turn it on. `$env` merges the caller's
+ * `cwd/.env` into `process.env`; the sibling resolvers in `config.ts` and
+ * `session-control.ts` already read an injected env record rather than the merged
+ * view, and this direct read was the outlier.
+ */
 export declare function notificationsEnabled(): boolean;
 /** Workflow-gate answer shape. */
 interface GateAnswer {

package/dist/types/sdk/bus/kind-aware-reconciliation.d.ts

@@ -2,7 +2,8 @@
  * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
  * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
  */
-import { type PromptCorrelation, type PromptReconciliationStatus, type TurnPromptReconciliation } from "./prompt-reconciliation";
+import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
+import { type PromptCorrelation } from "./prompt-reconciliation";
 import type { ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
 export type { ReconciliationKind };
 export interface KindCorrelation extends PromptCorrelation {
@@ -20,6 +21,12 @@ export interface KindAwareReconciliation {
         type: "agent_failed";
         error: unknown;
     }): Promise<void>;
+    claimPendingOutcome(correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome): Promise<SdkPromptTerminalOutcome>;
+    finalizePromptOutcome(correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {
+        code: string;
+        message: string;
+    }): Promise<void>;
+    peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
     lookup(kind: ReconciliationKind, selector: {
         commandId?: string;
         turnId?: string;

package/dist/types/sdk/bus/lifecycle-control-runtime.d.ts

@@ -48,6 +48,8 @@ export declare function buildCreateArgv(frame: SessionCreateFrame, _ids: {
 /** Real daemon-safe tmux launcher: canonical owner-isolation plan + GJC tags. */
 export declare function daemonSpawnCreate(env?: NodeJS.ProcessEnv, opts?: {
     ownerIsolationProbe?: OwnerIsolationProbe;
+    platform?: NodeJS.Platform;
+    processIncarnation?: (pid: number) => string | undefined;
 }): (frame: SessionCreateFrame, ids: {
     lifecycleRequestId: string;
     intendedSessionId: string;
@@ -73,6 +75,8 @@ export declare function daemonResumeSession(env?: NodeJS.ProcessEnv, opts?: {
     sessionsRoot?: string;
     listSessions?: (env: NodeJS.ProcessEnv) => GjcTmuxSessionStatus[];
     ownerIsolationProbe?: OwnerIsolationProbe;
+    platform?: NodeJS.Platform;
+    processIncarnation?: (pid: number) => string | undefined;
 }): (target: {
     sessionIdOrPrefix: string;
     path?: string;

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

@@ -1,4 +1,5 @@
-import type { PromptCorrelation, PromptReconciliationStatus } from "./prompt-reconciliation";
+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";
@@ -14,6 +15,8 @@ export interface DurableReconciliationRecord extends PromptCorrelation {
     acceptedAt: number;
     startedAt?: number;
     terminalAt?: number;
+    outcome?: SdkPromptTerminalOutcome;
+    pendingOutcome?: SdkPromptTerminalOutcome;
     /** Skill-only safe token; never skill args bodies. */
     skillName?: string;
 }
@@ -43,8 +46,9 @@ export declare function isSafeReconciliationSessionId(sessionId: string): boolea
 /** 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: failed/process_restart.
- * Meaning: reconciliation incomplete — not proof of agent failure.
+ * 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 {

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,20 @@ 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). Generation 36 binds
+ * managed-session replacement to exact native filesystem authority.
  */
-export declare const DAEMON_GENERATION = 30;
+export declare const DAEMON_GENERATION = 36;
 /**
  * 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/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";