@sayknow-cli/coding-agent 0.3.8 → 0.3.10

package/CHANGELOG.md

@@ -4,6 +4,19 @@ Sayknow-CLI is a rebranded fork of [gajae-code](https://github.com/Yeachan-Heo/g
 This file tracks the **fork's own releases**; upstream's full feature history lives
 in that project. Each release notes the upstream version it is built on.
 
+## [0.3.10] — 2026-07-09
+
+### Changed
+
+- Synced onto upstream **gajae-code v0.9.2**, carrying the 0.9.2 patch set into
+  Sayknow-CLI while preserving the SKC fork layer and release surface.
+
+### Fixed
+
+- Updated the release version surfaces so `skc --version`, package metadata,
+  native sentinel exports, plugin metadata, schemas, and public sync checks report
+  **0.3.10** consistently.
+
 ## [0.3.0] — 2026-06-23
 
 ### Changed

package/dist/types/cli/args.d.ts

@@ -14,6 +14,7 @@ export interface Args {
     mpreset?: string;
     default?: boolean;
     apiKey?: string;
+    credential?: string;
     systemPrompt?: string;
     appendSystemPrompt?: string;
     thinking?: Effort;

package/dist/types/cli/notify-cli.d.ts

@@ -19,12 +19,17 @@ export interface NotifyCommandDeps {
     setupRedact?: boolean;
     setupInteractive?: boolean;
     threadedModePrompt?: (message: string) => Promise<string>;
+    tokenPrompt?: () => Promise<string>;
+    setExitCode?: (code: number) => void;
+    exitProcess?: (code: number) => void;
 }
 export declare function parseNotifyArgs(args: string[]): NotifyCommandArgs | undefined;
 export declare function runNotifyCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;
+export declare function runNotifyCliCommand(cmd: NotifyCommandArgs, deps?: NotifyCommandDeps): Promise<void>;
 type TokenPromptInput = NodeJS.ReadStream & {
     isRaw?: boolean;
     setRawMode?: (mode: boolean) => unknown;
+    pause?: () => unknown;
 };
 type TokenPromptOutput = Pick<NodeJS.WriteStream, "write">;
 export declare function promptForToken(input?: TokenPromptInput, output?: TokenPromptOutput): Promise<string>;

package/dist/types/cli.d.ts

@@ -40,6 +40,9 @@ export declare class RootHelpCommand extends Command {
         "api-key": import("@sayknow-cli/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        credential: import("@sayknow-cli/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         "system-prompt": import("@sayknow-cli/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

package/dist/types/commands/launch.d.ts

@@ -37,6 +37,9 @@ export default class Index extends Command {
         "api-key": import("@sayknow-cli/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        credential: import("@sayknow-cli/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         "system-prompt": import("@sayknow-cli/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

package/dist/types/config/model-profile-activation.d.ts

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "@sayknow-cli/agent-core";
+import { ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { Api, Model } from "@sayknow-cli/ai";
 import type { AgentSession } from "../session/agent-session";
 import { type ModelRegistry, type SkcModelAssignmentTargetId } from "./model-registry";
@@ -16,6 +16,10 @@ export interface PrepareModelProfileActivationOptions {
     settings: Pick<Settings, "get">;
     profileName: string;
 }
+export interface ApplyModelProfileActivationOptions {
+    persistDefault?: boolean;
+    thinkingLevelOverride?: ThinkingLevel;
+}
 export interface PreparedModelProfileActivation {
     profileName: string;
     session: ModelProfileActivationSession & {
@@ -55,10 +59,6 @@ export declare function materializeActiveModelProfileAssignment(options: Materia
 export declare function materializeActiveModelProfileAssignments(options: MaterializeModelProfileAssignmentsOptions): boolean;
 export declare function formatModelProfileCredentialError(profileName: string, providers: readonly string[]): string;
 export declare function prepareModelProfileActivation(options: PrepareModelProfileActivationOptions): Promise<PreparedModelProfileActivation>;
-export declare function applyPreparedModelProfileActivation(prepared: PreparedModelProfileActivation, options?: {
-    persistDefault?: boolean;
-}): Promise<void>;
-export declare function activateModelProfile(options: PrepareModelProfileActivationOptions, applyOptions?: {
-    persistDefault?: boolean;
-}): Promise<void>;
+export declare function applyPreparedModelProfileActivation(prepared: PreparedModelProfileActivation, options?: ApplyModelProfileActivationOptions): Promise<void>;
+export declare function activateModelProfile(options: PrepareModelProfileActivationOptions, applyOptions?: ApplyModelProfileActivationOptions): Promise<void>;
 export {};

package/dist/types/config/model-registry.d.ts

@@ -1,4 +1,4 @@
-import { type Api, type AssistantMessageEventStream, type CacheRetention, type Context, type Model, type ModelRefreshStrategy, type ModelRequestTransform, type SimpleStreamOptions, type ThinkingConfig } from "@sayknow-cli/ai";
+import { type Api, type AssistantMessageEventStream, type AuthCredentialSelector, type CacheRetention, type Context, type Model, type ModelRefreshStrategy, type ModelRequestTransform, type SimpleStreamOptions, type ThinkingConfig } from "@sayknow-cli/ai";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@sayknow-cli/ai/utils/oauth/types";
 import { type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage } from "../session/auth-storage";
@@ -19,6 +19,8 @@ export interface ModelRoleInfo {
 }
 export declare const MODEL_ROLES: Record<ModelRole, ModelRoleInfo>;
 export declare const MODEL_ROLE_IDS: ModelRole[];
+export declare const MODEL_PROFILE_NAME_PATTERN: RegExp;
+export declare const MODEL_PROFILE_NAME_PATTERN_DESCRIPTION = "lowercase letters, numbers, dots, underscores, or hyphens";
 export type SkcModelAssignmentTargetId = "default" | "executor" | "architect" | "planner" | "critic";
 export interface SkcModelAssignmentTargetInfo extends ModelRoleInfo {
     id: SkcModelAssignmentTargetId;
@@ -342,6 +344,8 @@ export declare class ModelRegistry {
     getModelProfile(name: string): ModelProfileDefinition | undefined;
     getAvailableModelProfileNames(): string[];
     saveCustomModelProfile(name: string, definition: ModelProfileConfig): Promise<ModelProfileDefinition>;
+    renameCustomModelProfile(name: string, displayName: string): Promise<ModelProfileDefinition>;
+    deleteCustomModelProfile(name: string): Promise<ModelProfileConfig>;
     applyConfiguredModelBindings(targetSettings: Settings): void;
     /**
      * Get all models (built-in + custom).
@@ -382,11 +386,15 @@ export declare class ModelRegistry {
     /**
      * Get API key for a model.
      */
-    getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
+    getApiKey(model: Model<Api>, sessionId?: string, options?: {
+        credentialSelector?: AuthCredentialSelector;
+    }): Promise<string | undefined>;
     /**
      * Get API key for a provider (e.g., "openai").
      */
-    getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined>;
+    getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string, options?: {
+        credentialSelector?: AuthCredentialSelector;
+    }): Promise<string | undefined>;
     /**
      * Check if a model is using OAuth credentials (subscription).
      */

package/dist/types/config/model-resolver.d.ts

@@ -2,7 +2,7 @@
  * Model resolution, scoping, and initial selection
  */
 import { ThinkingLevel } from "@sayknow-cli/agent-core";
-import { type Api, type Effort, type KnownProvider, type Model } from "@sayknow-cli/ai";
+import { type Api, type KnownProvider, type Model } from "@sayknow-cli/ai";
 import { type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
 /** Default model IDs for each known provider */
@@ -204,7 +204,7 @@ export declare function findInitialModel(options: {
     isContinuing: boolean;
     defaultProvider?: string;
     defaultModelId?: string;
-    defaultThinkingSelector?: Effort;
+    defaultThinkingSelector?: ThinkingLevel;
     modelRegistry: InitialModelRegistry;
 }): Promise<InitialModelResult>;
 /**

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;
@@ -942,7 +950,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly defaultThinkingLevel: {
         readonly type: "enum";
-        readonly values: readonly Effort[];
+        readonly values: readonly ["off", ...Effort[]];
         readonly default: Effort;
         readonly ui: {
             readonly tab: "model";
@@ -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/config/settings.d.ts

@@ -82,6 +82,13 @@ export declare class Settings {
      * Call before exit to ensure all changes are persisted.
      */
     flush(): Promise<void>;
+    /**
+     * Like {@link flush}, but rejects if the durable save fails instead of
+     * swallowing the error. Use where the caller must confirm persistence before
+     * reporting success (e.g. the Telegram `/rich` toggle). In-memory instances
+     * ({@link isolated}) short-circuit in {@link #saveNow} and never throw.
+     */
+    flushOrThrow(): Promise<void>;
     cloneForCwd(cwd: string): Promise<Settings>;
     getStorage(): AgentStorage | null;
     getCwd(): string;

package/dist/types/extensibility/runtime-skill-discovery.d.ts

@@ -0,0 +1,20 @@
+import type { SkillsSettings } from "../config/settings-schema";
+import type { Skill } from "./skills";
+export type RuntimeSkillDiscoverySource = "project" | "user";
+export interface RuntimeSkillDiscoveryCandidate {
+    name: string;
+    description: string;
+    source: RuntimeSkillDiscoverySource;
+    path: string;
+    useWhen?: string[];
+}
+export interface DiscoverRuntimeSkillsOptions {
+    cwd: string;
+    home?: string;
+    query?: string;
+    limit?: number;
+    source?: RuntimeSkillDiscoverySource | "all";
+    policy?: SkillsSettings;
+}
+export declare function discoverRuntimeSkills(options: DiscoverRuntimeSkillsOptions): Promise<RuntimeSkillDiscoveryCandidate[]>;
+export declare function findRuntimeSkillByName(cwd: string, name: string, policy?: SkillsSettings, home?: string): Promise<Skill | undefined>;

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

@@ -1,4 +1,4 @@
-import type { ThinkingLevel } from "@sayknow-cli/agent-core";
+import { type ThinkingLevel as ThinkingLevelValue } from "@sayknow-cli/agent-core";
 import type { Effort } from "@sayknow-cli/ai";
 import { Container, SettingsList } from "@sayknow-cli/tui";
 import { type SettingPath } from "../../config/settings";
@@ -13,7 +13,7 @@ export interface SettingsRuntimeContext {
     /** Available thinking levels (from session) */
     availableThinkingLevels: Effort[];
     /** Current thinking level (from session) */
-    thinkingLevel: ThinkingLevel | undefined;
+    thinkingLevel: ThinkingLevelValue | undefined;
     /** Available themes */
     availableThemes: string[];
     /** Available model profile names (from the model registry) */

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

@@ -1,10 +1,15 @@
-import type { Effort } from "@sayknow-cli/ai";
+import { type ThinkingLevel as ThinkingLevelValue } from "@sayknow-cli/agent-core";
 import { Container, SelectList } from "@sayknow-cli/tui";
+export interface ThinkingSelectorSelection {
+    level: ThinkingLevelValue;
+    persistDefault: boolean;
+}
 /**
  * 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: (selection: ThinkingSelectorSelection) => void, onCancel: () => void);
+    handleInput(data: string): 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

@@ -28,6 +28,7 @@ import type { Theme } from "./theme/theme";
 export type CompactionQueuedMessage = {
     text: string;
     mode: "steer" | "followUp";
+    followUpQueuePolicy?: "sequential";
 };
 export type SubmittedUserInput = {
     text: string;
@@ -100,6 +101,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 +225,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

@@ -18,9 +18,47 @@ export interface ConfigCommandChange {
     verbosity?: "lean" | "verbose";
     redact?: boolean;
 }
+export type TelegramControlCommandName = "reasoning" | "usage" | "context" | "compact";
+export type TelegramControlCommand = {
+    name: "reasoning";
+    action: "cycle" | "status" | "set";
+    level?: string;
+} | {
+    name: "usage";
+} | {
+    name: "context";
+} | {
+    name: "compact";
+    instructions?: string;
+};
+export type TelegramControlCommandParseResult = {
+    kind: "none";
+} | {
+    kind: "ignored";
+    commandName: TelegramControlCommandName;
+} | {
+    kind: "command";
+    command: TelegramControlCommand;
+} | {
+    kind: "invalid";
+    commandName: TelegramControlCommandName;
+    usage: string;
+};
+export declare function telegramControlCommandUsage(commandName: TelegramControlCommandName): string;
+/** Parse deterministic Telegram session-control commands. Recognised roots fail closed. */
+export declare function parseTelegramControlCommand(text: string, botUsername?: string): TelegramControlCommandParseResult;
 /**
  * Parse an in-thread config command. Returns the requested change, or
  * `undefined` when the text is not a recognised config command (so the daemon
  * 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

@@ -18,7 +18,7 @@
  * generated), or `SKC_NOTIFICATIONS_TOKEN`.
  */
 import { Settings } from "../config/settings";
-import type { ExtensionAPI } from "../extensibility/extensions";
+import type { ExtensionAPI, ExtensionContext } from "../extensibility/extensions";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -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 {
@@ -174,6 +176,17 @@ export interface SessionReadyFrame {
  */
 export declare function readGitRepoName(cwd: string): string | undefined;
 export declare function notificationsEnabled(): boolean;
+interface NotificationControlCommandPayload {
+    name?: unknown;
+    action?: unknown;
+    level?: unknown;
+    instructions?: unknown;
+}
+export declare function executeNotificationControlCommand(command: NotificationControlCommandPayload | undefined, ctx: ExtensionContext, api: ExtensionAPI): Promise<{
+    status: "ok" | "error" | "unavailable";
+    message: string;
+}>;
 export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
     settings?: Settings;
 }): void;
+export {};

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