@prometheus-ai/agent 0.5.3 → 0.5.8

package/dist/types/internal-urls/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (agent://, artifact://, memory://, skill://, rule://, mcp://, prometheus://, local://) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `prometheus://`, `pr://`, `rule://`, `skill://`, and `vault://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 import type { LocalProtocolOptions } from "./local-protocol";

package/dist/types/irc/bus.d.ts

@@ -0,0 +1,79 @@
+/**
+ * IrcBus - Process-global mailbox bus for agent-to-agent messaging.
+ *
+ * Replaces the old auto-reply model: a `send` never blocks on the recipient
+ * generating anything. Delivery resolves the recipient via the global
+ * AgentRegistry — parked agents are revived through the
+ * AgentLifecycleManager, idle agents are woken with a real turn, and busy
+ * agents receive the message as a non-interrupting aside at the next step
+ * boundary (see AgentSession.deliverIrcMessage). Replies are real turns by
+ * the recipient, observed via `wait` — with one exception: when the sender
+ * awaits a reply and the recipient is mid-turn with async execution
+ * disabled, the recipient session generates an ephemeral side-channel
+ * auto-reply (it may be blocked in a synchronous task spawn whose batch
+ * includes the sender, so a real turn could never happen in time).
+ */
+import { AgentLifecycleManager } from "../registry/agent-lifecycle";
+import { AgentRegistry } from "../registry/agent-registry";
+export interface IrcMessage {
+    id: string;
+    /** Sender agent id. */
+    from: string;
+    /** Recipient agent id (resolved; "all" is expanded by the tool, not stored). */
+    to: string;
+    body: string;
+    ts: number;
+    /** Message id being answered. */
+    replyTo?: string;
+}
+export interface IrcDeliveryReceipt {
+    to: string;
+    outcome: "injected" | "woken" | "revived" | "failed";
+    error?: string;
+}
+export declare class IrcBus {
+    #private;
+    static global(): IrcBus;
+    /** Reset the global bus. Test-only. */
+    static resetGlobalForTests(): void;
+    constructor(registry?: AgentRegistry, lifecycle?: AgentLifecycleManager);
+    /**
+     * Fire-and-forget delivery. Never blocks on the recipient generating
+     * anything: the receipt reports how the message reached the recipient
+     * (waiter/aside = "injected", idle wake = "woken", park revival =
+     * "revived"), not what they did with it.
+     *
+     * Mailbox semantics: a successfully delivered message never lingers in
+     * the recipient's mailbox — injection/wake puts the full body into their
+     * context, so buffering it too would double-deliver via a later
+     * `wait`/`inbox` and inflate unread counts. Only a failed live hand-off
+     * is buffered for the recipient to drain later.
+     *
+     * `opts.expectsReply` marks sends whose caller is blocked on an answer
+     * (`send await:true`). It is forwarded to the recipient session so a
+     * mid-turn recipient that cannot reach a step boundary (async execution
+     * disabled — e.g. blocked in a synchronous task spawn awaiting the
+     * sender's own batch) can generate an ephemeral side-channel auto-reply
+     * instead of stranding the sender until timeout.
+     */
+    send(msg: Omit<IrcMessage, "id" | "ts">, opts?: {
+        expectsReply?: boolean;
+    }): Promise<IrcDeliveryReceipt>;
+    /**
+     * Block until a message for `agentId` (optionally from `filter.from`)
+     * arrives; consume + return it. Null on timeout (`timeoutMs <= 0` waits
+     * forever). Rejects when `signal` aborts. By default, already-buffered
+     * mail satisfies the wait before parking a future waiter; callers that
+     * need a strictly future reply can disable that drain.
+     */
+    wait(agentId: string, filter: {
+        from?: string;
+    }, timeoutMs: number, signal?: AbortSignal, options?: {
+        drainPending?: boolean;
+    }): Promise<IrcMessage | null>;
+    /** Drain (or peek) pending messages for `agentId`. */
+    inbox(agentId: string, opts?: {
+        peek?: boolean;
+    }): IrcMessage[];
+    unreadCount(agentId: string): number;
+}

package/dist/types/lib/xai-http.d.ts

@@ -4,7 +4,7 @@ interface XAICredentials {
     apiKey: string;
     baseURL: string;
 }
-export declare function prometheusXAIUserAgent(): string;
+export declare function getPrometheusXAIUserAgent(): string;
 /**
  * Resolve xAI credentials for HTTP tool calls.
  *

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

@@ -45,6 +45,16 @@ export declare function refreshFile(client: LspClient, filePath: string, signal?
 export declare function shutdownClient(key: string): Promise<void>;
 /**
  * Send an LSP request and wait for response.
+ *
+ * Timeout policy:
+ * - If `timeoutMs` is explicitly provided, that value is used.
+ * - Else, if `signal` is provided, no internal timer is installed (the caller
+ *   owns the deadline via the signal — typically a wall-clock `AbortSignal.timeout`
+ *   from the LSP tool). Installing a second hard-coded 30s timer here used to
+ *   cause "timed out after 30000ms" errors even when the caller had requested
+ *   `timeout: 60`.
+ * - Else (no signal, no explicit timeout), fall back to `DEFAULT_REQUEST_TIMEOUT_MS`
+ *   to avoid leaking pending requests forever.
  */
 export declare function sendRequest(client: LspClient, method: string, params: unknown, signal?: AbortSignal, timeoutMs?: number): Promise<unknown>;
 /**

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

@@ -22,8 +22,8 @@ export declare function resolveCommand(command: string, cwd: string): string | n
  *
  * Priority (highest to lowest):
  * 1. Project root: lsp.json/.lsp.json/lsp.yml/.lsp.yml/lsp.yaml/.lsp.yaml
- * 2. Project config dirs: .prometheus/lsp.*, .claude/lsp.*, .codex/lsp.*, .gemini/lsp.* (+ hidden variants)
- * 3. User config dirs: ~/.prometheus/agent/lsp.*, ~/.claude/lsp.*, ~/.codex/lsp.*, ~/.gemini/lsp.* (+ hidden variants)
+ * 2. Project config dirs: .prometheus and .claude LSP config files (+ hidden variants)
+ * 3. User config dirs: ~/.prometheus/agent and ~/.claude LSP config files (+ hidden variants)
  * 4. User home root: ~/lsp.*, ~/.lsp.*
  * 5. Auto-detect from project markers + available binaries
  *

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

@@ -6,6 +6,13 @@ import type { Range, TextEdit, WorkspaceEdit } from "./types";
 export declare function applyTextEditsToString(content: string, edits: TextEdit[]): string;
 /** True when two ranges overlap (share any position other than a touching boundary). */
 export declare function rangesOverlap(a: Range, b: Range): boolean;
+/**
+ * Sort edits bottom-to-top for in-place application and reject overlaps.
+ * Equal start positions tiebreak by original array index descending so that,
+ * applied bottom-up, inserts at the same position land in array order
+ * (LSP spec: the order of edits in the array defines the order in the result).
+ */
+export declare function sortAndValidateTextEdits(edits: TextEdit[]): TextEdit[];
 /**
  * Flatten a WorkspaceEdit's text edits into a Map<uri, TextEdit[]>.
  * Resource operations (create/rename/delete) are ignored — callers handle them separately.
@@ -18,6 +25,8 @@ export declare function flattenWorkspaceTextEdits(edit: WorkspaceEdit): Map<stri
 export declare function applyTextEdits(filePath: string, edits: TextEdit[]): Promise<void>;
 /**
  * Apply a workspace edit (collection of file changes).
+ * All text-edit batches are overlap-validated before anything is written so a
+ * conflict throws without leaving the workspace half-applied.
  * Returns array of applied change descriptions.
  */
 export declare function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Promise<string[]>;

package/dist/types/lsp/format-options.d.ts

@@ -0,0 +1,32 @@
+/** Subset of the LSP `FormattingOptions` we send. */
+export interface LspFormattingOptions {
+    tabSize: number;
+    insertSpaces: boolean;
+    trimTrailingWhitespace: boolean;
+    insertFinalNewline: boolean;
+    trimFinalNewlines: boolean;
+}
+interface DetectedIndent {
+    tabSize?: number;
+    insertSpaces?: boolean;
+}
+/**
+ * Sniff `insertSpaces` and the indent unit from `content`.
+ *
+ * Walks the buffer once: the first indented line decides spaces vs tabs; for
+ * space indents, the GCD of all space-indent widths gives the stride (so a
+ * 2/4/6 file reports `2`, a 4/8 file reports `4`). Returns `undefined` for any
+ * field the content does not pin so a higher-precedence override (editorconfig)
+ * can win without being overwritten by sniffing noise.
+ */
+export declare function detectIndentFromContent(content: string): DetectedIndent;
+/**
+ * Resolve the `FormattingOptions` payload for a `textDocument/formatting` request
+ * targeting `filePath` with `content`.
+ *
+ * The two fields that actually affect on-disk bytes (`tabSize`, `insertSpaces`)
+ * are layered: editorconfig wins, then content sniffing, then the fallback.
+ * Trim/final-newline flags are static.
+ */
+export declare function resolveFormatOptions(filePath: string, content: string): LspFormattingOptions;
+export {};

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

@@ -3,7 +3,6 @@ import type { BunFile } from "bun";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from "../tools";
 import { type LspServerStatus } from "./client";
-import { renderCall, renderResult } from "./render";
 import { type LspParams, type LspToolDetails, lspSchema } from "./types";
 export type { LspServerStatus } from "./client";
 export type { LspToolDetails } from "./types";
@@ -15,7 +14,7 @@ export type { LspToolDetails } from "./types";
 export declare const LSP_READONLY_ACTIONS: ReadonlySet<string>;
 export interface LspStartupServerInfo {
     name: string;
-    status: "connecting" | "ready" | "error";
+    status: "connecting" | "ready" | "error" | "available";
     fileTypes: string[];
     error?: string;
 }
@@ -30,7 +29,7 @@ export interface LspWarmupOptions {
     /** Called when starting to connect to servers */
     onConnecting?: (serverNames: string[]) => void;
 }
-export declare function discoverStartupLspServers(cwd: string): LspStartupServerInfo[];
+export declare function discoverStartupLspServers(cwd: string, status?: LspStartupServerInfo["status"]): LspStartupServerInfo[];
 /**
  * Warm up LSP servers for a directory by connecting to all detected servers.
  * This should be called at startup to avoid cold-start delays.
@@ -129,10 +128,6 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
         timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
         payload: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
     }, import("zod/v4/core").$strip>;
-    readonly renderCall: typeof renderCall;
-    readonly renderResult: typeof renderResult;
-    readonly mergeCallAndResult = true;
-    readonly inline = true;
     readonly strict = true;
     constructor(session: ToolSession);
     static createIf(session: ToolSession): LspTool | null;

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

@@ -1,5 +1,5 @@
 import type { ptree } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 export declare const lspSchema: z.ZodObject<{
     action: z.ZodEnum<{
         capabilities: "capabilities";
@@ -222,6 +222,16 @@ export interface ServerConfig {
     disabled?: boolean;
     /** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
     warmupTimeoutMs?: number;
+    /**
+     * Per-server overrides for rust-analyzer workspace-ready polling. When omitted, the module
+     * defaults are used. Primarily a tuning/test seam to bound the multi-second settle window.
+     */
+    workspaceReadyTimings?: {
+        timeoutMs?: number;
+        pollMs?: number;
+        settleMs?: number;
+        statusRequestTimeoutMs?: number;
+    };
     capabilities?: ServerCapabilities;
     /** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
     isLinter?: boolean;
@@ -268,6 +278,8 @@ export interface LspClient {
     pendingRequests: Map<number, PendingRequest>;
     messageBuffer: Uint8Array;
     isReading: boolean;
+    /** Lifecycle state: "connecting" until initialize completes, then "ready"; "error" on init failure or reader death. */
+    status: "connecting" | "ready" | "error";
     serverCapabilities?: LspServerCapabilities;
     lastActivity: number;
     /** Serializes outbound JSON-RPC writes to the server process. */

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

@@ -3,11 +3,14 @@ import type { CodeAction, Command, Diagnostic, DiagnosticSeverity, DocumentSymbo
 export { detectLanguageId } from "../utils/lang-from-path";
 /**
  * Convert a file path to a file:// URI.
+ * Uses the URL machinery so special characters (`%`, `#`, `?`, spaces) are
+ * percent-encoded; plain concatenation produced URIs that broke round-trips.
  * Handles Windows drive letters correctly.
  */
 export declare function fileToUri(filePath: string): string;
 /**
  * Convert a file:// URI to a file path.
+ * Tolerates both percent-encoded URIs and lax servers that send raw paths.
  * Handles Windows drive letters correctly.
  */
 export declare function uriToFile(uri: string): string;
@@ -28,9 +31,10 @@ export declare function severityToIcon(severity?: DiagnosticSeverity): string;
  */
 export declare function formatDiagnostic(diagnostic: Diagnostic, filePath: string): string;
 /**
- * Reformat pre-formatted diagnostic messages into grep-style directory/file groups.
+ * Reformat pre-formatted diagnostic messages into a multi-level, prefix-folded
+ * directory/file grouping (see `formatGroupedFiles`).
  * Input:  ["path:line:col [sev] msg", ...]
- * Output: "# dir/\n## file.ts\n  line:col [sev] msg"
+ * Output: "# pkg/src/\n## file.ts\n  line:col [sev] msg"
  *
  * Messages that don't match the expected format are appended ungrouped at the end.
  */

package/dist/types/main.d.ts

@@ -4,20 +4,24 @@
  * 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 { type Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
+import { type ScopedModel } from "./config/model-resolver";
 import { Settings } from "./config/settings";
-import { InteractiveMode, runAcpMode } from "./modes";
+import { 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 { type SessionInfo, SessionManager } from "./session/session-manager";
+import { type SessionInfo } from "./session/session-listing";
+import { SessionManager } from "./session/session-manager";
+type RunAcpMode = (createSession: AcpSessionFactory) => Promise<never>;
 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>;
+export declare function buildModelScopeNotification(scopedModelsForDisplay: readonly Pick<ScopedModel, "model" | "thinkingLevel" | "explicitThinkingLevel">[], startupQuiet: boolean): InteractiveModeNotify | null;
+export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage" | "isStreaming">, input: SubmittedUserInput): Promise<void>;
 type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 export interface AcpSessionFactoryOptions {
     baseOptions: CreateAgentSessionOptions;
@@ -40,14 +44,25 @@ export interface AcpSessionFactoryOptions {
  * tool registry and shadow the client-supplied servers (issue #1234).
  */
 export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
-type ForkSessionPromptResult = "accepted" | "declined" | "unavailable";
-type ForkSessionPrompt = (session: SessionInfo) => Promise<ForkSessionPromptResult>;
+type SessionPromptResult = "accepted" | "declined" | "unavailable";
+type SessionPrompt = (session: SessionInfo) => Promise<SessionPromptResult>;
+/**
+ * Friendly CLI failure raised by {@link createSessionManager} when the user's
+ * session-resolution flags (`--resume`/`--fork`/cross-project prompts) cannot
+ * be satisfied. {@link runRootCommand} catches it and prints a clean stderr
+ * message instead of letting it surface as `[Uncaught Exception]`
+ * (see issue #2084).
+ */
+export declare class SessionResolutionError extends Error {
+    readonly hint?: string;
+    constructor(message: string, hint?: string);
+}
 /** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
-export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: ForkSessionPrompt): Promise<SessionManager | undefined>;
+export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: SessionPrompt, askToMoveSession?: SessionPrompt): Promise<SessionManager | undefined>;
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
-    runAcpMode?: typeof runAcpMode;
+    runAcpMode?: RunAcpMode;
     settings?: Settings;
     forceSetupWizard?: boolean;
 }

package/dist/types/mcp/json-rpc.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Redact credential-bearing query params (e.g. `exaApiKey`) so failed
+ * requests never write secrets to the persistent log file.
+ */
+export declare function redactUrlForLog(url: string): string;
 /** Parse SSE response format (lines starting with "data: ") */
 export declare function parseSSE(text: string): unknown;
 /** JSON-RPC 2.0 response structure */

package/dist/types/mcp/manager.d.ts

@@ -104,6 +104,14 @@ export declare class MCPManager {
      * Get the source metadata for a server.
      */
     getSource(name: string): SourceMeta | undefined;
+    /**
+     * Get the preserved (pre-auth) config for a known server — whether currently
+     * connected or merely discovered (a connect was attempted but may have failed,
+     * e.g. an OAuth server that has not been authorized yet). Mirrors the
+     * reconnect lookup at {@link reconnectServer} so callers like `/mcp reauth`
+     * can recover a discovered server's config without re-reading config files.
+     */
+    getServerConfig(name: string): MCPServerConfig | undefined;
     /**
      * Wait for a connection to complete (or fail).
      */

package/dist/types/mcp/oauth-discovery.d.ts

@@ -4,11 +4,13 @@
  * Automatically detects OAuth requirements from MCP server responses
  * and extracts authentication endpoints.
  */
+import type { FetchImpl } from "@prometheus-ai/ai/types";
 export interface OAuthEndpoints {
     authorizationUrl: string;
     tokenUrl: string;
     clientId?: string;
     scopes?: string;
+    resource?: string;
 }
 export interface AuthDetectionResult {
     requiresAuth: boolean;
@@ -38,4 +40,7 @@ export declare function analyzeAuthError(error: Error, serverUrl?: string): Auth
  * Try to discover OAuth endpoints by querying the server's well-known endpoints.
  * This is a fallback when error responses don't include OAuth metadata.
  */
-export declare function discoverOAuthEndpoints(serverUrl: string, authServerUrl?: string, resourceMetadataUrl?: string): Promise<OAuthEndpoints | null>;
+export declare function discoverOAuthEndpoints(serverUrl: string, authServerUrl?: string, resourceMetadataUrl?: string, opts?: {
+    fetch?: FetchImpl;
+    protectedResource?: string;
+}): Promise<OAuthEndpoints | null>;

package/dist/types/mcp/oauth-flow.d.ts

@@ -4,8 +4,9 @@
  * Allows users to authenticate with any OAuth-compatible MCP server
  * by providing authorization URL, token URL, and client credentials.
  */
-import { OAuthCallbackFlow } from "@prometheus-ai/ai/utils/oauth/callback-server";
-import type { OAuthController, OAuthCredentials } from "@prometheus-ai/ai/utils/oauth/types";
+import { OAuthCallbackFlow } from "@prometheus-ai/ai/oauth/callback-server";
+import type { OAuthController, OAuthCredentials } from "@prometheus-ai/ai/oauth/types";
+import type { FetchImpl } from "@prometheus-ai/ai/types";
 export interface MCPOAuthConfig {
     /** Authorization endpoint URL */
     authorizationUrl: string;
@@ -23,6 +24,10 @@ export interface MCPOAuthConfig {
     callbackPort?: number;
     /** Custom callback path (default: /callback or redirectUri pathname) */
     callbackPath?: string;
+    /** MCP resource URI for RFC 8707 resource indicators */
+    resource?: string;
+    /** Fetch implementation for token exchange and discovery requests. */
+    fetch?: FetchImpl;
 }
 /**
  * Generic OAuth flow for MCP servers.
@@ -46,6 +51,7 @@ export declare class MCPOAuthFlow extends OAuthCallbackFlow {
      * client id via config.
      */
     get registeredClientSecret(): string | undefined;
+    get resource(): string | undefined;
     generateAuthUrl(state: string, redirectUri: string): Promise<{
         url: string;
         instructions?: string;
@@ -56,4 +62,8 @@ export declare class MCPOAuthFlow extends OAuthCallbackFlow {
  * Refresh an MCP OAuth token using the standard refresh_token grant.
  * Returns updated credentials; preserves the old refresh token if the server doesn't rotate it.
  */
-export declare function refreshMCPOAuthToken(tokenUrl: string, refreshToken: string, clientId?: string, clientSecret?: string): Promise<OAuthCredentials>;
+export declare function refreshMCPOAuthToken(tokenUrl: string, refreshToken: string, clientId?: string, clientSecret?: string, resourceOrOpts?: string | {
+    fetch?: FetchImpl;
+}, opts?: {
+    fetch?: FetchImpl;
+}): Promise<OAuthCredentials>;

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

@@ -0,0 +1,11 @@
+export declare const MCP_CONNECTING_EVENT_CHANNEL = "mcp:connecting";
+export type McpConnectingEvent = {
+    serverNames: string[];
+};
+export declare function formatMCPConnectingMessage(serverNames: string[]): string;
+/**
+ * Runtime validator for the cross-module event payload. The event bus is
+ * untyped at runtime, so the subscriber verifies the shape before formatting
+ * rather than trusting a cast — a malformed emit is ignored instead of throwing.
+ */
+export declare function isMcpConnectingEvent(data: unknown): data is McpConnectingEvent;

package/dist/types/mcp/tool-bridge.d.ts

@@ -53,6 +53,7 @@ export declare class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
     readonly mcpToolName: string;
     /** Server name */
     readonly mcpServerName: string;
+    readonly approval: "write";
     /** Render completed MCP calls with the result header replacing the pending call header. */
     readonly mergeCallAndResult = true;
     /** Create MCPTool instances for all tools from an MCP server connection */
@@ -79,6 +80,7 @@ export declare class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetai
     readonly mcpToolName: string;
     /** Server name */
     readonly mcpServerName: string;
+    readonly approval: "write";
     /** Render completed MCP calls with the result header replacing the pending call header. */
     readonly mergeCallAndResult = true;
     /** Create DeferredMCPTool instances for all tools from an MCP server */

package/dist/types/mcp/transports/stdio.d.ts

@@ -5,6 +5,19 @@
  * Messages are newline-delimited JSON.
  */
 import type { MCPRequestOptions, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
+/** Subprocess argv for launching an MCP stdio server. */
+export interface StdioSpawnCommand {
+    cmd: string[];
+    windowsHide?: boolean;
+}
+/** Inputs used to resolve platform-specific stdio spawn behavior. */
+export interface ResolveStdioSpawnOptions {
+    cwd: string;
+    env: Record<string, string | undefined>;
+    platform?: NodeJS.Platform;
+}
+/** Resolve the subprocess argv used to launch an MCP stdio server. */
+export declare function resolveStdioSpawnCommand(config: MCPStdioServerConfig, options: ResolveStdioSpawnOptions): Promise<StdioSpawnCommand>;
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
 interface FrameSink {
     write(chunk: string): unknown;

package/dist/types/mcp/types.d.ts

@@ -40,6 +40,8 @@ export interface MCPAuthConfig {
     clientId?: string;
     /** Client secret — persisted for token refresh */
     clientSecret?: string;
+    /** MCP resource URI — persisted for OAuth resource indicators during refresh */
+    resource?: string;
 }
 /** Base server config with shared options */
 interface MCPServerConfigBase {

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

@@ -1,16 +1,7 @@
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
+import type { MemoryBackendSaveInput, MemoryBackendSaveResult } from "../memory-backend/types";
 import type { AgentSession } from "../session/agent-session";
-type GeneratedMemorySkillEvent = "use" | "view" | "patch";
-export declare const MEMORY_ARTIFACTS: {
-    readonly summary: "memory_summary.md";
-    readonly memory: "MEMORY.md";
-    readonly user: "USER.md";
-    readonly selfImprovementReport: "self_improvement_report.md";
-    readonly skillUsage: "skill_usage.json";
-    readonly skillCuratorReport: "skill_curator_report.md";
-    readonly soulProposal: "SOUL.proposed.md";
-};
 /**
  * Start the background memory startup pipeline.
  *
@@ -35,9 +26,10 @@ export declare function clearMemoryData(agentDir: string, cwd: string): Promise<
  * Force-enqueue global consolidation maintenance work.
  */
 export declare function enqueueMemoryConsolidation(agentDir: string, cwd: string, sourceUpdatedAt?: number): void;
-export declare function recordGeneratedMemorySkillEvent(memoryRoot: string, rawName: string, event: GeneratedMemorySkillEvent): Promise<boolean>;
-export declare function pinGeneratedMemorySkill(memoryRoot: string, rawName: string, pinned?: boolean): Promise<boolean>;
-export declare function archiveGeneratedMemorySkill(memoryRoot: string, rawName: string, reason: string): Promise<boolean>;
-export declare function restoreGeneratedMemorySkill(memoryRoot: string, rawName: string): Promise<boolean>;
 export declare function getMemoryRoot(agentDir: string, cwd: string): string;
-export {};
+/**
+ * Append one lesson to the project's `learned.md` (newest-first, deduped,
+ * capped, secret-redacted, injection-neutralized). The file backs the `learn`
+ * tool when `memory.backend` is `local`.
+ */
+export declare function saveLearnedLesson(agentDir: string, cwd: string, input: MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;

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

@@ -62,16 +62,6 @@ export declare function markStage1SucceededNoOutput(db: Database, params: {
     nowSec: number;
     cwd: string;
 }): boolean;
-export declare function recordBackgroundStage1Output(db: Database, params: {
-    threadId: string;
-    sourceUpdatedAt: number;
-    rolloutPath: string;
-    cwd: string;
-    rawMemory: string;
-    rolloutSummary: string;
-    rolloutSlug: string | null;
-    nowSec: number;
-}): void;
 export declare function markStage1Failed(db: Database, params: {
     threadId: string;
     ownershipToken: string;

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

@@ -1,5 +1,7 @@
-export * from "../mnemopi";
+export type { MnemopiBackendConfig, MnemopiLlmMode, MnemopiProviderOptions, MnemopiScoping, } from "../mnemopi/config";
+export type { MnemopiMemoryEditOperation, MnemopiMemoryEditOptions, MnemopiMemoryEditResult, MnemopiSessionState, MnemopiSessionStateOptions, } from "../mnemopi/state";
 export * from "./local-backend";
 export * from "./off-backend";
 export * from "./resolve";
+export * from "./runtime";
 export * from "./types";

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

@@ -2,8 +2,9 @@ import type { MemoryBackend } from "./types";
 /**
  * Wraps the existing `memories/` module as a `MemoryBackend`.
  *
- * No behavioural change — every call delegates to the legacy entry points so
- * the local memory pipeline (rollout summarisation → SQLite → memory_summary.md)
- * keeps working exactly as before.
+ * The rollout-summarisation pipeline (rollouts → SQLite → memory_summary.md) is
+ * delegated unchanged. On top of it, `save()` persists `learn`-tool lessons to
+ * `learned.md` (so `status()` reports `writable: true`); structured search is
+ * still unavailable.
  */
 export declare const localBackend: MemoryBackend;

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

@@ -6,11 +6,11 @@ import type { MemoryBackend } from "./types";
  * Selection rules (single source of truth — every memory consumer routes
  * through this):
  *   - `memory.backend === "hindsight"`  → Hindsight remote memory
- *   - `memory.backend === "prometheus-memory"`  → local Prometheus SQLite memory
+ *   - `memory.backend === "mnemopi"`  → local Mnemopi SQLite memory
  *   - `memory.backend === "local"`      → local rollout summary 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;
+export declare function resolveMemoryBackend(settings: Settings): Promise<MemoryBackend>;

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

@@ -0,0 +1,4 @@
+import type { AgentSession } from "../session/agent-session";
+import type { MemoryBackendOperationContext, MemoryRuntimeContext } from "./types";
+export declare function createMemoryRuntimeContext(context: MemoryBackendOperationContext): MemoryRuntimeContext;
+export declare function createSessionMemoryRuntimeContext(session: AgentSession, agentDir: string, cwd: string): MemoryRuntimeContext;