@sayknow-cli/coding-agent 0.3.8 → 0.3.10

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;
@@ -59,6 +67,8 @@ interface ThreadedFrame {
     name?: unknown;
     verbosity?: unknown;
     redact?: unknown;
+    status?: unknown;
+    message?: unknown;
 }
 /** Format the one-time identity header as pinned bullets. */
 export declare function formatIdentityHeader(frame: {

package/dist/types/notifications/topic-registry.d.ts

@@ -58,11 +58,10 @@ export declare class TopicRegistry {
     markIdentitySent(sessionId: string): void;
     /** Whether the identity header still needs sending for this session. */
     needsIdentity(sessionId: string): boolean;
-    /**
-     * Record the topic's applied title. Returns `true` when it changed (so the
-     * caller should `editForumTopic`), `false` when already current or unknown.
-     */
-    applyName(sessionId: string, name: string): boolean;
+    /** Whether a known session topic's applied title differs from `name`. */
+    needsRename(sessionId: string, name: string): boolean;
+    /** Commit a successfully-applied Telegram topic title. */
+    markNameApplied(sessionId: string, name: string): void;
     /** Remove a session topic record after Telegram deletes the topic. */
     delete(sessionId: string): boolean;
     /** Serialise for atomic persistence beside the daemon state. */

package/dist/types/runtime-credential-selector.d.ts

@@ -0,0 +1,7 @@
+import type { AuthCredentialSelector } from "@sayknow-cli/ai";
+export interface CliCredentialSelector {
+    provider?: string;
+    selector: AuthCredentialSelector;
+    raw: string;
+}
+export declare function parseCliCredentialSelector(raw: string): CliCredentialSelector;

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
 import { type AgentTelemetryConfig, type ThinkingLevel } from "@sayknow-cli/agent-core";
-import { type Model, type ProviderSessionState } from "@sayknow-cli/ai";
+import { type AuthCredentialSelector, type Model, type ProviderSessionState } from "@sayknow-cli/ai";
 import { createAppendOnlyContextManager, providerSupportsAppendOnlyAuto, resolveAppendOnlyMode } from "./append-only-mode";
 import { type Rule } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
@@ -55,6 +55,12 @@ export interface CreateAgentSessionOptions {
     /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
      * Keeps persisted session files isolated while reusing provider-side caches. */
     providerSessionId?: string;
+    /** Runtime credential selector for multi-account auth pools. */
+    credentialSelector?: {
+        provider?: string;
+        selector: AuthCredentialSelector;
+        raw: string;
+    };
     /** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
     customTools?: (CustomTool | ToolDefinition)[];
     /** Explicit parent/phase used to load active SKC sub-skill tools for this session. */

package/dist/types/session/agent-session.d.ts

@@ -270,6 +270,8 @@ export interface PromptOptions {
     images?: ImageContent[];
     /** When streaming, how to queue the message: "steer" (interrupt) or "followUp" (wait). */
     streamingBehavior?: "steer" | "followUp";
+    /** When set to "sequential", this follow-up is delivered one prompt at a time even if followUpMode is "all". */
+    followUpQueuePolicy?: "respect-mode" | "sequential";
     /** Optional tool choice override for the next LLM call. */
     toolChoice?: ToolChoice;
     /** Send as developer/system message instead of user. Providers that support it use the developer role; others fall back to user. */
@@ -657,7 +659,7 @@ export declare class AgentSession {
      * @throws Error if no model selected or no API key available (when not streaming)
      */
     prompt(text: string, options?: PromptOptions): Promise<void>;
-    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice" | "followUpQueuePolicy">): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -665,7 +667,7 @@ export declare class AgentSession {
     /**
      * Queue a follow-up message to process after the agent would otherwise stop.
      */
-    followUp(text: string, images?: ImageContent[]): Promise<void>;
+    followUp(text: string, images?: ImageContent[], options?: Pick<PromptOptions, "followUpQueuePolicy">): Promise<void>;
     queueDeferredMessage(message: CustomMessage): void;
     queueDeferredMessageForTests(message: CustomMessage, triggerTurn?: boolean): void;
     /**
@@ -679,6 +681,7 @@ export declare class AgentSession {
     sendCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
+        followUpQueuePolicy?: "respect-mode" | "sequential";
     }): Promise<void>;
     /** Remove undelivered queued custom messages matching `predicate` from executable queues and tagged display mirrors. */
     purgeQueuedCustomMessages(predicate: (message: CustomMessage) => boolean): PurgeQueuedCustomMessagesResult;
@@ -834,7 +837,7 @@ export declare class AgentSession {
     getAvailableModels(): Model[];
     /**
      * Set thinking level.
-     * Saves the effective metadata-clamped level to session and settings only if it changes.
+     * Saves the effective metadata-clamped level to the session, and to settings when requested.
      */
     setThinkingLevel(level: ThinkingLevel | undefined, persist?: boolean): void;
     /**

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/tools/index.d.ts

@@ -53,6 +53,7 @@ export * from "./review";
 export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./skill";
+export * from "./skill-discovery";
 export * from "./ssh";
 export * from "./subagent";
 export * from "./telegram-send";

package/dist/types/tools/skill-discovery.d.ts

@@ -0,0 +1,40 @@
+import type { AgentTool, AgentToolResult } from "@sayknow-cli/agent-core";
+import * as z from "zod/v4";
+import { type RuntimeSkillDiscoveryCandidate } from "../extensibility/runtime-skill-discovery";
+import type { ToolSession } from ".";
+declare const skillDiscoverySchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        project: "project";
+        user: "user";
+    }>>>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strict>;
+export type SkillDiscoveryToolInput = z.infer<typeof skillDiscoverySchema>;
+export interface SkillDiscoveryToolDetails {
+    candidates: RuntimeSkillDiscoveryCandidate[];
+    count: number;
+}
+export declare class SkillDiscoveryTool implements AgentTool<typeof skillDiscoverySchema, SkillDiscoveryToolDetails> {
+    #private;
+    readonly name = "skill_discovery";
+    readonly label = "SkillDiscovery";
+    readonly summary = "Discover project and user runtime skills by thin metadata";
+    readonly loadMode = "essential";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            all: "all";
+            project: "project";
+            user: "user";
+        }>>>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SkillDiscoveryTool | null;
+    execute(_toolCallId: string, input: SkillDiscoveryToolInput, signal?: AbortSignal): Promise<AgentToolResult<SkillDiscoveryToolDetails>>;
+}
+export {};

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.10",
 	"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.10",
+		"@sayknow-cli/agent-core": "0.3.10",
+		"@sayknow-cli/ai": "0.3.10",
+		"@sayknow-cli/natives": "0.3.10",
+		"@sayknow-cli/tui": "0.3.10",
+		"@sayknow-cli/utils": "0.3.10",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/cli/args.ts

@@ -3,6 +3,7 @@
  */
 import { type Effort, THINKING_EFFORTS } from "@sayknow-cli/ai";
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@sayknow-cli/utils";
+import { CliParseError } from "@sayknow-cli/utils/cli";
 import chalk from "chalk";
 import { parseEffort } from "../thinking";
 import { BUILTIN_TOOLS } from "../tools";
@@ -20,6 +21,7 @@ export interface Args {
 	mpreset?: string;
 	default?: boolean;
 	apiKey?: string;
+	credential?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;
 	thinking?: Effort;
@@ -136,6 +138,12 @@ export function parseArgs(args: string[]): Args {
 			result.default = true;
 		} else if (arg === "--api-key" && i + 1 < args.length) {
 			result.apiKey = args[++i];
+		} else if (arg === "--credential") {
+			const next = args[i + 1];
+			if (!next || next.startsWith("-")) {
+				throw new CliParseError("--credential requires <selector>");
+			}
+			result.credential = args[++i];
 		} else if (arg === "--system-prompt" && i + 1 < args.length) {
 			result.systemPrompt = args[++i];
 		} else if (arg === "--append-system-prompt" && i + 1 < args.length) {

package/src/cli/notify-cli.ts

@@ -31,6 +31,9 @@ export interface NotifyCommandDeps {
 	setupRedact?: boolean;
 	setupInteractive?: boolean;
 	threadedModePrompt?: (message: string) => Promise<string>;
+	tokenPrompt?: () => Promise<string>;
+	setExitCode?: (code: number) => void;
+	exitProcess?: (code: number) => void;
 }
 
 interface TelegramApiResponse<T> {
@@ -126,6 +129,27 @@ export async function runNotifyCommand(cmd: NotifyCommandArgs, deps: NotifyComma
 	}
 }
 
+export async function runNotifyCliCommand(cmd: NotifyCommandArgs, deps: NotifyCommandDeps = {}): Promise<void> {
+	try {
+		await runNotifyCommand(cmd, deps);
+	} catch (error) {
+		if (cmd.action !== "setup" || !(error instanceof Error)) {
+			throw error;
+		}
+
+		const cancelled = error.message === "Telegram bot token prompt cancelled.";
+		process.stderr.write(cancelled ? "Telegram notify setup cancelled.\n" : `Error: ${error.message}\n`);
+		const code = cancelled ? 130 : 1;
+		if (deps.setExitCode) {
+			deps.setExitCode(code);
+		} else {
+			process.exitCode = code;
+		}
+		const exitProcess = deps.exitProcess ?? (deps.setExitCode ? undefined : process.exit);
+		exitProcess?.(code);
+	}
+}
+
 async function getSettings(deps: NotifyCommandDeps): Promise<Settings> {
 	if (deps.settings) return deps.settings;
 	const { Settings } = await import("../config/settings");
@@ -136,7 +160,7 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 	const settings = await getSettings(deps);
 	const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
 	const apiBase = deps.apiBase ?? DEFAULT_API_BASE;
-	const token = deps.setupToken ?? (await promptForToken());
+	const token = deps.setupToken ?? (await (deps.tokenPrompt ?? promptForToken)());
 	if (!token.trim()) {
 		throw new Error("Telegram bot token is required.");
 	}
@@ -179,6 +203,7 @@ async function runSetup(deps: NotifyCommandDeps): Promise<void> {
 type TokenPromptInput = NodeJS.ReadStream & {
 	isRaw?: boolean;
 	setRawMode?: (mode: boolean) => unknown;
+	pause?: () => unknown;
 };
 
 type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
@@ -206,6 +231,7 @@ export async function promptForToken(
 			input.off("data", onData);
 			input.off("error", onError);
 			input.setRawMode?.(wasRaw);
+			input.pause?.();
 			output.write("\n");
 		};
 
@@ -249,18 +275,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 +296,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 +526,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.
 `);
 }

package/src/cli.ts

@@ -146,6 +146,10 @@ export class RootHelpCommand extends Command {
 		default: Flags.boolean({ description: "Persist --mpreset as the default model profile" }),
 		provider: Flags.string({ description: "Provider to use (legacy; prefer --model)" }),
 		"api-key": Flags.string({ description: "API key (defaults to env vars)" }),
+		credential: Flags.string({
+			description:
+				"Stored credential selector: email:<addr>, id:<n>, account:<id>, project:<id>, or provider/email:<addr>",
+		}),
 		"system-prompt": Flags.string({ description: "System prompt (default: coding assistant prompt)" }),
 		"append-system-prompt": Flags.string({ description: "Append text or file contents to the system prompt" }),
 		"allow-home": Flags.boolean({ description: "Allow starting in ~ without auto-switching to a temp dir" }),
@@ -191,6 +195,7 @@ export class RootHelpCommand extends Command {
 		`# Launch in a sibling git worktree\n  ${APP_NAME} --worktree`,
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Pin a stored credential for this session\n  ${APP_NAME} --credential email:me@example.com`,
 		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-medium`,
 		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencodego --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.skc/agent/sessions/--path--/session.jsonl`,

package/src/commands/launch.ts

@@ -87,6 +87,10 @@ export default class Index extends Command {
 		"api-key": Flags.string({
 			description: "API key (defaults to env vars)",
 		}),
+		credential: Flags.string({
+			description:
+				"Stored credential selector: email:<addr>, id:<n>, account:<id>, project:<id>, or provider/email:<addr>",
+		}),
 		"system-prompt": Flags.string({
 			description: "System prompt (default: coding assistant prompt)",
 		}),
@@ -181,6 +185,7 @@ export default class Index extends Command {
 		`# Launch in a sibling git worktree\n  ${APP_NAME} --worktree`,
 		`# Use different model (fuzzy matching)\n  ${APP_NAME} --model opus "Help me refactor this code"`,
 		`# Limit model cycling to specific models\n  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o`,
+		`# Pin a stored credential for this session\n  ${APP_NAME} --credential email:me@example.com`,
 		`# Activate a model profile for this session\n  ${APP_NAME} --mpreset codex-medium`,
 		`# Persist a model profile as the default\n  ${APP_NAME} --mpreset opencodego --default`,
 		`# Export a session file to HTML\n  ${APP_NAME} --export ~/.skc/agent/sessions/--path--/session.jsonl`,

package/src/commands/notify.ts

@@ -2,7 +2,7 @@
  * Configure Telegram notifications.
  */
 import { Args, Command, Flags } from "@sayknow-cli/utils/cli";
-import { type NotifyAction, type NotifyCommandArgs, runNotifyCommand } from "../cli/notify-cli";
+import { type NotifyAction, type NotifyCommandArgs, runNotifyCliCommand } from "../cli/notify-cli";
 import { initTheme } from "../modes/theme/theme";
 
 const ACTIONS: NotifyAction[] = ["setup", "status", "daemon-internal"];
@@ -56,6 +56,6 @@ export default class Notify extends Command {
 		};
 
 		if (action !== "daemon-internal") await initTheme();
-		await runNotifyCommand(cmd);
+		await runNotifyCliCommand(cmd);
 	}
 }

package/src/config/keybindings.ts

@@ -61,7 +61,7 @@ declare module "@sayknow-cli/tui" {
 }
 
 export function defaultMessageQueueKeysForPlatform(platform: NodeJS.Platform = process.platform): KeyId {
-	return platform === "win32" ? "alt+q" : "alt+enter";
+	return platform === "win32" || platform === "darwin" ? "alt+q" : "alt+enter";
 }
 
 /**