@sayknow-cli/coding-agent 0.3.7 → 0.3.9

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

@@ -17,7 +17,8 @@
  * Enable with Settings notifications config, `SKC_NOTIFICATIONS=1` (a token is
  * generated), or `SKC_NOTIFICATIONS_TOKEN`.
  */
-import type { ExtensionFactory } from "../extensibility/extensions";
+import { Settings } from "../config/settings";
+import type { ExtensionAPI } from "../extensibility/extensions";
 /** Where a `session_create` should run. Discriminated by `kind`. */
 export type SessionCreateTarget = {
     kind: "existing_path";
@@ -60,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 {
@@ -69,7 +72,7 @@ export interface SessionCloseFrame {
     chatId: string;
     token: string;
     target: SessionCloseTarget;
-    /** Hard-kill even if a live pane is attached (SKC-managed only). */
+    /** Required force-only close flag; false/omitted is rejected by daemon policy. */
     force?: boolean;
 }
 /** Resume a session (reattach if alive, else cold-restart from history). */
@@ -173,4 +176,6 @@ export interface SessionReadyFrame {
  */
 export declare function readGitRepoName(cwd: string): string | undefined;
 export declare function notificationsEnabled(): boolean;
-export declare const createNotificationsExtension: ExtensionFactory;
+export declare function createNotificationsExtension(api: ExtensionAPI, options?: {
+    settings?: Settings;
+}): void;

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;
@@ -23,8 +24,13 @@ export type ParsedLifecycleCommand = {
 } | {
     kind: "none";
 };
-/** True when the text begins a /session_* command (cheap pre-gate). */
-export declare function isLifecycleCommandText(text: string | undefined): boolean;
+/** True when the text begins with any /session_* token, regardless of addressability. */
+export declare function isLifecycleCommandLikeText(text: string | undefined): boolean;
+/** True when the text begins an addressable /session_* command (cheap pre-gate). */
+export declare function isLifecycleCommandText(text: string | undefined, ctx?: {
+    chatType?: string;
+    botUsername?: string;
+}): boolean;
 /**
  * Parse a paired-chat message into a lifecycle command. Returns `none` for
  * non-lifecycle text, `usage`/`reject` for malformed input (no side effect), or
@@ -33,7 +39,10 @@ export declare function isLifecycleCommandText(text: string | undefined): boolea
  * The caller MUST have already enforced paired-chat authorization; this function
  * performs grammar + target validation only.
  */
-export declare function parseLifecycleCommand(text: string | undefined): ParsedLifecycleCommand;
+export declare function parseLifecycleCommand(text: string | undefined, ctx?: {
+    chatType?: string;
+    botUsername?: string;
+}): ParsedLifecycleCommand;
 /** The canonical usage text (exported for the daemon's help replies). */
 export declare function lifecycleUsage(): string;
 /**

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

@@ -3,8 +3,8 @@ import type { Settings } from "../config/settings";
 import type { DaemonRuntimeInfo } from "../daemon/control-types";
 import { type ControlServerLike, type LifecycleControlServerFactory } from "./lifecycle-control-runtime";
 import { NotificationOperatorRuntime, OperatorBackoffPolicy } from "./operator-runtime";
-import { type AliasTable, type CallbackRoute, type PendingAsk } from "./telegram-reference";
-export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled";
+import { type AliasTable, type CallbackRoute } from "./telegram-reference";
+export type EnsureDaemonResult = "owner_spawned" | "attached" | "disabled" | "blocked";
 export interface DaemonState {
     pid: number;
     ownerId: string;
@@ -95,6 +95,8 @@ export declare function acquireDaemonOwnership(input: {
     acquired: boolean;
     ownerId?: string;
     attached?: boolean;
+    blocked?: boolean;
+    reason?: "identity_mismatch";
 }>;
 export declare function renewDaemonHeartbeat(input: {
     settings: Settings;
@@ -229,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;
@@ -252,6 +262,8 @@ export declare class TelegramNotificationDaemon {
     private readonly opts;
     readonly aliasTable: AliasTable;
     readonly messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
+    /** Telegram message id backing each streamed `${sessionId}:${coalesceKey}`, for in-place edits. */
+    private readonly liveMessages;
     readonly sessions: Map<string, SessionSocket>;
     private readonly runtime;
     private readonly sessionRouter;
@@ -264,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. */
@@ -276,6 +292,8 @@ export declare class TelegramNotificationDaemon {
     private readonly flatIdentitySent;
     /** Cached result of whether the paired chat is a private chat (flat-fallback gate). */
     private pairedChatPrivate;
+    /** Bot username from getMe, cached once at owner startup for group/forum command targeting. */
+    private botUsername;
     /** Sessions whose agent loop is currently busy (drives the typing indicator). */
     private get busy();
     /** Inbound update id → originating Telegram message, for delivery reactions. */
@@ -317,12 +335,17 @@ export declare class TelegramNotificationDaemon {
     /** Build an authenticated lifecycle frame from a parsed command + identity. */
     private buildLifecycleFrame;
     private handleLifecycleCommand;
+    private refreshBotIdentity;
     /** Map a lifecycle response/error to a user-facing message (G010 surfacing). */
     private formatLifecycleResponse;
     constructor(opts: TelegramDaemonOptions);
     private createSessionRouter;
     loadAliases(): Promise<void>;
     persistAliases(): Promise<void>;
+    loadSeenUpdateIds(): Promise<void>;
+    persistSeenUpdateIds(): Promise<void>;
+    private pruneSeenUpdateIds;
+    private rememberSeenUpdateId;
     scanRoots(): Promise<void>;
     connectSession(sessionId: string, url: string, token: string): void;
     /**
@@ -340,12 +363,15 @@ export declare class TelegramNotificationDaemon {
      * the socket. `scanRoots()` then reconnects the session.
      */
     private dropSession;
+    private deleteMessageRoutes;
     private static readonly THREADED_FRAMES;
     private topicNameFor;
     private topicIdentityKey;
     private topicIdentityBase;
     private topicOwnerForIdentity;
+    private sessionCanClaimIdentity;
     private submitThreadedFrame;
+    private existingTopicForPrivateChat;
     private rememberPendingThreadedFrame;
     private flushPendingThreadedFrames;
     private ensureTopic;
@@ -362,7 +388,23 @@ 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
+     * same-category entries (e.g. prior turns) so the map stays bounded.
+     */
+    private recordLiveMessage;
     private deliverFlatFallback;
     private pairedChatIsPrivate;
     private notifyThreadedFallback;
@@ -376,7 +418,7 @@ export declare class TelegramNotificationDaemon {
     private startTypingTimer;
     private stopTypingTimer;
     handleSessionMessage(session: SessionSocket, msg: any): Promise<void>;
-    pendingBySession: (sessionId?: string) => PendingAsk[];
+    private answerCallbackQueryBestEffort;
     private sendStaleGuidance;
     handleTelegramUpdate(update: unknown): Promise<void>;
     pollOnce(signal?: AbortSignal): Promise<number>;

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. */
@@ -81,14 +88,9 @@ export type RouteDecision = ({
 } | {
     kind: "ignore";
 };
-export interface PendingAsk {
-    sessionId: string;
-    actionId: string;
-}
 export interface RouteInboundContext {
     aliasTable: Pick<AliasTable, "get">;
     messageRoutes: Map<string | number, CallbackRoute | Omit<CallbackRoute, "answer">>;
-    pendingBySession: (sessionId?: string) => PendingAsk[];
     pairedChatId: string;
 }
 /** Route a Telegram update to a session/action without I/O. Fail closed under ambiguity. */

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

@@ -28,6 +28,19 @@ export interface ThreadedSend {
     coalesceKey?: string;
     /** True for the one-time identity header (the daemon pins it once). */
     identity?: boolean;
+    /**
+     * When true the daemon may deliver this as an in-place edit of the message
+     * previously sent under the same `(sessionId, coalesceKey)` instead of a new
+     * 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;
@@ -44,6 +57,7 @@ interface ThreadedFrame {
     diff?: unknown;
     cwd?: unknown;
     phase?: unknown;
+    finalAnswer?: boolean;
     text?: unknown;
     messageRef?: unknown;
     source?: unknown;

package/dist/types/runtime-api-key.d.ts

@@ -0,0 +1,7 @@
+export interface RuntimeApiKeyTarget {
+    setRuntimeApiKey(provider: string, apiKey: string): void;
+}
+export interface RuntimeApiKeyModel {
+    provider: string;
+}
+export declare function applyCliRuntimeApiKeyOverride(target: RuntimeApiKeyTarget, apiKey: string | undefined, model: RuntimeApiKeyModel | undefined): void;

package/dist/types/sdk.d.ts

@@ -1,5 +1,6 @@
 import { type AgentTelemetryConfig, type ThinkingLevel } from "@sayknow-cli/agent-core";
 import { 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";
 import { type ScopedModelSelection } from "./config/model-resolver";
@@ -241,5 +242,7 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+export { createAppendOnlyContextManager, providerSupportsAppendOnlyAuto, resolveAppendOnlyMode };
 export declare function createPluginHooksExtension(hooks: ConstrainedPluginHook[]): ExtensionFactory;
+export declare function resolveIntentTracingEnabled(intentTracingSetting: boolean | undefined, hasUI: boolean): boolean;
 export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

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

@@ -14,7 +14,7 @@
  */
 import { type Agent, type AgentEvent, type AgentMessage, type AgentState, type AgentTool, type StablePrefixSnapshot, ThinkingLevel } from "@sayknow-cli/agent-core";
 import { type CompactionResult, type EmergencyCompactionSample } from "@sayknow-cli/agent-core/compaction";
-import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@sayknow-cli/ai";
+import type { AssistantMessage, Effort, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ServiceTier, SimpleStreamOptions, TextContent, ToolCall, ToolChoice, UsageReport } from "@sayknow-cli/ai";
 export interface ForkContextSeedMetadata {
     sourceSessionId: string;
     parentMessageCount: number;
@@ -75,6 +75,7 @@ import { type DiscoverableTool, type DiscoverableToolSearchIndex } from "../tool
 import type { AskAnswerSource, ToolSession } from "../tools";
 import type { CheckpointState } from "../tools/checkpoint";
 import { type TodoItem, type TodoPhase } from "../tools/todo-write";
+import { type WorkspaceTree } from "../workspace-tree";
 import type { ClientBridge } from "./client-bridge";
 import { type ContributionPrepOptions, type ContributionPrepResult } from "./contribution-prep";
 import { type CustomMessage } from "./messages";
@@ -159,7 +160,7 @@ export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
     settings: Settings;
-    /** Models to cycle through with Ctrl+P (from --models flag) */
+    /** Models to cycle through with Alt+N (from --models flag) */
     scopedModels?: ScopedModelSelection[];
     /** Initial session thinking selector. */
     thinkingLevel?: ThinkingLevel;
@@ -200,6 +201,8 @@ export interface AgentSessionConfig {
     rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
         systemPrompt: string[];
     }>;
+    /** Initial workspace tree snapshot used for the first volatile per-turn context message. */
+    workspaceTree?: WorkspaceTree;
     /** Rebuild the SSH tool from current capability discovery results. */
     reloadSshTool?: () => Promise<AgentTool | null>;
     requestedToolNames?: ReadonlySet<string>;
@@ -317,6 +320,13 @@ export interface SessionStats {
     premiumRequests: number;
     cost: number;
 }
+export type QueuedMessageEditMode = "steer" | "followUp";
+export interface QueuedMessageEditEntry {
+    id: string;
+    text: string;
+    mode: QueuedMessageEditMode;
+    label: string;
+}
 /** A custom message contributed at the before-agent-start point. */
 export type BeforeAgentStartInternalMessage = Pick<CustomMessage, "customType" | "content" | "display" | "details" | "attribution">;
 /**
@@ -329,6 +339,33 @@ export type BeforeAgentStartContributor = (event: {
     images?: ImageContent[];
     sessionId: string | undefined;
 }) => Promise<BeforeAgentStartInternalMessage | undefined>;
+export declare class WorkerIntegrationRequestScheduler {
+    #private;
+    readonly request: () => Promise<void>;
+    constructor(request: () => Promise<void>);
+    enqueue(): void;
+    flush(): Promise<void>;
+}
+export type StreamingEditParsedToolCall = {
+    toolCall: ToolCall;
+    path: string;
+    resolvedPath: string;
+    diff?: string;
+    op?: string;
+    rename?: string;
+};
+export type StreamingEditParsedCacheEntry = {
+    version: string;
+    parsed: StreamingEditParsedToolCall | undefined;
+};
+export declare function getStreamingEditToolCallForEvent(event: AgentEvent, cache: Map<string, StreamingEditParsedCacheEntry>, resolvePath: (filePath: string) => string | undefined): StreamingEditParsedToolCall | undefined;
+/** Test-only counters for AgentSession event fan-out hot-path assertions. */
+export declare const __agentSessionPerfCounters: {
+    listenerSnapshotRebuilds: number;
+    messageUpdateExtensionQueues: number;
+    reset(): void;
+};
+export declare function buildContextInjectionSignature(kind: string, parts: readonly string[]): string;
 export declare class AgentSession {
     #private;
     readonly agent: Agent;
@@ -337,6 +374,13 @@ export declare class AgentSession {
     readonly taskDepth: number;
     readonly yieldQueue: YieldQueue;
     readonly configWarnings: string[];
+    readonly streamingEditDebugCounters: {
+        guardRuns: number;
+        processedChars: number;
+        checkedRemovedLines: number;
+        fullChecks: number;
+        nonEditDeterminations: number;
+    };
     readonly rawSseDebugBuffer: RawSseDebugBuffer;
     constructor(config: AgentSessionConfig);
     /** Model registry for API key resolution and model discovery */
@@ -670,8 +714,11 @@ export declare class AgentSession {
         steering: readonly string[];
         followUp: readonly string[];
     };
+    getQueuedMessageEntries(): QueuedMessageEditEntry[];
+    removeQueuedMessageForEditing(id: string): string | undefined;
+    moveQueuedMessageForEditing(id: string, direction: "up" | "down"): boolean;
     /**
-     * Pop the last queued message (steering first, then follow-up).
+     * Pop the newest queued message across steering and follow-up queues.
      * Used by dequeue keybinding to restore messages to editor one at a time.
      * Returns the popped entry's `.text`; the tag (if any) dies with the
      * record — no orphan state can outlive the queue entry.
@@ -706,6 +753,11 @@ export declare class AgentSession {
      * @returns true if completed, false if cancelled by hook
      */
     newSession(options?: NewSessionOptions): Promise<boolean>;
+    /**
+     * Clear active conversational/model context while preserving the current
+     * session identity and durable history trail.
+     */
+    clearContext(): Promise<boolean>;
     /**
      * Set a display name for the current session.
      */
@@ -905,9 +957,12 @@ export declare class AgentSession {
      */
     setAutoRetryEnabled(enabled: boolean): void;
     /**
-     * Manually retry the last failed assistant turn.
-     * Removes the error message from agent state and re-attempts with a fresh retry budget.
-     * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
+     * Manually retry the last failed assistant turn, or resume an interrupted tail
+     * left by a non-graceful process exit after the user/custom/tool-result message
+     * was persisted but before the agent emitted a terminal assistant response.
+     * Removes failed/aborted/unresolved tool-use assistant tails before
+     * re-attempting with a fresh retry budget.
+     * @returns true if retry/resume was initiated, false if no retryable tail exists or agent is busy
      */
     retry(): Promise<boolean>;
     /**

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

@@ -93,6 +93,7 @@ export declare class AgentStorage {
      * Sets a cached value with expiry time (unix seconds).
      */
     setCache(key: string, value: string, expiresAtSec: number): void;
+    deleteCachePrefix(prefix: string): void;
     /**
      * Deletes expired cache entries. Call periodically for cleanup.
      */

package/dist/types/session/file-mention-pruning.d.ts

@@ -0,0 +1,8 @@
+import type { SessionEntry, SessionMessageEntry } from "./session-manager";
+export interface FileMentionPruneResult {
+    changed: SessionMessageEntry[];
+    bytesSaved: number;
+}
+/** Notice injected in place of a superseded file-mention body. */
+export declare function stalefileMentionNotice(path: string): string;
+export declare function pruneStaleFileMentions(entries: readonly SessionEntry[], resolveAbs: (path: string) => string): FileMentionPruneResult;