@sayknow-cli/coding-agent 0.3.12 → 0.3.15

package/dist/types/modes/interactive-mode.d.ts

@@ -21,13 +21,17 @@ import type { EvalExecutionComponent } from "./components/eval-execution";
 import type { HookEditorComponent } from "./components/hook-editor";
 import type { HookInputComponent } from "./components/hook-input";
 import type { HookSelectorComponent } from "./components/hook-selector";
+import { type PetMode, SayknowPetWidget } from "./components/sayknow-pet-widget";
 import { StatusLineComponent } from "./components/status-line";
 import type { ToolExecutionHandle } from "./components/tool-execution";
 import { type WelcomeLogoMode } from "./components/welcome";
+import { IrcObservationLedger } from "./irc-observation-ledger";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import type { Theme } from "./theme/theme";
-import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
+import type { CompactionQueuedMessage, InteractiveModeContext, IrcArrivalSnapshot, SubmittedUserInput, TodoItem, TodoPhase, TranscriptRebuildPolicy } from "./types";
+import type { ParsedIrcMessage } from "./utils/irc-message";
 export declare const DEFAULT_COMPOSER_PLACEHOLDER: string;
+export declare function getWelcomeTranscriptReservedRows(chatContainer: Container, width: number): number;
 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) */
@@ -51,6 +55,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     keybindings: KeybindingsManager;
     agent: Agent;
     historyStorage?: HistoryStorage;
+    readonly ircLedger: IrcObservationLedger;
     ui: TUI;
     chatContainer: Container;
     pendingMessagesContainer: Container;
@@ -61,6 +66,8 @@ export declare class InteractiveMode implements InteractiveModeContext {
     editorContainer: Container;
     hookWidgetContainerAbove: Container;
     hookWidgetContainerBelow: Container;
+    petFloorContainer: Container;
+    petWidget: SayknowPetWidget | undefined;
     statusLine: StatusLineComponent;
     isInitialized: boolean;
     isBackgrounded: boolean;
@@ -132,7 +139,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     updateEditorChrome(): void;
     updateEditorBorderColor(): void;
     updateEditorTopBorder(): void;
-    rebuildChatFromMessages(): void;
+    setPetMode(mode: PetMode): void;
+    previewPetMode(mode: PetMode): void;
+    restoreComposer(): void;
+    rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
     /** Apply any deferred model switch after the current stream ends. */
     flushPendingModelSwitch(): Promise<void>;
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
@@ -166,15 +176,22 @@ export declare class InteractiveMode implements InteractiveModeContext {
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;
     }): Component[];
+    addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[];
+    removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined;
+    resetRenderedIrcInlineComponents(): readonly (readonly Component[])[];
     renderSessionContext(sessionContext: SessionContext, options?: {
         updateFooter?: boolean;
         populateHistory?: boolean;
     }): void;
+    rebuildInitialMessages(policy: TranscriptRebuildPolicy, prebuiltContext?: SessionContext, options?: {
+        preserveExistingChat?: boolean;
+    }): void;
     renderInitialMessages(prebuiltContext?: SessionContext, options?: {
         preserveExistingChat?: boolean;
     }): void;
     getUserMessageText(message: Message): string;
     findLastAssistantMessage(): AssistantMessage | undefined;
+    getAssistantViewportAnchorId(message: AssistantMessage): string;
     extractAssistantText(message: AssistantMessage): string;
     handleExportCommand(text: string): Promise<void>;
     handleDumpCommand(): void;
@@ -213,6 +230,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     openInBrowser(urlOrPath: string): void;
     showSettingsSelector(): void;
     showThemeSelector(): void;
+    showPetSelector(): void;
     showHistorySearch(): void;
     showExtensionsDashboard(): void;
     showAgentsDashboard(): void;
@@ -244,6 +262,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     }): Promise<void>;
     toggleToolOutputExpansion(): void;
     setToolsExpanded(expanded: boolean): void;
+    captureIrcArrivalSnapshot(): IrcArrivalSnapshot;
+    toggleIrcSidebar(): void;
+    applyIrcSidebarAvailability(enabled: boolean): void;
+    resetIrcSidebarSession(): void;
     toggleThinkingBlockVisibility(): void;
     toggleTodoExpansion(): void;
     setTodos(todos: TodoItem[] | TodoPhase[]): void;

package/dist/types/modes/irc-observation-ledger.d.ts

@@ -0,0 +1,22 @@
+import type { ParsedIrcMessage } from "./utils/irc-message";
+type InlineMode = "persistent" | "ephemeral";
+export type IrcObservationRecord = Readonly<ParsedIrcMessage & {
+    mode: InlineMode;
+    observedAt: number;
+    sequence: number;
+    expiresAt?: number;
+    retainedUtf8Bytes: number;
+}>;
+/** Runtime-only IRC observations. This intentionally has no persistence layer. */
+export declare class IrcObservationLedger {
+    #private;
+    /** Inline observations expire after 10 seconds; closed-panel observations persist inline. */
+    observe(message: ParsedIrcMessage, panelVisibleAtObservation: boolean): IrcObservationRecord | undefined;
+    getRecord(observationId: string): IrcObservationRecord | undefined;
+    getSidebarRecords(): readonly IrcObservationRecord[];
+    getInlineProjection(now: number): readonly IrcObservationRecord[];
+    /** Returns and clears IDs whose retained payload was released. */
+    drainEvictedObservationIds(): readonly string[];
+    reset(): void;
+}
+export {};

package/dist/types/modes/print-mode.d.ts

@@ -20,9 +20,8 @@ export interface PrintModeOptions {
     /** Images to attach to the initial message */
     initialImages?: ImageContent[];
     /**
-     * When true, an assistant error/abort does not call process.exit(); print mode
-     * returns instead so the caller (e.g. RLM autonomous mode) can run its own
-     * finalization/cleanup before the process exits.
+     * When true, a terminal assistant error/abort leaves process exit status
+     * untouched so the caller can run its own finalization and status handling.
      */
     suppressProcessExit?: boolean;
 }
@@ -37,7 +36,7 @@ export interface PrintModeOptions {
  * 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;
+export declare const CONTEXT_OVERFLOW_EXIT_CODE = 78;
 /**
  * Run in print (single-shot) mode.
  * Sends prompts to the agent and outputs the result.

package/dist/types/modes/rpc/rpc-client.d.ts

@@ -3,7 +3,7 @@
  *
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
-import type { AgentEvent, AgentMessage, AgentToolResult, ThinkingLevel } from "@sayknow-cli/agent-core";
+import { type AgentEvent, type AgentMessage, type AgentToolResult, type ResolvedThinkingLevel, ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { CompactionResult } from "@sayknow-cli/agent-core/compaction";
 import type { ImageContent, Model } from "@sayknow-cli/ai";
 import type { BashResult } from "../../exec/bash-executor";
@@ -36,6 +36,11 @@ export interface RpcClientOptions {
     customTools?: RpcClientCustomTool[];
 }
 export type ModelInfo = Pick<Model, "provider" | "id" | "contextWindow" | "reasoning" | "thinking">;
+export type RpcDefaultModelSelection = {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly thinkingLevel: ResolvedThinkingLevel;
+};
 export type RpcEventListener = (event: AgentEvent) => void;
 export type RpcSessionEventListener = (event: AgentSessionEvent) => void;
 export interface RpcClientToolContext<TDetails = unknown> {
@@ -149,6 +154,7 @@ export declare class RpcClient {
         provider: string;
         id: string;
     }>;
+    setDefaultModelSelection(provider: string, modelId: string, thinkingLevel: ResolvedThinkingLevel): Promise<RpcDefaultModelSelection>;
     /**
      * Cycle to next model.
      */

package/dist/types/modes/rpc/rpc-mode.d.ts

@@ -18,7 +18,7 @@ export type PendingExtensionRequest = {
     resolve: (response: RpcExtensionUIResponse) => void;
     reject: (error: Error) => void;
 };
-type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => void;
+type RpcOutput = (obj: RpcResponse | RpcExtensionUIRequest | RpcHostToolCallRequest | RpcHostToolCancelRequest | RpcHostUriRequest | RpcHostUriCancelRequest | object) => Promise<void>;
 export declare function shouldEmitRpcTitlesForTest(): boolean;
 /**
  * Cancellation commands bypass the ordered serial chain because they must
@@ -63,6 +63,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;
+    close: () => void;
 };
 export { RpcListenRefusedError } from "./rpc-socket-security";
 /**

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

@@ -4,7 +4,7 @@
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
-import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@sayknow-cli/agent-core";
+import type { AgentMessage, AgentToolResult, ResolvedThinkingLevel, ThinkingLevel } from "@sayknow-cli/agent-core";
 import type { CompactionResult } from "@sayknow-cli/agent-core/compaction";
 import type { Effort, ImageContent, Model } from "@sayknow-cli/ai";
 import type { BashResult } from "../../exec/bash-executor";
@@ -69,6 +69,12 @@ export type RpcCommand = {
     type: "set_model";
     provider: string;
     modelId: string;
+} | {
+    id?: string;
+    type: "set_default_model_selection";
+    provider: string;
+    modelId: string;
+    thinkingLevel?: ResolvedThinkingLevel;
 } | {
     id?: string;
     type: "cycle_model";
@@ -278,6 +284,16 @@ export type RpcResponse = {
     command: "set_model";
     success: true;
     data: Model;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_default_model_selection";
+    success: true;
+    data: {
+        provider: string;
+        modelId: string;
+        thinkingLevel: ResolvedThinkingLevel;
+    };
 } | {
     id?: string;
     type: "response";

package/dist/types/modes/shared/agent-wire/deep-interview-gate.d.ts

@@ -42,6 +42,8 @@ export interface AskGateQuestion {
     deepInterview?: AskGateDeepInterviewState;
     /** Override the emitted workflow gate address for non-deep-interview ask prompts. */
     workflowGate?: AskGateWorkflowGateMeta;
+    allowEmpty?: boolean;
+    navigationLabel?: "Next" | "Done";
 }
 export interface AskGateResult {
     id: string;
@@ -90,5 +92,11 @@ export declare function questionToGate(question: AskGateQuestion): OpenGateInput
  * semantically invalid answer.
  */
 export declare function gateAnswerToResult(question: AskGateQuestion, answer: unknown): AskGateResult;
+/**
+ * Classify an accepted ask-domain gate answer independently of its transport.
+ * Schema-invalid and semantically invalid answers throw, so callers leave the
+ * durable gate pending rather than treating them as a non-committing answer.
+ */
+export declare function classifyAskGateDisposition(gate: Pick<OpenGateInput, "context" | "options">, answer: unknown): "commit" | "resolve_without_commit";
 /** Convenience: map a batch of ask questions to gate open-inputs. */
 export declare function questionsToGates(questions: AskGateQuestion[]): OpenGateInput[];

package/dist/types/modes/shared/agent-wire/unattended-run-controller.d.ts

@@ -156,6 +156,11 @@ export declare class UnattendedRunController {
     /** Returns the in-flight/settled abort completion once aborting has begun. */
     get abortCompletion(): Promise<void> | undefined;
     private fireAbort;
+    /**
+     * Invoke every configured abort hook exactly once with per-hook isolation, so a
+     * failing hook never prevents the other cancellation surfaces from running.
+     * Returns the number of hooks that rejected.
+     */
     private runAbortHooks;
 }
 export {};

package/dist/types/modes/shared/agent-wire/unattended-session.d.ts

@@ -15,10 +15,45 @@
  * RPC server can route `negotiate_unattended` + `workflow_gate_response` here.
  */
 import type { Model } from "@sayknow-cli/ai";
+import type { AskSelectedAckOutcome } from "../../../tools";
 import type { RpcCommand, RpcUnattendedAccepted, RpcUnattendedDeclaration, RpcWorkflowGate, RpcWorkflowGateResolution, RpcWorkflowGateResponse } from "../../rpc/rpc-types";
 import type { RpcUnattendedControlPlane } from "./command-dispatch";
 import { type UnattendedAbortHooks, type UnattendedAuditEvent, UnattendedRunController } from "./unattended-run-controller";
 import { type GateStore, type OpenGateInput } from "./workflow-gate-broker";
+export interface WorkflowGateTerminalController {
+    completeGateInteractions(gateId: string): void | Promise<void>;
+    cancelGateInteractions(gateId: string, reason: string): void | Promise<void>;
+}
+export interface WorkflowGateTerminalEvent {
+    gateId: string;
+    kind: "accepted" | "cancelled";
+    origin?: "rpc" | "bridge" | "other" | "telegram_notification";
+    reason?: string;
+}
+export interface NotificationGateResolutionOptions {
+    interactionActionId: string;
+    replyReceiptId: string;
+    answerJson: string;
+    idempotencyKey?: string;
+    requestSelectedAck(input: {
+        replyReceiptId: string;
+        actionId: string;
+        commitKey: string;
+        daemonDeadlineAt: number;
+        hostTimeoutMs: number;
+    }): Promise<AskSelectedAckOutcome>;
+    resolveClaim(): void;
+    closeClaimInvalid(reason: string): void;
+}
+export interface AskSelectedAckRecoveryParticipant {
+    requestRecoveredAskSelectedAck(input: {
+        sessionId: string;
+        actionId: string;
+        commitKey: string;
+        deadlineAt: number;
+        hostTimeoutMs: number;
+    }): Promise<AskSelectedAckOutcome>;
+}
 /**
  * Derive an explicit `providerSupportsTokenCostMetrics` capability from the
  * active model so unattended negotiation fails closed when token/cost usage
@@ -41,7 +76,10 @@ export interface WorkflowGateEmitter {
      */
     onGateEmitted?(listener: (gate: RpcWorkflowGate) => void): () => void;
     resolveGate?(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    resolveGateFromNotification?(response: RpcWorkflowGateResponse, options: NotificationGateResolutionOptions): Promise<RpcWorkflowGateResolution>;
+    registerGateTerminalController?(controller: WorkflowGateTerminalController): () => void;
     listPendingGates?(): RpcWorkflowGate[];
+    setAckRecoveryParticipant?(participant: AskSelectedAckRecoveryParticipant | null): void;
 }
 export interface UnattendedSessionOptions {
     runId: string;
@@ -72,10 +110,17 @@ export declare class UnattendedSessionControlPlane implements RpcUnattendedContr
     /** Observe every emitted gate (e.g. so an extension can map an ask to its gate_id). */
     onGateEmitted(listener: (gate: RpcWorkflowGate) => void): () => void;
     get controller(): UnattendedRunController | undefined;
+    registerGateTerminalController(controller: WorkflowGateTerminalController): () => void;
+    setAckRecoveryParticipant(participant: AskSelectedAckRecoveryParticipant | null): void;
     negotiate(declaration: RpcUnattendedDeclaration): RpcUnattendedAccepted;
     preflightCommand(command: RpcCommand): void;
     reconcileUsage(phase?: string): void;
     resolveGate(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    resolveGateFromNotification(response: RpcWorkflowGateResponse, options: NotificationGateResolutionOptions): Promise<RpcWorkflowGateResolution>;
+    startRecoveryOnce(options?: {
+        participantGraceMs?: number;
+    }): Promise<void>;
+    dispose(reason?: string): void;
     listPendingGates(): import("../../rpc/rpc-types").RpcWorkflowGate[];
     emitGate(input: OpenGateInput): Promise<unknown>;
     recover(): Promise<void>;

package/dist/types/modes/shared/agent-wire/workflow-gate-broker.d.ts

@@ -1,4 +1,32 @@
-import type { RpcWorkflowGate, RpcWorkflowGateContext, RpcWorkflowGateKind, RpcWorkflowGateOption, RpcWorkflowGateResolution, RpcWorkflowGateResponse, RpcWorkflowStage } from "../../rpc/rpc-types";
+import type { AskSelectedAckOutcome } from "../../../tools";
+import type { RpcWorkflowGate, RpcWorkflowGateContext, RpcWorkflowGateKind, RpcWorkflowGateOption, RpcWorkflowGateResolution, RpcWorkflowGateResponse, RpcWorkflowGateValidationError, RpcWorkflowStage } from "../../rpc/rpc-types";
+export type PersistedSemanticDisposition = "commit" | "resolve_without_commit";
+export type PersistedResolutionOrigin = {
+    kind: "generic";
+    channel: "rpc" | "bridge" | "other";
+} | {
+    kind: "telegram_notification";
+    interactionActionId: string;
+} | {
+    kind: "legacy_unknown";
+};
+export type PersistedAckPolicy = {
+    kind: "none";
+    reason: "non_telegram" | "semantic_noncommit" | "legacy_unproven";
+} | {
+    kind: "telegram_selected_v1";
+    commitKey: string;
+    actionId: string;
+    state: "pending" | "attempt_started" | "delivered" | "failed" | "unknown";
+    outcome?: AskSelectedAckOutcome;
+    updatedAt: string;
+};
+export interface GateResolutionOptions {
+    semanticDisposition?: PersistedSemanticDisposition;
+    resolutionOrigin?: PersistedResolutionOrigin;
+    ackPolicy?: PersistedAckPolicy;
+    beforeAdvance?: () => Promise<void>;
+}
 export interface PersistedGate {
     gate: RpcWorkflowGate;
     status: "pending" | "accepted";
@@ -8,6 +36,9 @@ export interface PersistedGate {
     answer?: unknown;
     resolution?: RpcWorkflowGateResolution;
     advanced: boolean;
+    semanticDisposition?: PersistedSemanticDisposition;
+    resolutionOrigin?: PersistedResolutionOrigin;
+    ackPolicy?: PersistedAckPolicy;
 }
 export interface GateStore {
     nextSeq(stage: RpcWorkflowStage): number;
@@ -74,6 +105,8 @@ export interface BrokerHooks {
      * it for any gate left `accepted` but not `advanced` by a crash.
      */
     advance?(gate: RpcWorkflowGate, answer: unknown): void | Promise<void>;
+    /** Runs after durable acceptance and before advance, including crash recovery. */
+    finalizeAccepted?(record: PersistedGate): Promise<void>;
     /** Append-only audit sink. */
     audit?(event: GateAuditEvent): void;
 }
@@ -92,7 +125,13 @@ export declare class WorkflowGateBroker {
     private readonly runId;
     private readonly store;
     private readonly hooks;
+    private readonly recovering;
+    private readonly gateLocks;
+    private withGateLock;
     constructor(runId: string, store: GateStore, hooks?: BrokerHooks);
+    classifyDisposition(gateId: string, answer: unknown): PersistedSemanticDisposition;
+    validationError(gateId: string, keyword: string, message: string): RpcWorkflowGateValidationError;
+    updateAckPolicy(gateId: string, ackPolicy: PersistedAckPolicy): void;
     private runShort;
     /** Open and emit a gate. The pending record is persisted BEFORE emission. */
     openGate(input: OpenGateInput): RpcWorkflowGate;
@@ -101,7 +140,8 @@ export declare class WorkflowGateBroker {
      * On success the resolution is persisted BEFORE `advance` is invoked exactly
      * once. Invalid answers leave the gate pending (per #315 acceptance).
      */
-    resolve(response: RpcWorkflowGateResponse): Promise<RpcWorkflowGateResolution>;
+    resolve(response: RpcWorkflowGateResponse, options?: GateResolutionOptions): Promise<RpcWorkflowGateResolution>;
+    private resolveUnlocked;
     /**
      * Recover any gate left `accepted` but not `advanced` by a crash between the
      * durable accept and the advanced commit. Replays `advance` (which must be