@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/ml/bayesian-qualifier.js

@@ -190,8 +190,17 @@ export class BayesianQualifier {
      * Load the qualifier state from a JSON string
      */
     loadState(stateJson) {
+        const trimmed = stateJson.trim();
+        if (!trimmed) {
+            logger.debug('[BayesianQualifier] Ignoring empty persisted state');
+            return false;
+        }
         try {
-            const state = JSON.parse(stateJson);
+            const parsed = JSON.parse(trimmed);
+            if (!isBayesianState(parsed)) {
+                throw new Error('invalid bayesian state shape');
+            }
+            const state = parsed;
             this.X = state.X;
             this.y = state.y;
             this.scaler.means = state.means;
@@ -202,9 +211,12 @@ export class BayesianQualifier {
             if (this.X.length > 0) {
                 this.train();
             }
+            return true;
         }
         catch (err) {
-            logger.error(`[BayesianQualifier] Failed to load state: ${err.message}`);
+            const message = err instanceof Error ? err.message : String(err);
+            logger.debug(`[BayesianQualifier] Ignoring invalid persisted state: ${message}`);
+            return false;
         }
     }
     // ============================================================================
@@ -248,4 +260,25 @@ export class BayesianQualifier {
         return x;
     }
 }
+function isNumberArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === 'number' && Number.isFinite(item));
+}
+function isNumberMatrix(value) {
+    return Array.isArray(value) && value.every(isNumberArray);
+}
+function isBayesianState(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const state = value;
+    return (isNumberMatrix(state.X) &&
+        isNumberArray(state.y) &&
+        isNumberArray(state.means) &&
+        isNumberArray(state.stds) &&
+        typeof state.lengthScale === 'number' &&
+        Number.isFinite(state.lengthScale) &&
+        typeof state.signalVariance === 'number' &&
+        Number.isFinite(state.signalVariance) &&
+        typeof state.noiseVariance === 'number' &&
+        Number.isFinite(state.noiseVariance));
+}
 //# sourceMappingURL=bayesian-qualifier.js.map

package/dist/openclaw/gateway-bridge.js

@@ -1,5 +1,6 @@
 import { constants as fsConstants } from 'fs';
 import { access, appendFile, mkdir, readFile, writeFile } from 'fs/promises';
+import { rotateIfLarge } from '../utils/disk-guard.js';
 import * as os from 'os';
 import * as path from 'path';
 import { createPublicKey, randomUUID, sign as signPayload } from 'crypto';
@@ -355,6 +356,7 @@ function responseSummary(response) {
 }
 async function appendAttachRecord(attachLogPath, record) {
     await mkdir(path.dirname(attachLogPath), { recursive: true });
+    rotateIfLarge(attachLogPath);
     await appendFile(attachLogPath, `${JSON.stringify(record)}\n`, 'utf8');
 }
 function sendResponseSummary(response) {
@@ -378,14 +380,17 @@ function sendResponseSummary(response) {
 }
 async function appendSendRecord(sendLogPath, record) {
     await mkdir(path.dirname(sendLogPath), { recursive: true });
+    rotateIfLarge(sendLogPath);
     await appendFile(sendLogPath, `${JSON.stringify(record)}\n`, 'utf8');
 }
 async function appendWebSocketProbeRecord(probeLogPath, record) {
     await mkdir(path.dirname(probeLogPath), { recursive: true });
+    rotateIfLarge(probeLogPath);
     await appendFile(probeLogPath, `${JSON.stringify(record)}\n`, 'utf8');
 }
 async function appendWebSocketCallRecord(callLogPath, record) {
     await mkdir(path.dirname(callLogPath), { recursive: true });
+    rotateIfLarge(callLogPath);
     await appendFile(callLogPath, `${JSON.stringify(record)}\n`, 'utf8');
 }
 function parseOpenClawWebSocketFrame(data) {

package/dist/plugins/marketplace.d.ts

@@ -144,6 +144,7 @@ export declare class PluginMarketplace extends EventEmitter {
     private providers;
     private hooks;
     private updateCheckerIntervalId;
+    private disposed;
     constructor(config?: Partial<MarketplaceConfig>);
     /**
      * Initialize marketplace

package/dist/plugins/marketplace.js

@@ -41,6 +41,7 @@ export class PluginMarketplace extends EventEmitter {
     providers = new Map();
     hooks = new Map();
     updateCheckerIntervalId = null;
+    disposed = false;
     constructor(config = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -55,6 +56,8 @@ export class PluginMarketplace extends EventEmitter {
         await fs.ensureDir(path.join(this.pluginsDir, 'installed'));
         await fs.ensureDir(path.join(this.pluginsDir, 'cache'));
         await this.loadInstalledPlugins();
+        if (this.disposed)
+            return;
         if (this.config.autoUpdate) {
             this.startUpdateChecker();
         }
@@ -273,9 +276,12 @@ export class PluginMarketplace extends EventEmitter {
      * Start update checker
      */
     startUpdateChecker() {
+        if (this.disposed || this.updateCheckerIntervalId)
+            return;
         this.updateCheckerIntervalId = setInterval(() => {
             this.checkUpdates();
         }, this.config.checkUpdatesInterval);
+        this.updateCheckerIntervalId.unref?.();
     }
     /**
      * Validate plugin path is within allowed directory
@@ -641,6 +647,7 @@ export class PluginMarketplace extends EventEmitter {
      * Dispose
      */
     async dispose() {
+        this.disposed = true;
         if (this.updateCheckerIntervalId) {
             clearInterval(this.updateCheckerIntervalId);
             this.updateCheckerIntervalId = null;

package/dist/prompts/execution-discipline.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Execution-discipline guidance — the highest-leverage prompt block borrowed
+ * from the Hermes Agent prompt audit (2026-06-16). Hermes ships an always-on
+ * `TASK_COMPLETION_GUIDANCE` + `<tool_persistence>` / `<mandatory_tool_use>` /
+ * `<verification>` set that pushes the model to *act with tools and deliver a
+ * verified artifact* rather than describe one. Code Buddy previously had only a
+ * gated `workflow-rules` Verification Contract (off for simple/lite queries) and
+ * no anti-stub / tool-persistence / mandatory-tool guidance at all.
+ *
+ * Kept short (~12 lines, ~150 tokens) and model-agnostic. Gated off for
+ * trivial/lite queries and for models without tool-call support
+ * (see prompt-builder.ts gating).
+ */
+export declare function getExecutionDisciplineBlock(): string;

package/dist/prompts/execution-discipline.js

@@ -0,0 +1,29 @@
+/**
+ * Execution-discipline guidance — the highest-leverage prompt block borrowed
+ * from the Hermes Agent prompt audit (2026-06-16). Hermes ships an always-on
+ * `TASK_COMPLETION_GUIDANCE` + `<tool_persistence>` / `<mandatory_tool_use>` /
+ * `<verification>` set that pushes the model to *act with tools and deliver a
+ * verified artifact* rather than describe one. Code Buddy previously had only a
+ * gated `workflow-rules` Verification Contract (off for simple/lite queries) and
+ * no anti-stub / tool-persistence / mandatory-tool guidance at all.
+ *
+ * Kept short (~12 lines, ~150 tokens) and model-agnostic. Gated off for
+ * trivial/lite queries and for models without tool-call support
+ * (see prompt-builder.ts gating).
+ */
+export function getExecutionDisciplineBlock() {
+    return [
+        '## Execution discipline',
+        'You take ACTION with tools — you do not describe what you would do. Each response either makes',
+        'progress via tool calls or delivers a verified final result.',
+        '- The deliverable is a working artifact backed by real tool output, not a description of one.',
+        '  Do not stop after writing a stub, a plan, or a single command.',
+        '- Keep using tools until (1) the task is complete AND (2) you have verified the result with a tool',
+        '  (test output, file read-back, command exit code). Never claim success you have not verified.',
+        '- For anything checkable — file contents, git state, arithmetic, current time, command results —',
+        '  ALWAYS use a tool. Never guess or fabricate tool output.',
+        '- Before finalizing, self-check: Correctness (every requirement met?), Grounding (claims backed by',
+        '  tool output?), Scope (no unintended file changes?).',
+    ].join('\n');
+}
+//# sourceMappingURL=execution-discipline.js.map

package/dist/prompts/variation-injector.js

@@ -142,11 +142,18 @@ export function extractBlocks(prompt) {
     const prefix = lines.slice(0, blockStart).join('\n');
     const rawBlocks = lines.slice(blockStart, blockEnd);
     const suffix = '';
-    // Split rawBlocks into individual bullet points
+    // Split rawBlocks into HEADING-ATOMIC sections: a new block begins at every
+    // `##`/`###` heading and absorbs ALL following lines (bullets, numbered items,
+    // blank lines) until the next heading. Previously this split at every bullet
+    // line, so the Fisher-Yates shuffle in applyVariation() interleaved foreign
+    // bullets (e.g. tool-parameter docs) into the middle of a `##`-headed block
+    // such as the Verification Contract (`## Workflow Orchestration`), corrupting
+    // structured guidance. Heading-atomic grouping shuffles whole sections instead
+    // — the anti-repetition variation is preserved, but no block is ever fragmented.
     const blocks = [];
     let current = '';
     for (const line of rawBlocks) {
-        if ((line.startsWith('- ') || line.startsWith('* ') || line.match(/^\d+\./)) && current) {
+        if (/^#{2,3}\s+/.test(line.trim()) && current.trim()) {
             blocks.push(current.trim());
             current = line;
         }

package/dist/protocols/acp/acp-agentic-runner.d.ts

@@ -5,7 +5,7 @@
  * (https://agentclientprotocol.com). Unlike the original text-only runner,
  * this drives a real agentic loop:
  *
- *   1. Ask the LLM (with a small read-only toolset) for the next step.
+ *   1. Ask the LLM (with a small toolset) for the next step.
  *   2. If it emits tool calls, EXECUTE each one and feed the result back.
  *   3. Repeat until the model stops calling tools (`end_turn`) or we hit
  *      the round cap (`max_turn_requests`).
@@ -26,10 +26,11 @@
  *     `session/request_permission` when that round-trip is available; a
  *     rejection fails the tool call instead of leaking content.
  *
- * Only read-only tools are exposed (`view_file`, `list_directory`,
- * `search`) — this runner never writes. Cancellation is honoured by
- * checking `signal.aborted` on every loop iteration and after every client
- * round-trip.
+ * Read-only tools are always exposed (`view_file`, `list_directory`,
+ * `search`). `write_file` is exposed only when the editor advertises
+ * `fs.writeTextFile`, and the write is routed through the editor permission
+ * flow. Cancellation is honoured by checking `signal.aborted` on every loop
+ * iteration and after every client round-trip.
  */
 import type { AcpPromptContext, AcpStopReason } from './acp-stdio-server.js';
 import type { CodeBuddyMessage, CodeBuddyResponse, CodeBuddyTool } from '../../codebuddy/client.js';
@@ -50,5 +51,5 @@ export interface AcpAgenticRunnerOptions {
 export declare function createAcpAgenticRunner(options: AcpAgenticRunnerOptions): (ctx: AcpPromptContext) => Promise<{
     stopReason: AcpStopReason;
 }>;
-/** Test-only: the static read-only toolset this runner exposes. */
+/** Test-only: the static read-only toolset this runner always exposes. */
 export declare const ACP_READONLY_TOOLS: ReadonlyArray<CodeBuddyTool>;

package/dist/protocols/acp/acp-agentic-runner.js

@@ -5,7 +5,7 @@
  * (https://agentclientprotocol.com). Unlike the original text-only runner,
  * this drives a real agentic loop:
  *
- *   1. Ask the LLM (with a small read-only toolset) for the next step.
+ *   1. Ask the LLM (with a small toolset) for the next step.
  *   2. If it emits tool calls, EXECUTE each one and feed the result back.
  *   3. Repeat until the model stops calling tools (`end_turn`) or we hit
  *      the round cap (`max_turn_requests`).
@@ -26,10 +26,11 @@
  *     `session/request_permission` when that round-trip is available; a
  *     rejection fails the tool call instead of leaking content.
  *
- * Only read-only tools are exposed (`view_file`, `list_directory`,
- * `search`) — this runner never writes. Cancellation is honoured by
- * checking `signal.aborted` on every loop iteration and after every client
- * round-trip.
+ * Read-only tools are always exposed (`view_file`, `list_directory`,
+ * `search`). `write_file` is exposed only when the editor advertises
+ * `fs.writeTextFile`, and the write is routed through the editor permission
+ * flow. Cancellation is honoured by checking `signal.aborted` on every loop
+ * iteration and after every client round-trip.
  */
 import { spawn } from 'child_process';
 import { rgPath } from '@vscode/ripgrep';
@@ -42,9 +43,9 @@ const LIST_DIRECTORY_MAX_ENTRIES = 256;
 const SEARCH_TIMEOUT_MS = 30_000;
 const SEARCH_MAX_RESULTS = 200;
 const SYSTEM_PROMPT = 'You are Code Buddy, a coding assistant operating over the Agent Client Protocol ' +
-    'inside a code editor. You have read-only tools (view_file, list_directory, search) ' +
-    'to inspect the workspace. Use them when you need to look at files, then answer ' +
-    'concisely in Markdown. Never claim to have modified files — you cannot write.';
+    'inside a code editor. Use the tools provided for this turn when you need workspace context. ' +
+    'If write_file is not available, never claim to have modified files. If write_file is available, ' +
+    'writes are routed through the editor and require client permission. Answer concisely in Markdown.';
 const READONLY_TOOLS = [
     {
         type: 'function',
@@ -90,11 +91,26 @@ const READONLY_TOOLS = [
         },
     },
 ];
-/** Maps each read-only tool to its ACP tool-call `kind` (spec enum). */
+const WRITE_FILE_TOOL = {
+    type: 'function',
+    function: {
+        name: 'write_file',
+        description: 'Write text content to a file through the editor client. Will overwrite existing files after permission.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Path to the file (absolute, or relative to the workspace).' },
+                content: { type: 'string', description: 'The exact string content to write into the file.' },
+            },
+            required: ['file_path', 'content'],
+        },
+    },
+};
 const TOOL_KIND = {
     view_file: 'read',
     list_directory: 'read',
     search: 'search',
+    write_file: 'edit',
 };
 /**
  * Build an injectable ACP prompt runner that performs a bounded,
@@ -103,22 +119,63 @@ const TOOL_KIND = {
 export function createAcpAgenticRunner(options) {
     const maxRounds = options.maxRounds ?? DEFAULT_MAX_ROUNDS;
     const maxToolOutputBytes = options.maxToolOutputBytes ?? DEFAULT_MAX_TOOL_OUTPUT_BYTES;
+    // Cache of MCPClientManager instances per session, so we don't reconnect on every prompt
+    const mcpManagers = new Map();
     return async function run(ctx) {
         const userText = extractPromptText(ctx.prompt);
         if (!userText) {
             return { stopReason: 'end_turn' };
         }
+        let mcpManager = mcpManagers.get(ctx.sessionId);
+        if (!mcpManager && ctx.mcpServers) {
+            try {
+                const { MCPManager } = await import('../../mcp/client.js');
+                mcpManager = new MCPManager();
+                mcpManagers.set(ctx.sessionId, mcpManager);
+                const servers = Array.isArray(ctx.mcpServers)
+                    ? ctx.mcpServers
+                    : typeof ctx.mcpServers === 'object' && ctx.mcpServers !== null
+                        ? Object.entries(ctx.mcpServers).map(([name, conf]) => ({ name, ...conf }))
+                        : [];
+                for (const server of servers) {
+                    try {
+                        await mcpManager.addServer(server);
+                    }
+                    catch (e) {
+                        logger.warn(`Failed to add MCP server ${server.name}`, { error: String(e) });
+                    }
+                }
+            }
+            catch (e) {
+                logger.warn('Failed to initialize MCPManager for passthrough', { error: String(e) });
+            }
+        }
         const messages = [
             { role: 'system', content: SYSTEM_PROMPT },
             { role: 'user', content: userText },
         ];
+        const allTools = [...READONLY_TOOLS];
+        if (ctx.canRequestClient('fs/write_text_file')) {
+            allTools.push(WRITE_FILE_TOOL);
+        }
+        if (mcpManager) {
+            const mcpTools = mcpManager.getTools().map((tool) => ({
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema,
+                }
+            }));
+            allTools.push(...mcpTools);
+        }
         let toolCallSeq = 0;
         for (let round = 0; round < maxRounds; round++) {
             if (ctx.signal.aborted)
                 return { stopReason: 'cancelled' };
             let response;
             try {
-                response = await options.chat(messages, READONLY_TOOLS);
+                response = await options.chat(messages, allTools);
             }
             catch (err) {
                 if (ctx.signal.aborted)
@@ -164,13 +221,28 @@ export function createAcpAgenticRunner(options) {
                     status: 'in_progress',
                     rawInput: args,
                 });
-                const result = await executeAcpTool({
-                    name: call.function.name,
-                    args,
-                    ctx,
-                    toolCallId,
-                    maxToolOutputBytes,
-                });
+                let result;
+                if (call.function.name.startsWith('mcp__') && mcpManager) {
+                    try {
+                        const mcpRes = await mcpManager.callTool(call.function.name, args);
+                        const outputText = Array.isArray(mcpRes.content)
+                            ? mcpRes.content.map((c) => c.text).join('\n')
+                            : String(mcpRes);
+                        result = { output: outputText, isError: !!mcpRes.isError };
+                    }
+                    catch (e) {
+                        result = { output: String(e), isError: true };
+                    }
+                }
+                else {
+                    result = await executeAcpTool({
+                        name: call.function.name,
+                        args,
+                        ctx,
+                        toolCallId,
+                        maxToolOutputBytes,
+                    });
+                }
                 if (ctx.signal.aborted)
                     return { stopReason: 'cancelled' };
                 ctx.sendUpdate({
@@ -205,6 +277,8 @@ async function executeAcpTool(input) {
                 return { output: await listDirectory(args, ctx.cwd), isError: false };
             case 'search':
                 return { output: await searchWorkspace(args, ctx.cwd, maxToolOutputBytes), isError: false };
+            case 'write_file':
+                return { output: await writeFileViaClientOrDisk(args, ctx, toolCallId), isError: false };
             default:
                 return { output: `Unknown tool: ${name}`, isError: true };
         }
@@ -248,6 +322,29 @@ async function readFileViaClientOrDisk(args, ctx, toolCallId, maxBytes) {
     const content = await fs.readFile(resolved, 'utf-8');
     return truncate(content, maxBytes);
 }
+/**
+ * Write a file through the editor client. There is deliberately no direct disk
+ * fallback: ACP writes are only allowed when the editor advertises
+ * `fs.writeTextFile`, and they are always gated by client permission.
+ */
+async function writeFileViaClientOrDisk(args, ctx, toolCallId) {
+    const rawPath = stringArg(args, 'file_path') ?? stringArg(args, 'path');
+    const content = stringArg(args, 'content');
+    if (!rawPath)
+        throw new Error('write_file: missing string file_path');
+    if (typeof content !== 'string')
+        throw new Error('write_file: missing string content');
+    if (!ctx.canRequestClient('fs/write_text_file')) {
+        throw new Error('write_file is unavailable because the ACP client did not advertise fs.writeTextFile.');
+    }
+    const absolute = path.isAbsolute(rawPath) ? rawPath : path.resolve(ctx.cwd, rawPath);
+    const allowed = await requestPermission(ctx, toolCallId, absolute);
+    if (!allowed) {
+        throw new Error(`Permission to write ${rawPath} was denied by the editor.`);
+    }
+    await ctx.requestClient('fs/write_text_file', { sessionId: ctx.sessionId, path: absolute, content });
+    return `Successfully wrote to ${rawPath} via editor client`;
+}
 async function requestPermission(ctx, toolCallId, target) {
     const outcome = await ctx.requestClient('session/request_permission', {
         sessionId: ctx.sessionId,
@@ -402,6 +499,6 @@ function truncate(text, maxBytes) {
         return text;
     return `${text.slice(0, maxBytes)}\n... [truncated]`;
 }
-/** Test-only: the static read-only toolset this runner exposes. */
+/** Test-only: the static read-only toolset this runner always exposes. */
 export const ACP_READONLY_TOOLS = READONLY_TOOLS;
 //# sourceMappingURL=acp-agentic-runner.js.map

package/dist/protocols/acp/acp-session-store.d.ts

@@ -0,0 +1,23 @@
+export interface AcpPersistedSession {
+    sessionId: string;
+    cwd: string;
+    title?: string;
+    history: unknown[];
+    mcpServers?: unknown;
+    updatedAt: string;
+}
+export interface AcpSessionStoreConfig {
+    storeDir?: string;
+}
+export declare class AcpSessionStore {
+    private readonly dir;
+    constructor(config?: AcpSessionStoreConfig);
+    save(session: AcpPersistedSession): Promise<void>;
+    load(sessionId: string): Promise<AcpPersistedSession | null>;
+    delete(sessionId: string): Promise<void>;
+    listAll(): Promise<AcpPersistedSession[]>;
+    private writeUnlocked;
+    private fileFor;
+    private ensureDir;
+    private defaultDir;
+}

package/dist/protocols/acp/acp-session-store.js

@@ -0,0 +1,77 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { withSessionLock } from '../../persistence/session-lock.js';
+import { logger } from '../../utils/logger.js';
+export class AcpSessionStore {
+    dir;
+    constructor(config = {}) {
+        this.dir = config.storeDir ?? this.defaultDir();
+        this.ensureDir();
+    }
+    async save(session) {
+        const file = this.fileFor(session.sessionId);
+        await withSessionLock(file, async () => {
+            await this.writeUnlocked(session);
+        });
+    }
+    async load(sessionId) {
+        const file = this.fileFor(sessionId);
+        if (!fs.existsSync(file))
+            return null;
+        try {
+            const raw = await fs.promises.readFile(file, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            logger.warn?.('[acp-session-store] failed to read session', {
+                sessionId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    async delete(sessionId) {
+        const file = this.fileFor(sessionId);
+        await withSessionLock(file, async () => {
+            if (fs.existsSync(file)) {
+                await fs.promises.unlink(file);
+            }
+        });
+    }
+    async listAll() {
+        if (!fs.existsSync(this.dir))
+            return [];
+        const files = await fs.promises.readdir(this.dir);
+        const sessions = [];
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            const sessionId = f.slice(0, -5);
+            const s = await this.load(sessionId);
+            if (s)
+                sessions.push(s);
+        }
+        return sessions;
+    }
+    async writeUnlocked(session) {
+        const file = this.fileFor(session.sessionId);
+        const temp = `${file}.tmp.${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        await fs.promises.writeFile(temp, JSON.stringify(session, null, 2), 'utf-8');
+        await fs.promises.rename(temp, file);
+    }
+    fileFor(sessionId) {
+        const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+        return path.join(this.dir, `${safe}.json`);
+    }
+    ensureDir() {
+        if (!fs.existsSync(this.dir)) {
+            fs.mkdirSync(this.dir, { recursive: true });
+        }
+    }
+    defaultDir() {
+        const home = os.homedir();
+        return path.join(home, '.codebuddy', 'acp-sessions');
+    }
+}
+//# sourceMappingURL=acp-session-store.js.map

package/dist/protocols/acp/acp-stdio-server.d.ts

@@ -30,6 +30,7 @@
  * backed by client `fs/*` + `session/request_permission`, and MCP passthrough.
  */
 import type { Readable, Writable } from 'node:stream';
+import { AcpSessionStore } from './acp-session-store.js';
 export declare const ACP_PROTOCOL_VERSION = 1;
 export interface AcpContentBlock {
     type: string;
@@ -53,6 +54,7 @@ export interface AcpPromptContext {
     sessionId: string;
     cwd: string;
     clientCapabilities: AcpClientCapabilities;
+    mcpServers?: unknown;
     canRequestClient: (method: string) => boolean;
     prompt: AcpContentBlock[];
     signal: AbortSignal;
@@ -68,6 +70,7 @@ export interface AcpAgentInfo {
     version: string;
 }
 export interface AcpStdioServerOptions {
+    store?: AcpSessionStore;
     promptRunner: AcpPromptRunner;
     /** Defaults to process.stdin. */
     input?: Readable;
@@ -87,6 +90,8 @@ export declare class AcpStdioServer {
     private readonly clientRequestTimeoutMs;
     private readonly sessions;
     private readonly pendingClientRequests;
+    private readonly store;
+    private storeLoaded;
     private clientCapabilities;
     private nextClientRequestId;
     private buffer;
@@ -98,6 +103,8 @@ export declare class AcpStdioServer {
     private ingest;
     private write;
     private sendUpdate;
+    private ensureStoreLoaded;
+    private persistSession;
     private requestClient;
     private handleLine;
     private dispatch;