@sayknow-cli/coding-agent 0.4.2 → 0.4.3

package/dist/types/lsp/lspmux.d.ts

@@ -0,0 +1,60 @@
+/**
+ * lspmux integration for LSP server multiplexing.
+ *
+ * When lspmux is available and running, this module wraps supported LSP server
+ * commands to use lspmux client mode, enabling server instance sharing across
+ * multiple editor windows.
+ *
+ * Integration is transparent: if lspmux is unavailable, falls back to direct spawning.
+ */
+interface LspmuxConfig {
+    instance_timeout?: number;
+    gc_interval?: number;
+    listen?: [string, number] | string;
+    connect?: [string, number] | string;
+    log_filters?: string;
+    pass_environment?: string[];
+}
+interface LspmuxState {
+    available: boolean;
+    running: boolean;
+    binaryPath: string | null;
+    config: LspmuxConfig | null;
+}
+/**
+ * Detect lspmux availability and state.
+ * Results are cached for STATE_CACHE_TTL_MS.
+ *
+ * Set SKC_DISABLE_LSPMUX=1 or PI_DISABLE_LSPMUX=1 to disable.
+ */
+export declare function detectLspmux(cwd?: string): Promise<LspmuxState>;
+/** Reset cached lspmux detection state for focused tests. */
+export declare function resetLspmuxStateForTesting(): void;
+/**
+ * Check if a server command is supported by lspmux.
+ */
+export declare function isLspmuxSupported(command: string): boolean;
+export interface LspmuxWrappedCommand {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+/**
+ * Wrap a server command to use lspmux client mode.
+ *
+ * @param originalCommand - The original LSP server command (e.g., "rust-analyzer")
+ * @param originalArgs - Original command arguments
+ * @param state - lspmux state from detectLspmux()
+ * @returns Wrapped command, args, and env vars; or original if lspmux unavailable
+ */
+export declare function wrapWithLspmux(originalCommand: string, originalArgs: string[] | undefined, state: LspmuxState): LspmuxWrappedCommand;
+/**
+ * Get lspmux-wrapped command if available, otherwise return original.
+ * This is the main entry point for config.ts integration.
+ *
+ * @param command - Original LSP server command
+ * @param args - Original command arguments
+ * @returns Command and args to use (possibly wrapped with lspmux)
+ */
+export declare function getLspmuxCommand(command: string, args?: string[], cwd?: string): Promise<LspmuxWrappedCommand>;
+export {};

package/dist/types/lsp/path-trust.d.ts

@@ -0,0 +1 @@
+export declare function isProjectControlledPath(candidate: string, cwd: string): boolean;

package/dist/types/lsp/render.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LSP Tool TUI Rendering
+ *
+ * Renders LSP tool calls and results in the TUI with:
+ * - Syntax-highlighted hover information
+ * - Color-coded diagnostics by severity
+ * - Grouped references and symbols
+ * - Collapsible/expandable views
+ */
+import type { RenderResultOptions } from "@sayknow-cli/agent-core";
+import { type Component, Text } from "@sayknow-cli/tui";
+import { type Theme } from "../modes/theme/theme";
+import type { LspParams, LspToolDetails } from "./types";
+export declare function renderCall(args: LspParams, _options: RenderResultOptions, theme: Theme): Text;
+/**
+ * Render LSP tool result with intelligent formatting based on result type.
+ * Detects hover, diagnostics, references, symbols, etc. and formats accordingly.
+ */
+export declare function renderResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: LspToolDetails;
+    isError?: boolean;
+}, options: RenderResultOptions, theme: Theme, args?: LspParams): Component;
+export declare const lspToolRenderer: {
+    renderCall: typeof renderCall;
+    renderResult: typeof renderResult;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};

package/dist/types/lsp/startup-events.d.ts

@@ -0,0 +1,12 @@
+import type { LspStartupServerInfo } from "./index";
+export declare const LSP_STARTUP_EVENT_CHANNEL = "lsp:startup";
+export type LspStartupEvent = {
+    type: "completed";
+    servers: Array<LspStartupServerInfo & {
+        status: "ready" | "error";
+    }>;
+} | {
+    type: "failed";
+    error: string;
+};
+export declare function getLspStartupWarningMessage(event: LspStartupEvent): string | null;

package/dist/types/lsp/types.d.ts

@@ -0,0 +1,306 @@
+import type { ptree } from "@sayknow-cli/utils";
+import * as z from "zod/v4";
+import type { OwnedProcess } from "../runtime/process-lifecycle";
+export declare const lspSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        status: "status";
+        diagnostics: "diagnostics";
+        definition: "definition";
+        references: "references";
+        hover: "hover";
+        symbols: "symbols";
+        rename: "rename";
+        rename_file: "rename_file";
+        code_actions: "code_actions";
+        type_definition: "type_definition";
+        implementation: "implementation";
+        reload: "reload";
+        capabilities: "capabilities";
+        request: "request";
+    }>;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    symbol: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    new_name: z.ZodOptional<z.ZodString>;
+    apply: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LspParams = z.infer<typeof lspSchema>;
+export interface LspToolDetails {
+    serverName?: string;
+    action: string;
+    success: boolean;
+    request?: LspParams;
+}
+export interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface Location {
+    uri: string;
+    range: Range;
+}
+export interface LocationLink {
+    originSelectionRange?: Range;
+    targetUri: string;
+    targetRange: Range;
+    targetSelectionRange: Range;
+}
+export type DiagnosticSeverity = 1 | 2 | 3 | 4;
+export interface DiagnosticRelatedInformation {
+    location: Location;
+    message: string;
+}
+export interface Diagnostic {
+    range: Range;
+    severity?: DiagnosticSeverity;
+    code?: string | number;
+    codeDescription?: {
+        href: string;
+    };
+    source?: string;
+    message: string;
+    tags?: number[];
+    relatedInformation?: DiagnosticRelatedInformation[];
+    data?: unknown;
+}
+export interface PublishedDiagnostics {
+    diagnostics: Diagnostic[];
+    version: number | null;
+}
+export interface PublishDiagnosticsParams {
+    uri: string;
+    diagnostics: Diagnostic[];
+    version?: number | null;
+}
+export interface TextEdit {
+    range: Range;
+    newText: string;
+}
+export interface AnnotatedTextEdit extends TextEdit {
+    annotationId?: string;
+}
+export interface TextDocumentIdentifier {
+    uri: string;
+}
+export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+    version: number | null;
+}
+export interface OptionalVersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+    version?: number | null;
+}
+export interface TextDocumentEdit {
+    textDocument: OptionalVersionedTextDocumentIdentifier;
+    edits: (TextEdit | AnnotatedTextEdit)[];
+}
+export interface CreateFileOptions {
+    overwrite?: boolean;
+    ignoreIfExists?: boolean;
+}
+export interface CreateFile {
+    kind: "create";
+    uri: string;
+    options?: CreateFileOptions;
+}
+export interface RenameFileOptions {
+    overwrite?: boolean;
+    ignoreIfExists?: boolean;
+}
+export interface RenameFile {
+    kind: "rename";
+    oldUri: string;
+    newUri: string;
+    options?: RenameFileOptions;
+}
+export interface DeleteFileOptions {
+    recursive?: boolean;
+    ignoreIfNotExists?: boolean;
+}
+export interface DeleteFile {
+    kind: "delete";
+    uri: string;
+    options?: DeleteFileOptions;
+}
+export type DocumentChange = TextDocumentEdit | CreateFile | RenameFile | DeleteFile;
+export interface WorkspaceEdit {
+    changes?: Record<string, TextEdit[]>;
+    documentChanges?: DocumentChange[];
+    changeAnnotations?: Record<string, {
+        label: string;
+        needsConfirmation?: boolean;
+        description?: string;
+    }>;
+}
+export type CodeActionKind = "quickfix" | "refactor" | "refactor.extract" | "refactor.inline" | "refactor.rewrite" | "source" | "source.organizeImports" | "source.fixAll" | string;
+export interface Command {
+    title: string;
+    command: string;
+    arguments?: unknown[];
+}
+export interface CodeAction {
+    title: string;
+    kind?: CodeActionKind;
+    diagnostics?: Diagnostic[];
+    isPreferred?: boolean;
+    disabled?: {
+        reason: string;
+    };
+    edit?: WorkspaceEdit;
+    command?: Command;
+    data?: unknown;
+}
+export interface CodeActionContext {
+    diagnostics: Diagnostic[];
+    only?: CodeActionKind[];
+    triggerKind?: 1 | 2;
+}
+export type SymbolKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26;
+export declare const SYMBOL_KIND_NAMES: Record<SymbolKind, string>;
+export interface DocumentSymbol {
+    name: string;
+    detail?: string;
+    kind: SymbolKind;
+    tags?: number[];
+    deprecated?: boolean;
+    range: Range;
+    selectionRange: Range;
+    children?: DocumentSymbol[];
+}
+export interface SymbolInformation {
+    name: string;
+    kind: SymbolKind;
+    tags?: number[];
+    deprecated?: boolean;
+    location: Location;
+    containerName?: string;
+}
+export interface MarkupContent {
+    kind: "plaintext" | "markdown";
+    value: string;
+}
+export type MarkedString = string | {
+    language: string;
+    value: string;
+};
+export interface Hover {
+    contents: MarkupContent | MarkedString | MarkedString[];
+    range?: Range;
+}
+/**
+ * Interface for linter/formatter clients.
+ * Can be implemented using LSP protocol or CLI tools.
+ */
+export interface LinterClient {
+    /** Format file content. Returns formatted content. */
+    format(filePath: string, content: string): Promise<string>;
+    /** Get diagnostics for a file. Content should already be written to disk. */
+    lint(filePath: string): Promise<Diagnostic[]>;
+    /** Dispose of any resources (e.g., LSP connection) */
+    dispose?(): void;
+}
+/** Factory function to create a LinterClient */
+export type LinterClientFactory = (config: ServerConfig, cwd: string) => LinterClient;
+export interface ServerCapabilities {
+    flycheck?: boolean;
+    ssr?: boolean;
+    expandMacro?: boolean;
+    runnables?: boolean;
+    relatedTests?: boolean;
+}
+export interface ServerConfig {
+    command: string;
+    args?: string[];
+    fileTypes: string[];
+    rootMarkers: string[];
+    initOptions?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    disabled?: boolean;
+    /** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
+    warmupTimeoutMs?: number;
+    capabilities?: ServerCapabilities;
+    /** Names of lower-precedence servers to drop when this server is available. */
+    supersedes?: string[];
+    /** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
+    isLinter?: boolean;
+    /** Resolved absolute path to the command binary (set during config loading) */
+    resolvedCommand?: string;
+    /**
+     * Custom linter client factory. If provided, creates a custom client instead of using LSP.
+     * The client handles format/lint operations. Useful for tools with buggy LSP implementations.
+     */
+    createClient?: LinterClientFactory;
+}
+export interface OpenFile {
+    version: number;
+    languageId: string;
+}
+export interface PendingRequest {
+    resolve: (result: unknown) => void;
+    reject: (error: Error) => void;
+    method: string;
+}
+export interface LspServerCapabilities {
+    renameProvider?: boolean | {
+        prepareProvider?: boolean;
+    };
+    codeActionProvider?: boolean | {
+        resolveProvider?: boolean;
+    };
+    hoverProvider?: boolean;
+    definitionProvider?: boolean;
+    referencesProvider?: boolean;
+    documentSymbolProvider?: boolean;
+    workspaceSymbolProvider?: boolean;
+    [key: string]: unknown;
+}
+export interface LspClient {
+    name: string;
+    cwd: string;
+    config: ServerConfig;
+    proc: ptree.ChildProcess<"pipe">;
+    owner?: OwnedProcess;
+    requestId: number;
+    diagnostics: Map<string, PublishedDiagnostics>;
+    diagnosticsVersion: number;
+    openFiles: Map<string, OpenFile>;
+    pendingRequests: Map<number, PendingRequest>;
+    messageBuffer: Uint8Array;
+    isReading: boolean;
+    serverCapabilities?: LspServerCapabilities;
+    lastActivity: number;
+    /** Serializes outbound JSON-RPC writes to the server process. */
+    writeQueue: Promise<void>;
+    /** Tracks active work-done progress tokens from the server */
+    activeProgressTokens: Set<string | number>;
+    /** Resolves when the server's initial project loading completes (or after timeout) */
+    projectLoaded: Promise<void>;
+    /** Call to signal that project loading has completed */
+    resolveProjectLoaded: () => void;
+}
+export interface LspJsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number;
+    method: string;
+    params: unknown;
+}
+export interface LspJsonRpcResponse {
+    jsonrpc: "2.0";
+    id?: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface LspJsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}

package/dist/types/lsp/utils.d.ts

@@ -0,0 +1,108 @@
+export { truncate } from "@sayknow-cli/utils";
+import type { CodeAction, Command, Diagnostic, DiagnosticSeverity, DocumentSymbol, Location, SymbolInformation, SymbolKind, TextEdit, WorkspaceEdit } from "./types";
+export { detectLanguageId } from "../utils/lang-from-path";
+/**
+ * Convert a file path to a file:// URI.
+ * Handles Windows drive letters correctly.
+ */
+export declare function fileToUri(filePath: string): string;
+/**
+ * Convert a file:// URI to a file path.
+ * Handles Windows drive letters correctly.
+ */
+export declare function uriToFile(uri: string): string;
+/**
+ * Convert diagnostic severity number to string name.
+ */
+export declare function severityToString(severity?: DiagnosticSeverity): string;
+/**
+ * Sort diagnostics by severity, then by location and message.
+ */
+export declare function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[];
+/**
+ * Get icon for diagnostic severity.
+ */
+export declare function severityToIcon(severity?: DiagnosticSeverity): string;
+/**
+ * Format a diagnostic as a human-readable string.
+ */
+export declare function formatDiagnostic(diagnostic: Diagnostic, filePath: string): string;
+/**
+ * Reformat pre-formatted diagnostic messages into grep-style directory/file groups.
+ * Input:  ["path:line:col [sev] msg", ...]
+ * Output: "# dir/\n## file.ts\n  line:col [sev] msg"
+ *
+ * Messages that don't match the expected format are appended ungrouped at the end.
+ */
+export declare function formatGroupedDiagnosticMessages(messages: string[]): string;
+/**
+ * Format diagnostics grouped by severity.
+ */
+export declare function formatDiagnosticsSummary(diagnostics: Diagnostic[]): string;
+/**
+ * Format a location as file:line:col relative to cwd.
+ */
+export declare function formatLocation(location: Location, cwd: string): string;
+/**
+ * Format a position as line:col.
+ */
+export declare function formatPosition(line: number, col: number): string;
+/**
+ * Format a workspace edit as a summary of changes.
+ */
+export declare function formatWorkspaceEdit(edit: WorkspaceEdit, cwd: string): string[];
+/**
+ * Format a text edit as a preview.
+ */
+export declare function formatTextEdit(edit: TextEdit, maxLength?: number): string;
+/**
+ * Get icon for symbol kind.
+ */
+export declare function symbolKindToIcon(kind: SymbolKind): string;
+/**
+ * Get name for symbol kind.
+ */
+export declare function symbolKindToName(kind: SymbolKind): string;
+/**
+ * Format a document symbol with optional hierarchy.
+ */
+export declare function formatDocumentSymbol(symbol: DocumentSymbol, indent?: number): string[];
+/**
+ * Format a symbol information (flat format).
+ */
+export declare function formatSymbolInformation(symbol: SymbolInformation, cwd: string): string;
+export declare function filterWorkspaceSymbols(symbols: SymbolInformation[], query: string): SymbolInformation[];
+export declare function dedupeWorkspaceSymbols(symbols: SymbolInformation[]): SymbolInformation[];
+export declare function formatCodeAction(action: CodeAction | Command, index: number): string;
+export interface CodeActionApplyDependencies {
+    resolveCodeAction?: (action: CodeAction) => Promise<CodeAction>;
+    applyWorkspaceEdit: (edit: WorkspaceEdit) => Promise<string[]>;
+    executeCommand: (command: Command) => Promise<void>;
+}
+export interface AppliedCodeActionResult {
+    title: string;
+    edits: string[];
+    executedCommands: string[];
+}
+export declare function applyCodeAction(action: CodeAction | Command, dependencies: CodeActionApplyDependencies): Promise<AppliedCodeActionResult | null>;
+export declare function hasGlobPattern(value: string): boolean;
+export declare function collectGlobMatches(pattern: string, cwd: string, maxMatches: number): Promise<{
+    matches: string[];
+    truncated: boolean;
+}>;
+export declare function resolveDiagnosticTargets(file: string, cwd: string, maxMatches: number): Promise<{
+    matches: string[];
+    truncated: boolean;
+}>;
+/**
+ * Extract plain text from hover contents.
+ */
+export declare function extractHoverText(contents: string | {
+    kind: string;
+    value: string;
+} | {
+    language: string;
+    value: string;
+} | unknown[]): string;
+export declare function resolveSymbolColumn(filePath: string, line: number, symbolSpec?: string): Promise<number>;
+export declare function readLocationContext(filePath: string, line: number, contextLines?: number): Promise<string[]>;

package/dist/types/main.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Main entry point for the coding agent CLI.
+ *
+ * This file handles CLI argument parsing and translates them into
+ * createAgentSession() options. The SDK does the heavy lifting.
+ */
+import type { ImageContent } from "@sayknow-cli/ai";
+import type { Args } from "./cli/args";
+import { ModelRegistry } from "./config/model-registry";
+import { Settings } from "./config/settings";
+import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import type { AcpStartupOptions } from "./modes/acp/startup-options";
+import type { SessionSelectionResult } from "./modes/components/session-selector";
+import type { InteractiveMode } from "./modes/interactive-mode";
+import type { PrintModeOptions } from "./modes/print-mode";
+import { initTheme } from "./modes/theme/theme";
+import type { SubmittedUserInput } from "./modes/types";
+import type { MCPManager } from "./runtime-mcp";
+import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage } from "./sdk";
+import type { AgentSession } from "./session/agent-session";
+import { type ResumeSessionIdentity, type SessionDestination, type SessionDirectoryMigrationPolicy, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
+import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
+import type { LspStartupServerInfo } from "./tools";
+import type { EventBus } from "./utils/event-bus";
+export type StartupUpdateRoute = "interactive" | "print" | "text" | "json" | "acp";
+export declare function classifyStartupUpdateRoute(parsed: Pick<Args, "print" | "mode">, autoPrint: boolean): StartupUpdateRoute;
+/** Coordinates the non-blocking update check around the interactive UI lifecycle. */
+export declare class StartupUpdateOrchestrator {
+    #private;
+    constructor(route: StartupUpdateRoute, enabled: () => boolean, check: () => Promise<string | undefined>);
+    startBeforeInteractiveInitialization(): void;
+    attachAfterInteractiveInitialization(notify: (version: string) => void): void;
+}
+export interface StartupUpdateInteractiveMode {
+    init: () => Promise<void>;
+    showNewVersionNotification: (version: string) => void;
+}
+export declare function initializeInteractiveModeWithStartupUpdate(mode: StartupUpdateInteractiveMode, startupUpdate: StartupUpdateOrchestrator): Promise<void>;
+/**
+ * Translate only ACP startup settings with a canonical SDK control carrier.
+ * Every other local-session flag is rejected so the broker-backed ACP host
+ * never appears to accept options it cannot apply to its remote session.
+ */
+export declare function resolveAcpStartupOptions(parsed: Pick<Args, "allowHome" | "apiKey" | "appendSystemPrompt" | "credential" | "continue" | "default" | "cwd" | "fileArgs" | "fork" | "hooks" | "messages" | "mpreset" | "mcpConfig" | "model" | "models" | "noLsp" | "noPty" | "noRules" | "noSession" | "noSkills" | "noTitle" | "noTools" | "pluginDirs" | "print" | "provider" | "providerSessionId" | "resume" | "sessionDir" | "skills" | "slow" | "smol" | "plan" | "systemPrompt" | "thinking" | "tmux" | "tools" | "extensions" | "unknownFlags">, sessionOptions: Pick<CreateAgentSessionOptions, "model" | "modelPattern" | "thinkingLevel">): AcpStartupOptions;
+declare function readPipedInput(): Promise<string | undefined>;
+export interface InteractiveModeNotify {
+    kind: "warn" | "error" | "info";
+    message: string;
+}
+export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+type StartupModelProfileArgs = {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+    startupModel?: CreateAgentSessionOptions["model"];
+    startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+};
+export declare function applyStartupModelProfiles(args: StartupModelProfileArgs): Promise<void>;
+export declare function applyStartupModelProfilesOrExit(args: StartupModelProfileArgs): Promise<void>;
+export declare function isStartupModelProfileCredentialRecoveryEligible(options: {
+    isInteractive: boolean;
+    hasInteractiveTerminal: boolean;
+    initialMessage: string | undefined;
+    initialMessages: readonly string[];
+    resumeAction: "continue-tail" | "open-idle" | undefined;
+}): boolean;
+export declare function applyStartupModelProfilesForRoot(args: StartupModelProfileArgs & {
+    isInteractive: boolean;
+    hasInteractiveTerminal: boolean;
+    initialMessage: string | undefined;
+    initialMessages: readonly string[];
+    resumeAction: "continue-tail" | "open-idle" | undefined;
+}): Promise<{
+    recoverableErrors: string[];
+}>;
+interface InteractiveModeFactoryOptions {
+    session: AgentSession;
+    version: string;
+    changelogMarkdown: string | undefined;
+    setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
+    lspServers: LspStartupServerInfo[] | undefined;
+    mcpManager: MCPManager | undefined;
+    eventBus?: EventBus;
+}
+type CreateInteractiveMode = (options: InteractiveModeFactoryOptions) => InteractiveMode;
+type ResumePickerTerminalCheck = () => boolean;
+type ListForResumePickerReadOnly = (cwd: string, sessionDir?: string) => Promise<SessionInfo[]>;
+type SelectResumeSession = (sessions: SessionInfo[]) => Promise<SessionSelectionResult>;
+type OpenExistingSessionStrict = (identity: ResumeSessionIdentity, destination: SessionDestination, storage?: undefined, migrationPolicy?: SessionDirectoryMigrationPolicy) => Promise<StrictSessionOpenResult>;
+export declare const BARE_RESUME_CONFLICT_ERROR = "--resume without a session cannot be combined with --continue, --fork, or --no-session.";
+export declare const BARE_RESUME_INTERACTIVE_ERROR = "--resume requires an interactive terminal; use --resume <id>.";
+export declare const BARE_RESUME_OPEN_ERROR = "Could not open the selected session. Use --resume <id>.";
+export declare function runInteractiveMode(session: AgentSession, version: string, changelogMarkdown: string | undefined, notifs: (InteractiveModeNotify | null)[], startupUpdate: StartupUpdateOrchestrator, initialMessages: string[], setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void, lspServers: LspStartupServerInfo[] | undefined, mcpManager: MCPManager | undefined, eventBus?: EventBus, initialMessage?: string, initialImages?: ImageContent[], createInteractiveMode?: CreateInteractiveMode, resumeAction?: "continue-tail" | "open-idle"): Promise<void>;
+declare function getChangelogForDisplay(parsed: Args): Promise<string | undefined>;
+export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings): Promise<SessionManager | undefined>;
+/**
+ * Research-mode (RLM) preset hook. Lets `skc rlm` augment the session options
+ * (system prompt, restricted toolset, custom python tool) and assert the tool
+ * boundary once the session's tool registry is fully assembled.
+ */
+export interface RlmPreset {
+    applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
+    onSessionCreated?: (session: AgentSession) => void | Promise<void>;
+}
+type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
+export interface RunRootCommandDependencies {
+    createAgentSession?: typeof createAgentSession;
+    discoverAuthStorage?: typeof discoverAuthStorage;
+    runAcpMode?: (options?: {
+        agentDir?: string;
+    }) => Promise<void>;
+    settings?: Settings;
+    rlmPreset?: RlmPreset;
+    suppressProcessExit?: boolean;
+    startupUpdate?: {
+        check: () => Promise<string | undefined>;
+    };
+    initTheme?: typeof initTheme;
+    readPipedInput?: typeof readPipedInput;
+    stdinIsTTY?: boolean;
+    runStartupCredentialAutoImportIfNeeded?: typeof runStartupCredentialAutoImportIfNeeded;
+    getChangelogForDisplay?: typeof getChangelogForDisplay;
+    createInteractiveMode?: CreateInteractiveMode;
+    runPrintMode?: RunPrintMode;
+    isResumePickerTerminal?: ResumePickerTerminalCheck;
+    listForResumePickerReadOnly?: ListForResumePickerReadOnly;
+    selectResumeSession?: SelectResumeSession;
+    openExistingSessionStrict?: OpenExistingSessionStrict;
+    initializeSettings?: typeof Settings.init;
+    loadSettingsForScope?: typeof Settings.loadForScope;
+}
+export declare function runRootCommand(parsed: Args, rawArgs: string[], deps?: RunRootCommandDependencies): Promise<void>;
+export declare function main(args: string[]): Promise<void>;
+export {};

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

@@ -0,0 +1,28 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { AgentSession } from "../session/agent-session";
+/**
+ * Start the background memory startup pipeline.
+ *
+ * Skips for ephemeral sessions, subagent sessions, disabled settings, or DB failures.
+ */
+export declare function startMemoryStartupTask(options: {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    agentDir: string;
+    taskDepth: number;
+}): void;
+/**
+ * Build memory usage instructions for prompt injection.
+ */
+export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings, session?: AgentSession): Promise<string | undefined>;
+/**
+ * Clear all persisted memory state and generated artifacts.
+ */
+export declare function clearMemoryData(agentDir: string, cwd: string): Promise<void>;
+/**
+ * Force-enqueue global consolidation maintenance work.
+ */
+export declare function enqueueMemoryConsolidation(agentDir: string, cwd: string, sourceUpdatedAt?: number): void;
+export declare function getMemoryRoot(agentDir: string, cwd: string): string;