@sayknow-cli/coding-agent 0.3.7 → 0.3.8

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/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/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) */
@@ -189,6 +190,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>;

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

@@ -198,6 +198,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>;

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.d.ts

@@ -17,12 +17,24 @@ export interface NotificationConfig {
 }
 /** 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;
 /** 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 +73,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;

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";
@@ -69,7 +70,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 +174,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

@@ -23,8 +23,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 +38,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/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;
@@ -252,6 +254,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;
@@ -276,6 +280,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 +323,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 +351,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;
@@ -363,6 +377,12 @@ export declare class TelegramNotificationDaemon {
     private cleanupAllAttachmentDirs;
     private resolveInboundAttachment;
     private flushPool;
+    /**
+     * 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 +396,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

@@ -81,14 +81,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,12 @@ 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;
 }
 interface ThreadedFrame {
     type?: 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;