@sayknow-cli/coding-agent 0.3.6 → 0.3.8

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<{
+        capabilities: "capabilities";
+        code_actions: "code_actions";
+        definition: "definition";
+        diagnostics: "diagnostics";
+        hover: "hover";
+        implementation: "implementation";
+        references: "references";
+        reload: "reload";
+        rename: "rename";
+        rename_file: "rename_file";
+        request: "request";
+        status: "status";
+        symbols: "symbols";
+        type_definition: "type_definition";
+    }>;
+    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,75 @@
+/**
+ * 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 { Args } from "./cli/args";
+import { ModelRegistry } from "./config/model-registry";
+import { Settings } from "./config/settings";
+import type { InteractiveMode } from "./modes/interactive-mode";
+import type { SubmittedUserInput } from "./modes/types";
+import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
+import type { AgentSession } from "./session/agent-session";
+import type { AuthStorage } from "./session/auth-storage";
+import { SessionManager } from "./session/session-manager";
+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 CreateSessionForMain = (options: CreateAgentSessionOptions, context?: {
+    skipPostCreateModelRefresh?: boolean;
+}) => Promise<CreateAgentSessionResult>;
+type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
+export interface AcpSessionFactoryOptions {
+    baseOptions: CreateAgentSessionOptions;
+    settings: Settings;
+    sessionDir?: string;
+    authStorage: AuthStorage;
+    modelRegistry: ModelRegistry;
+    parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
+    rawArgs: string[];
+    createSession: CreateSessionForMain;
+}
+export declare function applyStartupModelProfiles(args: {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
+    startupModel?: CreateAgentSessionOptions["model"];
+    startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
+}): Promise<void>;
+export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof applyStartupModelProfiles>[0]): Promise<void>;
+/**
+ * Build the per-`session/new` factory used by ACP mode.
+ *
+ * MCP servers in ACP sessions are owned exclusively by the ACP client, which
+ * supplies them through `session/new.mcpServers` and re-applies them via
+ * {@link AcpAgent#configureMcpServers}. We therefore force `enableMCP: false`
+ * on every session created here so {@link createAgentSession} skips the on-disk
+ * `.mcp.json` discovery path — otherwise host MCP tools land in the session's
+ * tool registry and shadow the client-supplied servers (issue #1234).
+ */
+export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+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>;
+}
+interface RunRootCommandDependencies {
+    createAgentSession?: typeof createAgentSession;
+    discoverAuthStorage?: typeof discoverAuthStorage;
+    runAcpMode?: (createSession: AcpSessionFactory) => Promise<void>;
+    settings?: Settings;
+    rlmPreset?: RlmPreset;
+    suppressProcessExit?: boolean;
+}
+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;

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

@@ -0,0 +1,110 @@
+import { Database } from "bun:sqlite";
+export interface MemoryThread {
+    id: string;
+    updatedAt: number;
+    rolloutPath: string;
+    cwd: string;
+    sourceKind: string;
+}
+export interface Stage1OutputRow {
+    threadId: string;
+    sourceUpdatedAt: number;
+    rawMemory: string;
+    rolloutSummary: string;
+    rolloutSlug: string | null;
+    generatedAt: number;
+    cwd: string;
+}
+export interface Stage1Claim {
+    threadId: string;
+    ownershipToken: string;
+    inputWatermark: number;
+    sourceUpdatedAt: number;
+    rolloutPath: string;
+    cwd: string;
+}
+export interface GlobalClaim {
+    ownershipToken: string;
+    inputWatermark: number;
+}
+export declare function openMemoryDb(dbPath: string): Database;
+export declare function closeMemoryDb(db: Database): void;
+export declare function clearMemoryData(db: Database): void;
+export declare function upsertThreads(db: Database, threads: MemoryThread[]): void;
+export declare function claimStage1Jobs(db: Database, params: {
+    nowSec: number;
+    threadScanLimit: number;
+    maxRolloutsPerStartup: number;
+    maxRolloutAgeDays: number;
+    minRolloutIdleHours: number;
+    leaseSeconds: number;
+    runningConcurrencyCap: number;
+    workerId: string;
+    excludeThreadIds?: string[];
+}): Stage1Claim[];
+export declare function enqueueGlobalWatermark(db: Database, sourceUpdatedAt: number, cwd: string, params?: {
+    forceDirtyWhenNotAdvanced?: boolean;
+}): void;
+export declare function markStage1SucceededWithOutput(db: Database, params: {
+    threadId: string;
+    ownershipToken: string;
+    sourceUpdatedAt: number;
+    rawMemory: string;
+    rolloutSummary: string;
+    rolloutSlug: string | null;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markStage1SucceededNoOutput(db: Database, params: {
+    threadId: string;
+    ownershipToken: string;
+    sourceUpdatedAt: number;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markStage1Failed(db: Database, params: {
+    threadId: string;
+    ownershipToken: string;
+    retryDelaySeconds: number;
+    reason: string;
+    nowSec: number;
+}): boolean;
+export declare function tryClaimGlobalPhase2Job(db: Database, params: {
+    workerId: string;
+    leaseSeconds: number;
+    nowSec: number;
+    cwd: string;
+}): {
+    kind: "claimed";
+    claim: GlobalClaim;
+} | {
+    kind: "skipped_not_dirty";
+} | {
+    kind: "skipped_running";
+};
+export declare function heartbeatGlobalJob(db: Database, params: {
+    ownershipToken: string;
+    leaseSeconds: number;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function listStage1OutputsForGlobal(db: Database, limit: number, cwd: string): Stage1OutputRow[];
+export declare function markGlobalPhase2Succeeded(db: Database, params: {
+    ownershipToken: string;
+    newWatermark: number;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markGlobalPhase2Failed(db: Database, params: {
+    ownershipToken: string;
+    retryDelaySeconds: number;
+    reason: string;
+    nowSec: number;
+    cwd: string;
+}): boolean;
+export declare function markGlobalPhase2FailedUnowned(db: Database, params: {
+    retryDelaySeconds: number;
+    reason: string;
+    nowSec: number;
+    cwd: string;
+}): boolean;

package/dist/types/memory-backend/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./local-backend";
+export * from "./off-backend";
+export * from "./resolve";
+export * from "./types";

package/dist/types/memory-backend/local-backend.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryBackend } from "./types";
+/**
+ * Wraps the existing `memories/` module as a `MemoryBackend`.
+ *
+ * The local pipeline owns rollout summarisation, SQLite retention, and
+ * `memory_summary.md`. Prompt reads use the live session cwd when available so
+ * manual enqueue/rebuild and startup hydration address the same memory root.
+ */
+export declare const localBackend: MemoryBackend;

package/dist/types/memory-backend/off-backend.d.ts

@@ -0,0 +1,7 @@
+import type { MemoryBackend } from "./types";
+/**
+ * No-op memory backend.
+ *
+ * Selected when `memory.backend` is `"off"`.
+ */
+export declare const offBackend: MemoryBackend;

package/dist/types/memory-backend/resolve.d.ts

@@ -0,0 +1,15 @@
+import type { Settings } from "../config/settings";
+import type { MemoryBackend } from "./types";
+/**
+ * Pick the active memory backend for a Settings instance.
+ *
+ * Selection rules (single source of truth — every memory consumer routes
+ * through this):
+ *   - `memory.backend === "hindsight"`  → Hindsight remote memory
+ *   - `memory.backend === "local"`      → local pipeline
+ *   - everything else                   → no-op
+ *
+ * `memories.enabled` remains accepted only as a legacy migration input. Once
+ * a config is loaded, `memory.backend` is the sole runtime selector.
+ */
+export declare function resolveMemoryBackend(settings: Settings): MemoryBackend;