@sayknow-cli/coding-agent 0.3.7 → 0.3.9

package/dist/types/export/ttsr.d.ts

@@ -11,9 +11,16 @@ export interface TtsrMatchContext {
     /** Stable key to isolate buffering (for example a tool call ID). */
     streamKey?: string;
 }
+/** Tracks when a rule was last injected (for repeat gating). */
+export interface TtsrInjectionRecord {
+    name: string;
+    lastInjectedAt: number;
+    repeatMode?: "once" | "after-gap";
+    repeatGap?: number;
+}
 export declare class TtsrManager {
     #private;
-    constructor(settings?: TtsrSettings);
+    constructor(settings?: Partial<TtsrSettings>);
     /** Add a TTSR rule to be monitored. */
     addRule(rule: Rule): boolean;
     /**
@@ -29,8 +36,10 @@ export declare class TtsrManager {
     markInjectedByNames(ruleNames: string[]): void;
     /** Get names of all injected rules (for persistence). */
     getInjectedRuleNames(): string[];
-    /** Restore injected state from a list of rule names. */
-    restoreInjected(ruleNames: string[]): void;
+    /** Get full injected rule records (for persistence). */
+    getInjectedRecords(): TtsrInjectionRecord[];
+    /** Restore injected state from legacy rule names or persisted records. */
+    restoreInjected(records: string[] | TtsrInjectionRecord[]): void;
     /** Reset stream buffers (called on new turn). */
     resetBuffer(): void;
     /** Check if any TTSR rules are registered. */
@@ -39,6 +48,8 @@ export declare class TtsrManager {
     incrementMessageCount(): void;
     /** Get current message count. */
     getMessageCount(): number;
+    /** Restore message counter after session resume. */
+    restoreMessageCount(messageCount: number): void;
     /** Get settings. */
     getSettings(): Required<TtsrSettings>;
 }

package/dist/types/extensibility/extensions/runner.d.ts

@@ -61,7 +61,8 @@ export declare class ExtensionRunner {
     private readonly cwd;
     private readonly sessionManager;
     private readonly modelRegistry;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry);
+    private readonly sessionMetadata?;
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, sessionMetadata?: ExtensionContext["sessionMetadata"]);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.

package/dist/types/extensibility/extensions/types.d.ts

@@ -186,6 +186,12 @@ export interface CompactOptions {
     onComplete?: (result: CompactionResult) => void;
     onError?: (error: Error) => void;
 }
+export interface ExtensionSessionMetadata {
+    kind: "main" | "sub";
+    taskDepth: number;
+    parentTaskPrefix?: string;
+    currentAgentType?: string;
+}
 /**
  * Context passed to extension event handlers.
  */
@@ -202,6 +208,8 @@ export interface ExtensionContext {
     cwd: string;
     /** Session manager (read-only) */
     sessionManager: ReadonlySessionManager;
+    /** Session classification supplied by the SDK for extension policy decisions. */
+    sessionMetadata?: ExtensionSessionMetadata;
     /** Model registry for API key resolution */
     modelRegistry: ModelRegistry;
     /** Current model (may be undefined) */

package/dist/types/goals/runtime.d.ts

@@ -35,6 +35,7 @@ export declare class GoalRuntime {
     #private;
     constructor(host: GoalRuntimeHost);
     get snapshot(): GoalRuntimeSnapshot;
+    shouldTrackTurnBaseline(): boolean;
     onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void;
     onToolCompleted(toolName: string): Promise<void>;
     onGoalToolCompleted(): Promise<void>;

package/dist/types/hooks/native-skill-hook.d.ts

@@ -11,6 +11,18 @@ interface SkcNativeHookDispatchOptions {
     effectiveSkillConfig?: EffectiveSkillConfigInput;
     configPaths?: string[];
 }
+export declare function clearSkcNativeSkillHookCachesForTesting(): void;
+export declare function getSkcNativeSkillHookCacheStatsForTesting(): {
+    effectiveSkillConfigResolutions: number;
+};
+export declare function resolveSkcNativeSkillConfigForTesting(input: {
+    cwd: string;
+    configPaths?: string[];
+    sessionId?: string;
+    threadId?: string;
+    stateDir?: string;
+}): Promise<EffectiveSkillConfigInput>;
 export declare function dispatchSkcNativeSkillHook(payload: HookPayload, options?: SkcNativeHookDispatchOptions): Promise<SkcNativeHookDispatchResult>;
+export declare function runSkcNativeSkillHookInProcess(payload: HookPayload): Promise<string>;
 export declare function runSkcNativeSkillHookCli(): Promise<void>;
 export {};

package/dist/types/main.d.ts

@@ -18,6 +18,9 @@ export interface InteractiveModeNotify {
     message: string;
 }
 export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+type CreateSessionForMain = (options: CreateAgentSessionOptions, context?: {
+    skipPostCreateModelRefresh?: boolean;
+}) => Promise<CreateAgentSessionResult>;
 type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 export interface AcpSessionFactoryOptions {
     baseOptions: CreateAgentSessionOptions;
@@ -27,7 +30,7 @@ export interface AcpSessionFactoryOptions {
     modelRegistry: ModelRegistry;
     parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
     rawArgs: string[];
-    createSession: (options: CreateAgentSessionOptions) => Promise<CreateAgentSessionResult>;
+    createSession: CreateSessionForMain;
 }
 export declare function applyStartupModelProfiles(args: {
     session: AgentSession;

package/dist/types/modes/components/assistant-message.d.ts

@@ -1,5 +1,8 @@
 import type { AssistantMessage, ImageContent, Usage } from "@sayknow-cli/ai";
 import { Container } from "@sayknow-cli/tui";
+interface AssistantMessageUpdateOptions {
+    streaming?: boolean;
+}
 /**
  * Component that renders a complete assistant message
  */
@@ -12,5 +15,6 @@ export declare class AssistantMessageComponent extends Container {
     setHideThinkingBlock(hide: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     setUsageInfo(usage: Usage): void;
-    updateContent(message: AssistantMessage): void;
+    updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void;
 }
+export {};

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

@@ -10,6 +10,7 @@ export type ModelSelectorSelection = {
     kind: "assignment";
     model: Model;
     role: SkcModelAssignmentTargetId | null;
+    roles?: readonly SkcModelAssignmentTargetId[];
     thinkingLevel?: ThinkingLevel;
     selector?: string;
 } | {
@@ -52,5 +53,8 @@ export declare class ModelSelectorComponent extends Container {
     handleInput(keyData: string): void;
     getSearchInput(): Input;
     __testSelectProfile(profileName: string, setDefault: boolean): Promise<void>;
+    __testSelectAssignment(selection: Omit<Extract<ModelSelectorSelection, {
+        kind: "assignment";
+    }>, "kind">): Promise<void>;
 }
 export {};

package/dist/types/modes/components/queued-message-selector.d.ts

@@ -0,0 +1,12 @@
+import { Container, SelectList } from "@sayknow-cli/tui";
+import type { QueuedMessageEditEntry } from "../../session/agent-session";
+type QueuedMessageMoveDirection = "up" | "down";
+export type { QueuedMessageMoveDirection };
+export declare class QueuedMessageSelectorComponent extends Container {
+    #private;
+    constructor(entries: QueuedMessageEditEntry[], onSelect: (entry: QueuedMessageEditEntry) => void, onDelete: (entry: QueuedMessageEditEntry, selectedIndex: number) => void, onMove: (entry: QueuedMessageEditEntry, selectedIndex: number, direction: QueuedMessageMoveDirection) => void, onCancel: () => void, options?: {
+        selectedIndex?: number;
+    });
+    handleInput(keyData: string): void;
+    getSelectList(): SelectList;
+}

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

@@ -16,6 +16,8 @@ export interface SettingsRuntimeContext {
     thinkingLevel: ThinkingLevel | undefined;
     /** Available themes */
     availableThemes: string[];
+    /** Available model profile names (from the model registry) */
+    availableModelProfiles: string[];
     /** Working directory for plugins tab */
     cwd: string;
 }

package/dist/types/modes/components/status-line.d.ts

@@ -90,5 +90,14 @@ export declare class StatusLineComponent implements Component {
      * everything fits on one row.
      */
     getPreviewContent(width: number): string;
+    getCacheStatsForTest(): {
+        rowHits: number;
+        rowMisses: number;
+    };
+    invalidateBranchForTest(): void;
+    setCachedPrForTest(pr: {
+        number: number;
+        url: string;
+    } | null): void;
     render(width: number): string[];
 }

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

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

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

@@ -23,6 +23,7 @@ export declare class CommandController {
     handleContextCommand(): void;
     handleMemoryCommand(text: string): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;

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

@@ -1,5 +1,10 @@
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __eventControllerPerfCounters: {
+    messageUpdateContentVisits: number;
+    reset(): void;
+};
 export declare class EventController {
     #private;
     private ctx;

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

@@ -14,9 +14,7 @@ export declare class InputController {
     handleFollowUp(): Promise<void>;
     /** Send editor text explicitly as a queued next-turn message. */
     handleQueueSubmit(): Promise<void>;
-    restoreLatestQueuedMessageToEditor(options?: {
-        currentText?: string;
-    }): number;
+    restoreLatestQueuedMessageToEditor(): number;
     restoreQueuedMessagesToEditor(options?: {
         abort?: boolean;
         currentText?: string;

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

@@ -27,6 +27,7 @@ import { type WelcomeLogoMode } from "./components/welcome";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
 import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
 export type WelcomeBannerSettingMode = "auto" | "unicode" | "square" | "ascii";
 export declare function resolveWelcomeLogoMode(mode: WelcomeBannerSettingMode, env?: Record<string, string | undefined>, platform?: NodeJS.Platform): WelcomeLogoMode;
 /** Options for creating an InteractiveMode instance (for future API use) */
@@ -95,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;
@@ -189,6 +191,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleToolsCommand(): void;
     handleContextCommand(): void;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleMoveCommand(targetPath: string): Promise<void>;
@@ -216,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/print-mode.d.ts

@@ -5,7 +5,7 @@
  * - `skc -p "prompt"` - text output
  * - `skc --mode json "prompt"` - JSON event stream
  */
-import type { ImageContent } from "@sayknow-cli/ai";
+import { type ImageContent } from "@sayknow-cli/ai";
 import type { AgentSession } from "../session/agent-session";
 /**
  * Options for print mode.
@@ -26,6 +26,18 @@ export interface PrintModeOptions {
      */
     suppressProcessExit?: boolean;
 }
+/**
+ * Exit code used when a non-interactive **text-mode** run (`skc -p`) terminates
+ * because the model context window is exhausted and automatic compaction could
+ * not bring the request under the limit. Distinct from the generic failure code
+ * (1) so text-mode callers can detect context exhaustion specifically instead of
+ * parsing the raw provider error string.
+ *
+ * Scope: text-mode final-response path only. JSON mode (`--mode json`) streams
+ * events from the subscription and does not run this terminal-error branch, so
+ * it is intentionally NOT covered by this exit code.
+ */
+export declare const CONTEXT_OVERFLOW_EXIT_CODE = 2;
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.

package/dist/types/modes/prompt-action-autocomplete.d.ts

@@ -1,4 +1,4 @@
-import type { AutocompleteItem, AutocompleteProvider, SlashCommand } from "@sayknow-cli/tui";
+import { type AutocompleteItem, type AutocompleteProvider, type SlashCommand } from "@sayknow-cli/tui";
 import type { KeybindingsManager } from "../config/keybindings";
 interface PromptActionDefinition {
     id: string;

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/rpc/rpc-types.d.ts

@@ -12,6 +12,7 @@ import type { ContextUsage } from "../../extensibility/extensions/types";
 import type { SessionStats } from "../../session/agent-session";
 import type { TodoPhase } from "../../tools/todo-write";
 export type RpcGetStateInclude = "tools" | "dumpTools" | "systemPrompt";
+export type RpcCapability = "compact_message_update";
 export type RpcCommand = {
     id?: string;
     type: "prompt";
@@ -59,6 +60,10 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_pending_workflow_gates";
+} | {
+    id?: string;
+    type: "set_capabilities";
+    capabilities: RpcCapability[];
 } | {
     id?: string;
     type: "set_model";
@@ -258,6 +263,15 @@ export type RpcResponse = {
     data: {
         gates: RpcWorkflowGate[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_capabilities";
+    success: true;
+    data: {
+        acceptedCapabilities: RpcCapability[];
+        unsupported: string[];
+    };
 } | {
     id?: string;
     type: "response";

package/dist/types/modes/shared/agent-wire/event-contract.d.ts

@@ -13,6 +13,7 @@
  * an `AgentSessionEvent` variant fails typecheck until it is registered, and so
  * conformance tests can assert fixture coverage equals the registry exactly.
  */
+import type { AssistantMessageEvent } from "@sayknow-cli/ai";
 import type { AgentSessionEvent } from "../../../session/agent-session";
 /** Wire protocol version. Bump on breaking envelope/semantic changes. */
 export declare const AGENT_WIRE_PROTOCOL_VERSION: 2;
@@ -29,6 +30,23 @@ export interface AgentWireEventPayload {
     event_type: AgentWireEventType;
     event: AgentSessionEvent;
 }
+export type AgentWireCompactAssistantMessageEvent = AssistantMessageEvent extends infer TEvent ? TEvent extends {
+    type: string;
+} ? Omit<TEvent, "partial" | "message" | "error"> : never : never;
+export interface AgentWireCompactMessageUpdatePayload {
+    event_type: "message_update";
+    /** Compact RPC opt-in payload: delta-only update plus minimal routing metadata. */
+    compact: true;
+    message_id: string | null;
+    content_index: number | null;
+    assistantMessageEvent: AgentWireCompactAssistantMessageEvent;
+    /** Full message checkpoint, snapshotted synchronously when this frame is enqueued. */
+    checkpoint_message?: Extract<AgentSessionEvent, {
+        type: "message_update";
+    }>["message"];
+    checkpoint_reason?: "periodic";
+}
+export type AgentWireEventFramePayload = AgentWireEventPayload | AgentWireCompactMessageUpdatePayload;
 /**
  * Bounded observed-signal vocabulary surfaced to owner control planes. Mirrors
  * the Harness `ObservedSignal` set; the Harness type aliases this in a later
@@ -82,3 +100,4 @@ export interface AgentWireFrameEnvelope<TType extends AgentWireFrameType = Agent
 }
 /** An `AgentSessionEvent` serialized into a versioned wire frame. */
 export type AgentWireEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventPayload>;
+export type AgentWireCompactEventFrame = AgentWireFrameEnvelope<"event", AgentWireEventFramePayload>;

package/dist/types/modes/shared/agent-wire/event-envelope.d.ts

@@ -1,5 +1,6 @@
 import type { AgentSessionEvent } from "../../../session/agent-session";
-import { type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
+import { type AgentWireCompactAssistantMessageEvent, type AgentWireCompactEventFrame, type AgentWireEventFrame, type AgentWireEventPayload, type AgentWireEventType, type AgentWireFrameEnvelope, type AgentWireFrameType } from "./event-contract";
+export declare const AGENT_WIRE_COMPACT_MESSAGE_UPDATE_CHECKPOINT_INTERVAL = 32;
 /**
  * Resolve the stable wire event-type for an `AgentSessionEvent`.
  *
@@ -27,6 +28,27 @@ export type BridgeFrameSequencer = AgentWireFrameSequencer;
 export declare function toAgentWireEventFrame(event: AgentSessionEvent, sequencer: AgentWireFrameSequencer): AgentWireEventFrame;
 /** Build the rich event payload (renderer-facing) for an `AgentSessionEvent`. */
 export declare function toAgentWireEventPayload(event: AgentSessionEvent): AgentWireEventPayload;
+export declare function sanitizeAssistantMessageEventForCompact(assistantMessageEvent: Extract<AgentSessionEvent, {
+    type: "message_update";
+}>["assistantMessageEvent"]): AgentWireCompactAssistantMessageEvent;
+export interface AgentWireCompactMessageUpdateOptions {
+    checkpointInterval?: number;
+}
+/**
+ * Stateful compact event serializer for opt-in RPC clients.
+ *
+ * Only `message_update` changes shape: it carries the immutable provider delta
+ * plus message/content identifiers, with periodic full-message checkpoints that
+ * are cloned synchronously before the caller returns to the event loop. All other
+ * event variants remain canonical full event frames so legacy bridge/RPC behavior
+ * and terminal `message_end` reconstruction are unchanged.
+ */
+export declare class AgentWireCompactEventEncoder {
+    #private;
+    constructor(sequencer: AgentWireFrameSequencer, options?: AgentWireCompactMessageUpdateOptions);
+    frame(event: AgentSessionEvent): AgentWireCompactEventFrame;
+}
+export declare function toAgentWireCompactEventFrame(event: AgentSessionEvent, encoder: AgentWireCompactEventEncoder): AgentWireCompactEventFrame;
 /** Back-compat alias for {@link toAgentWireEventFrame}. */
 export declare const toBridgeEventFrame: typeof toAgentWireEventFrame;
 /**

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

@@ -100,6 +100,7 @@ export interface InteractiveModeContext {
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
     locallySubmittedUserSignatures: Set<string>;
+    optimisticInjectedSignatures: Map<string, number>;
     lastSigintTime: number;
     lastEscapeTime: number;
     lastComposerClearEscapeTime: number;
@@ -198,6 +199,7 @@ export interface InteractiveModeContext {
     handleDumpCommand(): void;
     handleDebugTranscriptCommand(): Promise<void>;
     handleClearCommand(): Promise<void>;
+    handleContextClearCommand(): Promise<void>;
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
@@ -222,6 +224,7 @@ export interface InteractiveModeContext {
     showModelSelector(options?: {
         temporaryOnly?: boolean;
     }): void;
+    showEffortSelector(): void;
     showProviderOnboarding(): void;
     showPluginSelector(mode?: "install" | "uninstall"): void;
     showUserMessageSelector(): void;

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

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

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -6,6 +6,7 @@ import type { SessionContext } from "../../session/session-manager";
 interface RenderInitialMessagesOptions {
     preserveExistingChat?: boolean;
 }
+export declare function argsWithPartialJson(args: unknown, partialJson: unknown): unknown;
 export declare class UiHelpers {
     #private;
     private ctx;

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

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

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

@@ -14,15 +14,43 @@ 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;
+export declare function hasNonBlankValue(value: string | undefined): boolean;
+/** Is Telegram configured with usable non-blank boundary credentials? */
+export declare function isTelegramConfigured(cfg: NotificationConfig): cfg is NotificationConfig & {
+    botToken: string;
+    chatId: string;
+};
 /** 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;
     cfg?: NotificationConfig;
+    /** Task recursion depth; helper/subagent sessions must not spawn remote surfaces. */
+    taskDepth?: number;
+    /** Parent subagent id/prefix; present for helper/subagent sessions even when depth is omitted. */
+    parentTaskPrefix?: string;
+    /** Role-agent type/name; present for task sessions even if depth metadata is lost. */
+    currentAgentType?: string;
 }): boolean;
 /**
  * Resolve whether THIS session should run notifications.
@@ -61,7 +89,8 @@ export interface RedactableAction {
  * When redact is false, return the action unchanged.
  *
  * Redaction still applies to streamed content frames (turn_stream, context_update,
- * image_attachment) which are suppressed at their emit sites, not here.
+ * image_attachment) which are suppressed at their emit sites, not here. Explicit
+ * `telegram_send` file attachments are rejected before the file is read or forwarded.
  */
 export declare function buildRedactedAction(action: RedactableAction, opts: {
     redact: boolean;

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

@@ -5,5 +5,6 @@ export interface DaemonPaths {
     roots: string;
     steal: string;
     aliases: string;
+    seenUpdates: string;
 }
 export declare function daemonPaths(agentDir: string): DaemonPaths;