@sayknow-cli/coding-agent 0.3.8 → 0.3.9

package/dist/types/config/settings-schema.d.ts

@@ -130,6 +130,14 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "string";
         readonly default: undefined;
     };
+    readonly "notifications.telegram.rich.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly "notifications.telegram.richDraft.enabled": {
+        readonly type: "boolean";
+        readonly default: false;
+    };
     readonly "notifications.discord.botToken": {
         readonly type: "string";
         readonly default: undefined;
@@ -4102,6 +4110,12 @@ export interface NotificationsSettings {
     telegram: {
         botToken: string | undefined;
         chatId: string | undefined;
+        rich: {
+            enabled: boolean;
+        };
+        richDraft: {
+            enabled: boolean;
+        };
     };
     discord: {
         botToken: string | undefined;

package/dist/types/modes/components/thinking-selector.d.ts

@@ -1,10 +1,10 @@
-import type { Effort } from "@sayknow-cli/ai";
+import { type ThinkingLevel as ThinkingLevelValue } from "@sayknow-cli/agent-core";
 import { Container, SelectList } from "@sayknow-cli/tui";
 /**
  * Component that renders a thinking level selector with borders
  */
 export declare class ThinkingSelectorComponent extends Container {
     #private;
-    constructor(currentLevel: Effort, availableLevels: Effort[], onSelect: (level: Effort) => void, onCancel: () => void);
+    constructor(currentLevel: ThinkingLevelValue | undefined, availableLevels: ThinkingLevelValue[], onSelect: (level: ThinkingLevelValue) => void, onCancel: () => void);
     getSelectList(): SelectList;
 }

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -26,6 +26,7 @@ export declare class SelectorController {
     showProviderOnboarding(): void;
     showCustomModelPresetWizard(snapshot: ModelProfileConfig): void;
     showCustomProviderWizard(): void;
+    showEffortSelector(): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;
     showHistorySearch(): void;

package/dist/types/modes/interactive-mode.d.ts

@@ -96,6 +96,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
     locallySubmittedUserSignatures: Set<string>;
+    optimisticInjectedSignatures: Map<string, number>;
     lastSigintTime: number;
     lastEscapeTime: number;
     lastComposerClearEscapeTime: number;
@@ -218,6 +219,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showModelSelector(options?: {
         temporaryOnly?: boolean;
     }): void;
+    showEffortSelector(): void;
     showProviderOnboarding(): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;
     showUserMessageSelector(): void;

package/dist/types/modes/rpc/rpc-mode.d.ts

@@ -64,9 +64,7 @@ export declare function isFastLaneRpcCommand(type: RpcCommand["type"]): boolean;
 export declare function createRpcCommandScheduler(run: (command: RpcCommand) => Promise<void>, track: (task: Promise<void>) => void): {
     dispatch: (command: RpcCommand) => void;
 };
-export declare class RpcListenRefusedError extends Error {
-    constructor(socketPath: string);
-}
+export { RpcListenRefusedError } from "./rpc-socket-security";
 /**
  * Probe whether a unix-domain socket path has a live server accepting
  * connections. Returns `true` when a connection succeeds (a previous owner is

package/dist/types/modes/rpc/rpc-socket-security.d.ts

@@ -1,6 +1,9 @@
 export declare class RpcSocketSecurityError extends Error {
     constructor(message: string);
 }
+export declare class RpcListenRefusedError extends Error {
+    constructor(socketPath: string);
+}
 export declare function prepareRpcSocketPath(socketPath: string): Promise<void>;
 export declare function assertSafeClientSocket(socketPath: string): Promise<void>;
 export declare function verifyRpcSocketAfterListen(socketPath: string): Promise<void>;

package/dist/types/modes/types.d.ts

@@ -100,6 +100,7 @@ export interface InteractiveModeContext {
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
     locallySubmittedUserSignatures: Set<string>;
+    optimisticInjectedSignatures: Map<string, number>;
     lastSigintTime: number;
     lastEscapeTime: number;
     lastComposerClearEscapeTime: number;
@@ -223,6 +224,7 @@ export interface InteractiveModeContext {
     showModelSelector(options?: {
         temporaryOnly?: boolean;
     }): void;
+    showEffortSelector(): void;
     showProviderOnboarding(): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;
     showUserMessageSelector(): void;

package/dist/types/modes/utils/injected-user-submission.d.ts

@@ -0,0 +1,52 @@
+import type { ImageContent, TextContent } from "@sayknow-cli/ai";
+import type { InteractiveModeContext } from "../types";
+/**
+ * Normalize the content passed to an extension `sendUserMessage` call into a
+ * plain text string plus its image attachments. Mirrors the normalization in
+ * `AgentSession.sendUserMessage` (text parts joined with "\n") so the resulting
+ * text matches the eventual user `message_start` payload.
+ */
+export declare function normalizeInjectedUserContent(content: string | (TextContent | ImageContent)[]): {
+    text: string;
+    images: ImageContent[];
+    imageCount: number;
+};
+/**
+ * Record a remotely/programmatically injected user message (e.g. Telegram
+ * inbound routed through the extension API) into the interactive TUI, so it is
+ * captured in prompt history and shown immediately instead of only appearing
+ * once the eventual `message_start` event lands.
+ *
+ * Local TUI submissions never reach this path (they go through
+ * `session.prompt(...)` / `startPendingSubmission`), so this cannot double-add
+ * local prompt history.
+ *
+ * - Always adds the injected text to editor prompt history.
+ * - Idle injections optimistically render the user message and record a pending
+ *   injected optimistic signature (a counting Map, so multiple idle injections
+ *   before the first `message_start` do not clobber each other); the later user
+ *   `message_start` consumes one count and skips both the duplicate chat add and
+ *   the defensive editor clear (so a locally typed draft is preserved).
+ * - Busy/queued injections refresh the pending-message display, which the
+ *   caller has already populated by invoking `session.sendUserMessage(...)`
+ *   before this helper.
+ *
+ * This helper never clears the editor text.
+ */
+export declare function applyInjectedUserSubmission(ctx: InteractiveModeContext, input: {
+    content: string | (TextContent | ImageContent)[];
+    queued: boolean;
+}): void;
+/**
+ * Record one pending optimistic render for an injected user message.
+ *
+ * Injected sends are fire-and-forget and multiple idle injections can be
+ * rendered before the first `message_start` arrives, so a counting Map (not a
+ * single slot) tracks how many optimistic renders are outstanding per signature.
+ */
+export declare function incrementInjectedOptimisticSignature(ctx: InteractiveModeContext, signature: string): void;
+/**
+ * Consume one pending injected optimistic render for `signature`. Decrements the
+ * count (deleting the key at zero) and returns whether one was outstanding.
+ */
+export declare function consumeInjectedOptimisticSignature(ctx: InteractiveModeContext, signature: string): boolean;

package/dist/types/notifications/config-commands.d.ts

@@ -24,3 +24,12 @@ export interface ConfigCommandChange {
  * can fall through to treating it as a free-text injection).
  */
 export declare function parseInThreadConfigCommand(text: string): ConfigCommandChange | undefined;
+/**
+ * Parse a `/rich on|off` toggle. Returns `true`/`false` for a recognised
+ * on/off argument, or `undefined` otherwise (not a `/rich` command, or `/rich`
+ * with a missing/invalid argument). This is intentionally SEPARATE from
+ * `parseInThreadConfigCommand`: `/verbose`/`/redact` are producer/session config
+ * forwarded over the WS, whereas rich is Telegram-daemon delivery policy handled
+ * daemon-locally, so it never becomes a `config_command` frame or a user turn.
+ */
+export declare function parseRichToggleCommand(text: string): boolean | undefined;

package/dist/types/notifications/config.d.ts

@@ -14,6 +14,12 @@ export interface NotificationConfig {
     redact: boolean;
     verbosity: "lean" | "verbose";
     idleTimeoutMs: number;
+    rich: {
+        enabled: boolean;
+    };
+    richDraft: {
+        enabled: boolean;
+    };
 }
 /** Read typed config from Settings. */
 export declare function getNotificationConfig(settings: Settings): NotificationConfig;
@@ -25,6 +31,16 @@ export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is No
 };
 /** Is global config sufficient for auto-on (enabled + at least one configured adapter)? */
 export declare function isGloballyConfigured(cfg: NotificationConfig): boolean;
+/**
+ * Per-run opt-out for completion notifications, honored before settings lookups.
+ *
+ * `SKC_NOTIFY=off` (also `0` / `false`, case-insensitive) suppresses the
+ * completion notification surface for this process only. `config.yml` is
+ * untouched and child processes inherit the env var, which lets non-interactive
+ * fleet runs (`skc -p --no-session`) stay silent even when a user-level/global
+ * completion notification configuration is enabled.
+ */
+export declare function completionNotifyDisabledByEnv(env: NodeJS.ProcessEnv): boolean;
 /** Resolve whether the notifications extension should be registered at SDK startup. */
 export declare function shouldRegisterNotificationsExtension(input: {
     env: NodeJS.ProcessEnv;

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

@@ -61,6 +61,8 @@ export interface SessionCreateFrame {
     target: SessionCreateTarget;
     /** Reference to the daemon-written, once-consumed startup-prompt file. */
     startupPromptRef?: string;
+    /** Model profile preset to activate for the spawned session (--mpreset). */
+    modelPreset?: string;
 }
 /** Close (hard-kill, history preserved) a session. */
 export interface SessionCloseFrame {

package/dist/types/notifications/lifecycle-commands.d.ts

@@ -4,6 +4,7 @@ export type LifecycleCommandVerb = "session_create" | "session_close" | "session
 export type ParsedLifecycleCommand = {
     kind: "create";
     target: SessionCreateTarget;
+    modelPreset?: string;
 } | {
     kind: "close";
     target: SessionCloseTarget;

package/dist/types/notifications/lifecycle-control-runtime.d.ts

@@ -35,7 +35,8 @@ export declare function createRateLimiter(maxPerWindow: number, windowMs: number
  *  The launched session id is carried via `SKC_SESSION_ID` in the child env (see
  *  {@link daemonSpawnCreate}); the root `skc` launcher has no `--session-id`
  *  flag, so it must never appear in argv. Only flags the launch parser actually
- *  supports are emitted (`--worktree <branch>` for worktree targets). */
+ *  supports are emitted (`--worktree <branch>` for worktree targets,
+ *  `--mpreset <profile>` for model presets). */
 export declare function buildCreateArgv(frame: SessionCreateFrame, _ids: {
     intendedSessionId: string;
     startupPromptRef?: string;

package/dist/types/notifications/reply-sent-store.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Index of rich messages the daemon sent, mapping `${chat_id}:${message_id}` to
+ * the original markdown. Telegram does not echo a `sendRichMessage` message's
+ * text in a reply's `reply_to_message`, so a user replying to a rich final
+ * answer would otherwise strand the agent without the quoted context. The daemon
+ * records the markdown on every promoted send and looks it up on inbound replies
+ * to restore that context.
+ *
+ * Fail-closed and off-path-neutral: nothing is recorded unless a send was
+ * actually promoted to rich, `record` is a no-op on any error (the in-memory map
+ * is only mutated after the atomic persist succeeds), and `lookup` returns
+ * undefined on any miss or error, so a bad index write/read never kills the
+ * daemon.
+ */
+import * as fs from "node:fs";
+/**
+ * Minimal async filesystem surface the store needs. Structurally a subset of the
+ * daemon's `TelegramDaemonFs`, so the daemon can pass its own `fs` straight
+ * through and tests can inject a fake.
+ */
+export interface ReplySentStoreFs {
+    mkdir(path: string, opts?: fs.MakeDirectoryOptions): Promise<unknown>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string, opts?: fs.WriteFileOptions): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    chmod(path: string, mode: number): Promise<void>;
+}
+export declare class ReplySentStore {
+    #private;
+    constructor(input: {
+        agentDir: string;
+        fs?: ReplySentStoreFs;
+        now?: () => number;
+    });
+    /** Restore the persisted index into memory. No-op on a missing or corrupt file. */
+    load(): Promise<void>;
+    /**
+     * Record the original markdown of a rich message the daemon just sent. The
+     * text is capped at {@link MAX_TEXT_LENGTH}; the index is capped at
+     * {@link MAX_ENTRIES} (oldest-by-timestamp evicted). No-op on any failure: the
+     * in-memory map is only replaced after the atomic persist succeeds.
+     */
+    record(input: {
+        chatId: string | number;
+        messageId: number;
+        text: string;
+    }): Promise<void>;
+    /** Look up the original markdown for a message the daemon sent. undefined on miss or failure. */
+    lookup(input: {
+        chatId: string | number;
+        messageId: number;
+    }): string | undefined;
+}

package/dist/types/notifications/rich-draft.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Opt-in rich-draft streaming for a turn's in-progress preview.
+ *
+ * When the operator opts in (`richDraft.enabled`) the daemon streams LIVE turn
+ * markdown to the Bot API `sendRichMessageDraft` method as a debounced preview.
+ * Every failure is a harmless no-op (warn once, keep the daemon alive), and when
+ * off no draft call is ever made — so the off-state request bodies stay
+ * byte-identical.
+ */
+import type { BotApi } from "./telegram-daemon";
+import type { ThreadedSend } from "./threaded-render";
+/** Minimum gap between two draft sends for one session (debounce floor). */
+export declare const DRAFT_DEBOUNCE_MS = 1500;
+/**
+ * Wrap raw markdown + a monotonic draft id in the `sendRichMessageDraft` request
+ * payload shape: mirrors `buildRichMessage`'s proven `rich_message.markdown`
+ * content wrapper, with a top-level `draft_id` selecting the draft revision to
+ * update (a routing param, like `message_thread_id`).
+ */
+export declare function buildRichDraft(draftId: number, raw: string): {
+    draft_id: number;
+    rich_message: {
+        markdown: string;
+    };
+};
+/**
+ * Whether a granted send should stream a rich draft. Fail-closed: every clause
+ * must hold, otherwise no draft is sent. Mirrors `shouldPromoteRich` but targets
+ * the LIVE lane and the live-only `richDraftMarkdown` marker (set by
+ * `renderThreadedFrame` for non-finalized turn frames).
+ */
+export declare function shouldStreamDraft(input: {
+    enabled?: boolean;
+    send: ThreadedSend;
+}): boolean;
+/**
+ * Per-session debounce + monotonic draft-id state for draft streaming. Skips a
+ * draft when less than `debounceMs` has elapsed since the session's last SENT
+ * draft (the rate-limit pool already coalesces live frames to the latest, so a
+ * skipped frame is naturally superseded by the next one). `reset` clears a
+ * session's window when its turn finalizes so the next turn starts fresh.
+ */
+export declare class DraftStreamState {
+    #private;
+    constructor(debounceMs?: number);
+    /**
+     * If enough time has elapsed since the session's last draft, record `now` as
+     * the new last-sent time and return the next monotonic draft id; otherwise
+     * return `undefined` (debounced — the caller skips this frame).
+     */
+    tryClaim(sessionId: string, now: number): number | undefined;
+    /** Clear a session's debounce window (called when its turn finalizes). The
+     * global draft id keeps incrementing so ids are never reused across turns. */
+    reset(sessionId: string): void;
+}
+/**
+ * Best-effort delivery of a rich draft. Never throws and has no HTML fallback: a
+ * draft is a purely additive preview, so on any failure (a thrown transport
+ * error or an `{ ok: false }` JSON response — the transport returns `res.json()`
+ * for JSON methods, so `ok:false` does not throw) it warns exactly once and
+ * returns; the unchanged live HTML send still carries the content.
+ */
+export declare function deliverDraft(botApi: BotApi, base: {
+    chat_id: string | number;
+    message_thread_id?: number;
+}, draftId: number, raw: string, log?: {
+    warn(msg: string): void;
+}): Promise<void>;

package/dist/types/notifications/rich-render.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Rich-message promotion for stable non-editable Telegram text sends.
+ *
+ * When enabled, the daemon promotes eligible finalized `sendMessage` payloads
+ * carrying raw markdown to the Bot API `sendRichMessage` method. On any miss or
+ * failure the daemon keeps the unchanged HTML `sendMessage` path, so the
+ * off-state request bodies are byte-identical.
+ */
+import type { BotApi } from "./telegram-daemon";
+import type { ThreadedSend } from "./threaded-render";
+/**
+ * Telegram's hard per-message character ceiling (4096). Surfaced here purely as
+ * documentation and a marker for a future native rich-message splitter — it is
+ * intentionally NON-BEHAVIORAL and MUST stay that way: nothing in the rich path
+ * branches on this value.
+ *
+ * Overflow is already safe without it. The production final-answer text is capped
+ * at 3500 chars upstream (`summaryFromMessage(..., 3500)`), so a promoted
+ * `sendRichMessage` never approaches this ceiling; and if the Bot API ever rejects
+ * an oversized rich payload it returns `{ ok: false }`, which
+ * `deliverRichWithFallback` (below) turns into the chunked HTML `splitTelegramHtml`
+ * fallback (each chunk ≤ TELEGRAM_MESSAGE_LIMIT). This constant only marks where a
+ * future rich splitter would read its ceiling; wiring it into a branch would change
+ * byte-for-byte behavior and is out of scope.
+ */
+export declare const RICH_MESSAGE_LIMIT = 4096;
+/** Wrap raw markdown in the `sendRichMessage` request payload shape. */
+export declare function buildRichMessage(raw: string, extras?: {
+    reply_markup?: unknown;
+}): {
+    rich_message: {
+        markdown: string;
+    };
+    reply_markup?: unknown;
+};
+/**
+ * Whether a granted send should be promoted to `sendRichMessage`. Fail-closed
+ * and class-aware: every clause must hold, otherwise the daemon keeps the HTML path.
+ */
+export declare function shouldPromoteRich(input: {
+    enabled?: boolean;
+    send: ThreadedSend;
+}): boolean;
+/**
+ * Deliver the promoted rich message, falling back to `fallbackDeliver` (the
+ * unchanged HTML `sendMessage` loop) on any failure. A failure is either a
+ * thrown transport error or a `{ ok: false }` JSON response (the transport
+ * returns `res.json()` for JSON methods, so `ok:false` does not throw). On
+ * failure exactly one diagnostic is logged before the fallback runs; on success
+ * the fallback never runs.
+ *
+ * Returns the sent message's `message_id` on success (when the response carries
+ * one), otherwise `undefined` — including every failure/fallback path and a
+ * success whose response omits `result.message_id`. Callers that ignore the
+ * return value are unaffected.
+ */
+export declare function deliverRichWithFallback(botApi: BotApi, base: {
+    chat_id: string | number;
+    message_thread_id?: number;
+}, send: ThreadedSend, fallbackDeliver: () => Promise<void>, log?: {
+    warn(msg: string): void;
+}): Promise<number | undefined>;
+/**
+ * Deliver an action-needed (ask/idle) message via `sendRichMessage`, falling
+ * back to the unchanged HTML chunk loop on any failure. Mirrors
+ * {@link deliverRichWithFallback} but takes an explicit markdown body plus an
+ * optional top-level `reply_markup` (probe-confirmed: `sendRichMessage` accepts
+ * `reply_markup` alongside `rich_message`), and surfaces a structured outcome so
+ * the daemon can route inbound replies to the resulting message id.
+ *
+ * On rich success: returns `{ messageId, usedRich: true, usedFallback: false }`
+ * where `messageId` is `res.result.message_id` when present. On a `{ ok:false }`
+ * response or a thrown transport error: warns exactly once, runs `htmlFallback`,
+ * and returns `{ messageId, usedRich: false, usedFallback: true }` where
+ * `messageId` is the fallback's return value (the last HTML chunk's id).
+ */
+export declare function deliverRichActionWithFallback(botApi: BotApi, base: {
+    chat_id: string | number;
+    message_thread_id?: number;
+}, opts: {
+    markdown: string;
+    replyMarkup?: unknown;
+    requireMessageId?: boolean;
+}, htmlFallback: () => Promise<number | undefined>, log?: {
+    warn(msg: string): void;
+}): Promise<{
+    messageId?: number;
+    usedRich: boolean;
+    usedFallback: boolean;
+}>;

package/dist/types/notifications/telegram-daemon.d.ts

@@ -231,6 +231,14 @@ export interface TelegramDaemonOptions {
      * default applies (e.g. lifecycle control disabled), no control server starts.
      */
     createLifecycleControlServer?: LifecycleControlServerFactory | null;
+    /** Rich text promotion (enabled by default; see rich-render.ts). */
+    rich?: {
+        enabled: boolean;
+    };
+    /** Opt-in rich-draft streaming of live turn previews (off by default; see rich-draft.ts). */
+    richDraft?: {
+        enabled: boolean;
+    };
 }
 interface SessionSocket {
     sessionId: string;
@@ -268,6 +276,10 @@ export declare class TelegramNotificationDaemon {
     private readonly pool;
     private readonly poller;
     private readonly dispatchState;
+    /** Original markdown of rich messages we sent (chat+message_id), for restoring reply context on inbound replies. */
+    private readonly replyStore;
+    /** Per-session debounce + monotonic draft-id state for opt-in draft streaming. */
+    private readonly draftStream;
     /** Identity-bearing sessions by repo/branch surface, used to avoid transient duplicate topics. */
     private readonly topicOwnerByIdentity;
     /** Non-identity frames held until identity creates the correct thread. */
@@ -376,7 +388,17 @@ export declare class TelegramNotificationDaemon {
     private ensureAttachmentDir;
     private cleanupAllAttachmentDirs;
     private resolveInboundAttachment;
+    /**
+     * Serialize all pool flushes. Every caller (`submitThreadedFrame`, the flat
+     * fallback, the drain timer's `void this.flushPool()`, topic teardown) goes
+     * through one promise chain, so two flushes never interleave — a live send can
+     * never be in-flight while a finalized flush reads `liveMessages` and decides
+     * to post a fresh (duplicate) final. Errors are swallowed so one failed flush
+     * never poisons the queue (each flush is already best-effort internally).
+     */
+    private flushChain;
     private flushPool;
+    private flushPoolInner;
     /**
      * Track the Telegram message id backing a streamed `(sessionId, coalesceKey)`
      * so later live/finalized frames edit it in place. Evicts this session's stale

package/dist/types/notifications/telegram-reference.d.ts

@@ -59,6 +59,13 @@ export declare function buildActionMessage(action: {
     options?: string[];
     summary?: string;
 }): RenderedMessage;
+/** Render an `action_needed` body as raw markdown (rich-message source; the HTML fallback stays on buildActionMessage). */
+export declare function buildActionMarkdown(action: {
+    kind: "ask" | "idle";
+    question?: string;
+    options?: string[];
+    summary?: string;
+}): string;
 /** 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>;
 /** A protocol `reply` frame the client should send to the server. */

package/dist/types/notifications/threaded-render.d.ts

@@ -34,6 +34,13 @@ export interface ThreadedSend {
      * message. Set for streamed turn frames so live + finalized share one message.
      */
     editable?: boolean;
+    /** Rich message class metadata. Only finalized final-answer sends are ever
+     * rich-promoted; the daemon gate (`shouldPromoteRich`) requires exactly this. */
+    richClass?: "final";
+    /** Rich final-answer markdown (raw). Delivery marker derived ONLY from a frame's `finalAnswer` bit; never inferred from `phase`. */
+    richMarkdown?: string;
+    /** Live-turn raw markdown for opt-in draft streaming (set ONLY on non-finalized turn frames; never triggers rich-final promotion, which requires `lane === "finalized"`). */
+    richDraftMarkdown?: string;
 }
 interface ThreadedFrame {
     type?: unknown;
@@ -50,6 +57,7 @@ interface ThreadedFrame {
     diff?: unknown;
     cwd?: unknown;
     phase?: unknown;
+    finalAnswer?: boolean;
     text?: unknown;
     messageRef?: unknown;
     source?: unknown;

package/dist/types/skc-runtime/tmux-common.d.ts

@@ -2,6 +2,7 @@ import type { ResolvedTmuxBinary } from "./psmux-detect";
 export declare const SKC_DEFAULT_TMUX_SESSION = "sayknow_cli";
 export declare const SKC_TMUX_SESSION_PREFIX = "sayknow_cli_";
 export declare const SKC_TMUX_COMMAND_ENV = "SKC_TMUX_COMMAND";
+export declare const SKC_TMUX_ACTIVE_SESSION_ENV = "SKC_TMUX_ACTIVE_SESSION";
 export declare const SKC_TMUX_PROFILE_ENV = "SKC_TMUX_PROFILE";
 export declare const SKC_TMUX_MOUSE_ENV = "SKC_MOUSE";
 export declare const SKC_TMUX_PROFILE_OPTION = "@skc-profile";

package/dist/types/utils/pasted-image-path.d.ts

@@ -0,0 +1,30 @@
+export interface DecodePastedPathOptions {
+    /**
+     * Platform whose path semantics apply when decoding (shell unescaping,
+     * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
+     * injectable so tests can pin the win32 contract from any host.
+     */
+    platform?: NodeJS.Platform;
+    /** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
+    homedir?: string;
+}
+export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
+    /** Base directory for relative paths. Defaults to `process.cwd()`. */
+    cwd?: string;
+}
+/**
+ * Decode pasted text into a filesystem path candidate. No filesystem access.
+ *
+ * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
+ * win32 where `\` is the path separator), quoted paths, `file://` URIs
+ * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
+ * expansion. Returns `undefined` when the text is empty, spans multiple
+ * lines, or is an invalid `file://` URI.
+ */
+export declare function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined;
+/**
+ * Returns the resolved path when the whole pasted text is a single path to an
+ * existing image file (verified by extension AND content signature),
+ * otherwise `undefined` (the paste is inserted as text).
+ */
+export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@sayknow-cli/coding-agent",
-	"version": "0.3.8",
+	"version": "0.3.9",
 	"description": "Sayknow-CLI CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://sayknow-cli.com",
 	"author": "jaybeyond",
@@ -52,12 +52,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@sayknow-cli/stats": "0.3.8",
-		"@sayknow-cli/agent-core": "0.3.8",
-		"@sayknow-cli/ai": "0.3.8",
-		"@sayknow-cli/natives": "0.3.8",
-		"@sayknow-cli/tui": "0.3.8",
-		"@sayknow-cli/utils": "0.3.8",
+		"@sayknow-cli/stats": "0.3.9",
+		"@sayknow-cli/agent-core": "0.3.9",
+		"@sayknow-cli/ai": "0.3.9",
+		"@sayknow-cli/natives": "0.3.9",
+		"@sayknow-cli/tui": "0.3.9",
+		"@sayknow-cli/utils": "0.3.9",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/notify-cli.ts

@@ -249,18 +249,18 @@ export async function promptForToken(
 }
 
 const THREADED_ENABLED_SUCCESS =
-	"Telegram Threaded Mode capability verified for this bot. SKC will request a private-chat topic per session; if Telegram ever refuses topic creation, notifications fall back to this flat chat with a one-time nudge.\n";
+	"Telegram Threaded Mode capability verified for this bot. SKC will request a private-chat topic per session; if Telegram ever refuses topic creation, notifications fall back to this flat chat with inline ask buttons only and a one-time Threaded Mode nudge.\n";
 
 const THREADED_MISSING_WARNING =
-	"Warning: Telegram getMe did not include has_topics_enabled, so SKC cannot verify private-chat Threaded Mode capability for this bot. Setup will continue; update Telegram/Bot API support or re-run setup if per-session topics fail.\n";
+	"Warning: Telegram getMe did not include has_topics_enabled, so SKC cannot verify private-chat Threaded Mode capability for this bot. Setup will continue; flat private-chat fallback supports outbound notifications and inline ask buttons only. Free-text replies and session commands require Threaded Mode/topic routing.\n";
 
 const THREADED_NONINTERACTIVE_WARNING =
-	"Warning: Telegram Threaded Mode capability is OFF for this bot. Setup will be saved because this run is non-interactive, but per-session Telegram delivery may fail closed until the bot owner enables Threaded Mode in @BotFather. SKC cannot enable it through the Bot API.\n";
+	"Warning: Telegram Threaded Mode capability is OFF for this bot. Setup will be saved because this run is non-interactive. Flat private-chat fallback supports outbound notifications and inline ask buttons only; free-text replies and session commands require enabling Threaded Mode in @BotFather > Bot Settings > Threads Settings.\n";
 
 const THREADED_DISABLED_GUIDANCE =
 	"Telegram Threaded Mode is OFF for this bot. SKC needs Telegram private-chat topics so each session can use its own thread.\n" +
-	"SKC cannot enable this through the Bot API. Open @BotFather, select this bot, enable Threaded Mode / forum topics for private chats, then return here.\n" +
-	"Telegram may require an additional Stars purchase fee for private-chat topics.\n";
+	"SKC cannot enable this through the Bot API. Open @BotFather > Bot Settings > Threads Settings for this bot, enable Threaded Mode / forum topics for private chats, then return here.\n" +
+	"Without Threaded Mode, flat private-chat fallback supports outbound notifications and inline ask buttons only; free-text replies and session commands require topic routing.\n";
 
 const THREADED_DISABLED_PROMPT =
 	"Press Enter after enabling Threaded Mode, or type skip to finish setup with a warning: ";
@@ -270,7 +270,7 @@ const THREADED_STILL_OFF = "Telegram still reports Threaded Mode OFF for this bo
 const THREADED_RETRY_PROMPT = "Press Enter to check again, or type skip to finish setup with a warning: ";
 
 const THREADED_SKIP_WARNING =
-	"Warning: continuing without verified Telegram Threaded Mode capability. Setup will be saved, but per-session Telegram delivery may fail closed until Threaded Mode is enabled in BotFather.\n";
+	"Warning: continuing without verified Telegram Threaded Mode capability. Setup will be saved. Flat private-chat fallback supports outbound notifications and inline ask buttons only; free-text replies and session commands require enabling Threaded Mode in BotFather.\n";
 
 const THREADED_INVALID_INPUT = "Type Enter to retry or skip to continue with a warning.\n";
 
@@ -500,8 +500,10 @@ ${chalk.bold("Examples:")}
 
 ${chalk.bold("Threaded Mode:")}
   SKC uses Telegram private-chat topics for per-session threads. Setup verifies the bot
-  capability via getMe.has_topics_enabled. If it is off, enable Threaded Mode in @BotFather;
-  bots cannot toggle it through the Bot API. If Telegram refuses topic creation at runtime,
-  SKC delivers flat to the paired private chat and nudges you to enable Threaded Mode.
+  capability via getMe.has_topics_enabled. Enable Threaded Mode in @BotFather > Bot Settings
+  > Threads Settings; bots cannot toggle it through the Bot API. If Telegram refuses topic
+  creation at runtime, SKC delivers flat to the paired private chat with outbound notifications
+  and inline ask buttons only, then nudges you to enable Threaded Mode for free-text replies
+  and session commands.
 `);
 }