@borgee/agents-host 0.1.8 → 0.2.1

package/README.md

@@ -26,6 +26,7 @@ Borgee channel message
 - local-config multi-agent startup
 - one isolated `AgentsHost` per effective agent key
 - per-channel conversation memory via each provider's native session mechanism
+- one draft progress message per turn when a provider emits public progress
 - hot reload for host config and agent file add / update / remove
 
 **Out of scope:**
@@ -314,13 +315,19 @@ Each Borgee channel is mapped 1:1 to a provider-native session while it stays
 active:
 
 - **Claude**: first turn for a channel uses `--session-id <uuid>`; every turn
-  after uses `-r/--resume <uuid>`.
+  after uses `-r/--resume <uuid>`. The host persists the channel→session map in
+  its state root, serializes cross-channel map rewrites, and retries once with a
+  fresh session immediately if Claude reports a stale `--resume` target.
 - **Copilot**: one persistent `copilot --acp` subprocess is shared by a single
   `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are
-  serialized; different channels keep isolated ACP sessions.
-
-There is no separate history store on our side. If a runner restarts, that
-agent's provider-side channel sessions start fresh.
+  serialized; different channels keep isolated ACP sessions. The host persists
+  the channel→ACP-session map in its state root and restores same-host
+  continuity with ACP `session/resume` when available, otherwise `session/load`
+  plus local replay cleanup on runtimes that advertise only load support.
+
+There is no separate transcript/history store on our side. Claude and Copilot
+only persist the native session ids they should try to resume later; cross-host
+continuity still does not exist in this runtime.
 
 ## Testing
 

package/dist/agents-host.d.ts

@@ -23,8 +23,13 @@ export declare class AgentsHost {
     private readonly config;
     private readonly provider;
     private readonly borgee;
+    private readonly activeTurns;
+    private readonly progressChannelQueues;
+    private readonly progressDrafts;
     private selfAgentId;
+    private selfAgentIdPromise;
     private started;
+    private controlPlaneClosed;
     constructor(config: AgentsHostConfig, deps?: {
         borgee?: ChatControlPlane;
         provider?: ProviderAdapter;
@@ -32,4 +37,8 @@ export declare class AgentsHost {
     start(): Promise<void>;
     stop(): Promise<void>;
     private handleMessage;
+    private trackActiveTurn;
+    private enqueueProgressChannelTurn;
+    private ensureProgressDraft;
+    private ensureSelfAgentId;
 }

package/dist/agents-host.js

@@ -1,5 +1,114 @@
+import { chmod, mkdir } from 'node:fs/promises';
 import { SdkChatControlPlane } from './chat/sdk-chat-control-plane.js';
+import { createDurableCursorStore } from './durable-cursor-store.js';
 import { createProvider } from './providers/create-provider.js';
+const PRIVATE_STATE_ROOT_MODE = 0o700;
+const STREAM_PROGRESS_EDIT_THROTTLE_MS = 150;
+async function ensurePrivateStateRoot(path) {
+    await mkdir(path, { recursive: true, mode: PRIVATE_STATE_ROOT_MODE });
+    await chmod(path, PRIVATE_STATE_ROOT_MODE);
+}
+function hasVisibleText(value) {
+    return value.trim().length > 0;
+}
+function providerUsesDraftProgress(provider) {
+    return provider === 'claude' || provider === 'copilot';
+}
+class DraftMessageController {
+    borgee;
+    channelId;
+    canWrite;
+    messageId = null;
+    currentBody = '';
+    pendingBody = null;
+    timer = null;
+    sealed = false;
+    writeChain = Promise.resolve();
+    constructor(borgee, channelId, canWrite) {
+        this.borgee = borgee;
+        this.channelId = channelId;
+        this.canWrite = canWrite;
+    }
+    update(text) {
+        if (this.sealed || !hasVisibleText(text)) {
+            return;
+        }
+        this.pendingBody = text;
+        if (this.timer) {
+            return;
+        }
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.flushPending().catch((error) => {
+                console.error('[agents-host] failed to flush draft progress:', error);
+            });
+        }, STREAM_PROGRESS_EDIT_THROTTLE_MS);
+    }
+    cancelProgress() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.sealed = true;
+    }
+    async finalize(finalText) {
+        this.sealed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (hasVisibleText(finalText)) {
+            this.pendingBody = finalText;
+            await this.flushPending();
+            return;
+        }
+        await this.enqueueWrite(async () => {
+            if (!this.canWrite() || !this.messageId) {
+                return;
+            }
+            await this.borgee.deleteMessage(this.messageId);
+            this.messageId = null;
+            this.currentBody = '';
+            this.pendingBody = null;
+        });
+    }
+    async discard() {
+        this.sealed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.pendingBody = null;
+        await this.enqueueWrite(async () => {
+            if (!this.canWrite() || !this.messageId) {
+                return;
+            }
+            await this.borgee.deleteMessage(this.messageId);
+            this.messageId = null;
+            this.currentBody = '';
+        });
+    }
+    async flushPending() {
+        await this.enqueueWrite(async () => {
+            const body = this.pendingBody;
+            if (!this.canWrite() || !body || body === this.currentBody) {
+                return;
+            }
+            if (this.messageId) {
+                await this.borgee.editMessage(this.messageId, body);
+            }
+            else {
+                const posted = await this.borgee.postMessage(this.channelId, body);
+                this.messageId = posted.messageId;
+            }
+            this.currentBody = body;
+        });
+    }
+    enqueueWrite(operation) {
+        this.writeChain = this.writeChain.then(operation, operation);
+        return this.writeChain;
+    }
+}
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
  * to exactly one Borgee agent over `@borgee/plugin-sdk` (BPP / `/ws/plugin`).
@@ -22,35 +131,54 @@ export class AgentsHost {
     config;
     provider;
     borgee;
+    activeTurns = new Set();
+    progressChannelQueues = new Map();
+    progressDrafts = new Map();
     selfAgentId = null;
+    selfAgentIdPromise = null;
     started = false;
+    controlPlaneClosed = false;
     constructor(config, deps) {
         this.config = config;
         this.provider = deps?.provider ?? createProvider({
             provider: config.agent.provider,
+            stateRootDir: config.stateRootDir,
+            resolveStableAgentId: () => this.selfAgentId ?? undefined,
             claudeCommand: config.claudeCommand,
             claudeArgs: config.claudeArgs,
             copilotCommand: config.copilotCommand,
             copilotArgs: config.copilotArgs,
             copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
         });
-        this.borgee = deps?.borgee ?? new SdkChatControlPlane(config.borgeeBaseUrl, config.agent.agentApiKey, undefined, 
-        // Lets the server know which runtime/provider actually connected
-        // (internal/bpp ConnectHandler → users.last_connected_plugin_id), so
-        // the web UI can show real state instead of a client-side guess.
-        `agents-host:${config.agent.provider}`);
+        this.borgee = deps?.borgee ?? new SdkChatControlPlane(config.borgeeBaseUrl, config.agent.agentApiKey, undefined, {
+            cursorStore: createDurableCursorStore({
+                stateRootDir: config.stateRootDir,
+            }),
+            // Lets the server know which runtime/provider actually connected
+            // (internal/bpp ConnectHandler → users.last_connected_plugin_id), so
+            // the web UI can show real state instead of a client-side guess.
+            pluginId: `agents-host:${config.agent.provider}`,
+        });
     }
     async start() {
         if (this.started)
             return;
         this.started = true;
+        this.controlPlaneClosed = false;
+        await ensurePrivateStateRoot(this.config.stateRootDir);
         await this.borgee.connect((message) => {
-            void this.handleMessage(message);
+            if (!this.started) {
+                return;
+            }
+            const task = providerUsesDraftProgress(this.config.agent.provider)
+                ? this.enqueueProgressChannelTurn(message.channel_id, () => this.handleMessage(message))
+                : this.handleMessage(message);
+            this.trackActiveTurn(task);
+            return task;
         });
-        const me = await this.borgee.getMe();
-        this.selfAgentId = me.id;
+        const agentId = await this.ensureSelfAgentId();
         console.log('[agents-host] connected', {
-            agentId: me.id,
+            agentId,
             agentName: this.config.agent.agentName,
             provider: this.config.agent.provider,
         });
@@ -59,8 +187,13 @@ export class AgentsHost {
         if (!this.started)
             return;
         this.started = false;
+        for (const draft of this.progressDrafts.values()) {
+            draft.cancelProgress();
+        }
+        this.controlPlaneClosed = true;
         await this.borgee.close();
         await this.provider.dispose?.();
+        await Promise.allSettled([...this.activeTurns]);
     }
     async handleMessage(msg) {
         console.log('[agents-host] received message', {
@@ -69,8 +202,9 @@ export class AgentsHost {
             agentName: this.config.agent.agentName,
             channelId: msg.channel_id,
         });
+        const selfAgentId = await this.ensureSelfAgentId();
         const authorId = String(msg.user_id ?? msg.sender_id ?? 'unknown');
-        if (this.selfAgentId && authorId === this.selfAgentId) {
+        if (authorId === selfAgentId) {
             return;
         }
         const content = String(msg.content ?? msg.body ?? '').trim();
@@ -80,6 +214,8 @@ export class AgentsHost {
         // messages an agent receives (per-agent + per-channel require_mention is
         // enforced at BPP fan-out via AgentReceivesChannelMessage). If a channel
         // message reaches this host at all, the agent is meant to handle it.
+        const stopTyping = this.borgee.startTyping(msg.channel_id);
+        const useDraftProgress = providerUsesDraftProgress(this.config.agent.provider);
         try {
             const reply = await this.provider.generateReply({
                 agentName: this.config.agent.agentName,
@@ -87,15 +223,88 @@ export class AgentsHost {
                 channelId: msg.channel_id,
                 incomingAuthorId: authorId,
                 incomingContent: content,
-            });
-            await this.borgee.postMessage(msg.channel_id, reply.text);
+            }, useDraftProgress
+                ? {
+                    onProgress: (update) => {
+                        if (!this.started || this.controlPlaneClosed) {
+                            return;
+                        }
+                        this.ensureProgressDraft(msg.channel_id).update(update.text);
+                    },
+                }
+                : undefined);
+            if (useDraftProgress) {
+                const draft = this.progressDrafts.get(msg.channel_id);
+                if (!this.started) {
+                    await draft?.discard().catch(() => { });
+                    this.progressDrafts.delete(msg.channel_id);
+                    return;
+                }
+                await (draft ?? this.ensureProgressDraft(msg.channel_id)).finalize(reply.text);
+                this.progressDrafts.delete(msg.channel_id);
+            }
+            else if (this.started && !this.controlPlaneClosed) {
+                await this.borgee.postMessage(msg.channel_id, reply.text);
+            }
         }
         catch (error) {
+            if (useDraftProgress) {
+                const draft = this.progressDrafts.get(msg.channel_id);
+                if (draft) {
+                    await draft.discard().catch(() => { });
+                    this.progressDrafts.delete(msg.channel_id);
+                }
+            }
             console.error('[agents-host] failed to generate or send reply:', {
                 provider: this.config.agent.provider,
                 agentName: this.config.agent.agentName,
                 error,
             });
         }
+        finally {
+            stopTyping();
+        }
+    }
+    trackActiveTurn(task) {
+        this.activeTurns.add(task);
+        void task.finally(() => {
+            this.activeTurns.delete(task);
+        });
+    }
+    enqueueProgressChannelTurn(channelId, task) {
+        const previous = this.progressChannelQueues.get(channelId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => { })
+            .then(task)
+            .finally(() => {
+            if (this.progressChannelQueues.get(channelId) === next) {
+                this.progressChannelQueues.delete(channelId);
+            }
+        });
+        this.progressChannelQueues.set(channelId, next);
+        return next;
+    }
+    ensureProgressDraft(channelId) {
+        let draft = this.progressDrafts.get(channelId);
+        if (!draft) {
+            draft = new DraftMessageController(this.borgee, channelId, () => !this.controlPlaneClosed);
+            this.progressDrafts.set(channelId, draft);
+        }
+        return draft;
+    }
+    async ensureSelfAgentId() {
+        if (this.selfAgentId) {
+            return this.selfAgentId;
+        }
+        if (!this.selfAgentIdPromise) {
+            this.selfAgentIdPromise = this.borgee.getMe().then((me) => {
+                this.selfAgentId = me.id;
+                return me.id;
+            }).catch((error) => {
+                this.selfAgentIdPromise = null;
+                throw error;
+            });
+        }
+        return this.selfAgentIdPromise;
     }
 }

package/dist/chat/chat-control-plane.d.ts

@@ -1,7 +1,10 @@
-import type { ChannelMessageEvent, MeResponseUser } from '../types.js';
+import type { ChannelMessageEvent, MeResponseUser, PostedMessage } from '../types.js';
 export interface ChatControlPlane {
-    connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
+    connect(onMessage: (message: ChannelMessageEvent) => void | Promise<void>): Promise<void>;
     close(): Promise<void>;
-    postMessage(channelId: string, content: string): Promise<void>;
+    postMessage(channelId: string, content: string): Promise<PostedMessage>;
+    editMessage(messageId: string, content: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    startTyping(channelId: string): () => void;
     getMe(): Promise<MeResponseUser>;
 }

package/dist/chat/sdk-chat-control-plane.d.ts

@@ -1,8 +1,9 @@
 import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent } from '@borgee/plugin-sdk';
-import type { ChannelMessageEvent, MeResponseUser } from '../types.js';
+import type { ChannelMessageEvent, MeResponseUser, PostedMessage } from '../types.js';
 import type { ChatControlPlane } from './chat-control-plane.js';
-type PluginClientLike = Pick<BorgeePluginClient, 'close' | 'connect' | 'getMe' | 'on' | 'sendMessage'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'deleteMessage' | 'editMessage' | 'getMe' | 'on' | 'sendMessage' | 'startTyping'>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
+type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'cursorStore' | 'pluginId'>;
 /**
  * Thin adapter over `@borgee/plugin-sdk` (the same BPP/`/ws/plugin` SDK used by
  * the OpenClaw plugin) that implements the minimal `ChatControlPlane` surface
@@ -10,13 +11,16 @@ type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
  */
 export declare class SdkChatControlPlane implements ChatControlPlane {
     private readonly client;
-    private pendingMessages;
     private unsubscribe;
     private connected;
-    constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, pluginId?: string);
-    connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
+    private me;
+    constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, options?: SdkChatControlPlaneOptions);
+    connect(onMessage: (message: ChannelMessageEvent) => void | Promise<void>): Promise<void>;
     close(): Promise<void>;
-    postMessage(channelId: string, content: string): Promise<void>;
+    postMessage(channelId: string, content: string): Promise<PostedMessage>;
+    editMessage(messageId: string, content: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    startTyping(channelId: string): () => void;
     getMe(): Promise<MeResponseUser>;
 }
 export declare function mapInboundToChannelMessage(event: InboundMessageEvent): ChannelMessageEvent;

package/dist/chat/sdk-chat-control-plane.js

@@ -6,53 +6,63 @@ import { createBorgeePlugin, } from '@borgee/plugin-sdk';
  */
 export class SdkChatControlPlane {
     client;
-    pendingMessages = [];
     unsubscribe = null;
     connected = false;
-    constructor(baseUrl, apiKey, createClient = createBorgeePlugin, pluginId) {
-        this.client = createClient({ baseUrl, apiKey, pluginId });
+    me = null;
+    constructor(baseUrl, apiKey, createClient = createBorgeePlugin, options = {}) {
+        this.client = createClient({ baseUrl, apiKey, ...options });
     }
     async connect(onMessage) {
-        this.unsubscribe = this.client.on('message', (event) => {
-            const message = mapInboundToChannelMessage(event);
-            if (!this.connected) {
-                this.pendingMessages.push(message);
-                return;
-            }
-            onMessage(message);
+        this.unsubscribe = this.client.on('message', async (event) => {
+            await onMessage(mapInboundToChannelMessage(event));
         });
         try {
-            await this.client.connect();
+            // The SDK resolves connect after session.resume_ack, before every replay
+            // frame necessarily runs. Mark the consumer ready first so replay ACKs
+            // wait for the real handler instead of acknowledging an in-memory buffer.
             this.connected = true;
-            for (const message of this.pendingMessages) {
-                onMessage(message);
+            await this.client.connect();
+            if (this.client.agentId) {
+                this.me = { id: this.client.agentId };
             }
-            this.pendingMessages = [];
         }
         catch (error) {
+            this.connected = false;
             this.unsubscribe?.();
             this.unsubscribe = null;
-            this.pendingMessages = [];
             throw error;
         }
     }
     async close() {
         this.connected = false;
-        this.pendingMessages = [];
         this.unsubscribe?.();
         this.unsubscribe = null;
         await this.client.close();
     }
     async postMessage(channelId, content) {
-        await this.client.sendMessage({ channelId, body: content });
+        const sent = await this.client.sendMessage({ channelId, body: content });
+        return { messageId: sent.messageId };
+    }
+    async editMessage(messageId, content) {
+        await this.client.editMessage({ messageId, body: content });
+    }
+    async deleteMessage(messageId) {
+        await this.client.deleteMessage({ messageId });
+    }
+    startTyping(channelId) {
+        return this.client.startTyping(channelId);
     }
     async getMe() {
+        if (this.me) {
+            return this.me;
+        }
         const me = await this.client.getMe();
-        return {
+        this.me = {
             id: me.id,
             display_name: me.displayName,
             role: me.kind,
         };
+        return this.me;
     }
 }
 export function mapInboundToChannelMessage(event) {

package/dist/config.js

@@ -1,3 +1,4 @@
+import { resolveSingleAgentStateRoot } from './state-paths.js';
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
 export const MAX_COPILOT_SESSION_TTL_MINUTES = MAX_TIMER_DELAY_MS / 60_000;
 export const DEFAULT_COPILOT_SESSION_TTL_MINUTES = 2 * 24 * 60;
@@ -74,6 +75,7 @@ export function loadConfigFromEnv(env = process.env) {
     const provider = resolveProvider(envOr('RUNTIME_PROVIDER', 'claude', env), 'Unsupported RUNTIME_PROVIDER');
     return {
         borgeeBaseUrl: requireEnv('BORGEE_BASE_URL', env),
+        stateRootDir: resolveSingleAgentStateRoot(env),
         ...resolveProviderCommandConfig({
             claudeCommand: envOr('CLAUDE_COMMAND', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeCommand, env),
             claudeArgs: parseArgs(envOr('CLAUDE_ARGS', DEFAULT_PROVIDER_COMMAND_CONFIG.claudeArgs.join(' '), env)),

package/dist/durable-cursor-store.d.ts

@@ -0,0 +1,5 @@
+import { type CursorStore } from '@borgee/plugin-sdk';
+export interface DurableCursorStoreOptions {
+    stateRootDir: string;
+}
+export declare function createDurableCursorStore(options: DurableCursorStoreOptions): CursorStore;

package/dist/durable-cursor-store.js

@@ -0,0 +1,7 @@
+import { FileCursorStore } from '@borgee/plugin-sdk';
+import { resolveAgentCursorPath } from './state-paths.js';
+export function createDurableCursorStore(options) {
+    return new FileCursorStore({
+        resolvePath: (agentId) => resolveAgentCursorPath(options.stateRootDir, agentId),
+    });
+}

package/dist/local-config.js

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parseDocument, stringify } from 'yaml';
 import { optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { resolveLocalConfigAgentStateRoot } from './state-paths.js';
 const SUPPORTED_CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
 export const DEFAULT_LOCAL_HOST_CONFIG_FILENAME = 'agents-host.yaml';
 export const DEFAULT_LOCAL_AGENTS_DIRNAME = 'agents';
@@ -131,6 +132,9 @@ function parseHostConfigFile(hostConfigPath, value) {
 function toGeneratedAgentConfigFilename(key) {
     return `${encodeURIComponent(key)}.yaml`;
 }
+function toCaseInsensitiveFilesystemIdentity(path) {
+    return path.toLowerCase();
+}
 function parseGenerateHostConfigFile(sourceLabel, value) {
     if (value.agentsDir !== undefined) {
         throw new Error(`Invalid generate-config host spec in ${sourceLabel}: agentsDir is not supported; generate-config always writes the canonical default layout`);
@@ -573,13 +577,14 @@ function renderAgentConfigYaml(agent) {
     }
     return stringify(config);
 }
-function buildManagedAgentSnapshot(host, sourcePath, agent) {
+function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
     const providerConfig = resolveProviderCommandConfig({
         ...host.defaults,
         ...parseProviderCommandOverrides(agent, `agent config ${sourcePath}`),
     });
     const config = {
         borgeeBaseUrl: host.borgeeBaseUrl,
+        stateRootDir: resolveLocalConfigAgentStateRoot(stateRootBaseDir, agent.key),
         ...providerConfig,
         agent: {
             agentApiKey: agent.apiKey,
@@ -610,6 +615,7 @@ export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {
         const resolvedHostConfigDir = dirname(resolvedHostConfigPath);
         const hostConfigRecord = await loadParsedDocument(fileSystem, resolvedHostConfigPath, 'host config');
         const hostConfig = parseHostConfigFile(absoluteHostConfigPath, hostConfigRecord);
+        const stateRootBaseDir = managedGeneration.managedRootPath ?? hostConfigDir;
         const agentsDir = toAgentsDir(absoluteHostConfigPath, hostConfig.agentsDir);
         const resolvedAgentsDir = resolve(fileSystem.realPath
             ? await fileSystem.realPath(toAgentsDir(resolvedHostConfigPath, hostConfig.agentsDir))
@@ -643,7 +649,7 @@ export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {
             resolvedAgentsDir,
             agents: parsedAgents
                 .filter((entry) => entry.config.enabled !== false)
-                .map((entry) => buildManagedAgentSnapshot(hostConfig, entry.sourcePath, entry.config)),
+                .map((entry) => buildManagedAgentSnapshot(hostConfig, stateRootBaseDir, entry.sourcePath, entry.config)),
         };
     }
     finally {

package/dist/providers/claude/adapter.d.ts

@@ -1,8 +1,9 @@
 import type { ProviderAdapter } from '../provider-adapter.js';
-import type { ProviderInput, ProviderReply } from '../../types.js';
+import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { ClaudeCliClient } from './cli-client.js';
 export declare class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
     constructor(cli: ClaudeCliClient);
-    generateReply(input: ProviderInput): Promise<ProviderReply>;
+    generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -4,7 +4,7 @@ export class ClaudeProviderAdapter {
     constructor(cli) {
         this.cli = cli;
     }
-    async generateReply(input) {
+    async generateReply(input, options) {
         const prompt = buildPrompt({
             agentName: input.agentName,
             provider: input.provider,
@@ -12,7 +12,12 @@ export class ClaudeProviderAdapter {
             incomingAuthorId: input.incomingAuthorId,
             incomingContent: input.incomingContent,
         });
-        const text = await this.cli.generateReply(input.channelId, prompt);
+        const text = await this.cli.generateReply(input.channelId, prompt, {
+            onProgress: options?.onProgress,
+        });
         return { text };
     }
+    async dispose() {
+        await this.cli.dispose();
+    }
 }

package/dist/providers/claude/cli-client.d.ts

@@ -1,21 +1,44 @@
+import spawn from 'cross-spawn';
+import type { ProviderGenerateOptions } from '../../types.js';
+import type { ClaudeChannelSessionStore } from './session-store.js';
+interface ClaudeCliRuntime {
+    spawn: typeof spawn;
+}
 /**
  * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
  * native per-channel session continuity.
  *
- * Verified CLI behavior (`claude --help`):
- * - `--session-id <uuid>` starts a *new* conversation pinned to that UUID.
- * - `-r/--resume <uuid>` resumes an *existing* conversation by session ID.
- * These are documented as distinct operations, so this client tracks which
- * channels have already started a session and switches from `--session-id`
- * (first turn) to `--resume` (every turn after) accordingly. No message
- * history is kept on our side — the CLI's own session storage is the single
- * source of truth for conversation memory.
+ * Claude session memory remains entirely inside the Claude CLI. This client
+ * only pins one native session id per Borgee channel and serializes turns per
+ * channel so `--resume` is never called concurrently for the same session.
  */
 export declare class ClaudeCliClient {
     private readonly command;
     private readonly args;
-    private readonly sessionIdsByChannel;
-    constructor(command: string, args: string[]);
-    generateReply(channelId: string, prompt: string): Promise<string>;
+    private readonly sessionStore?;
+    private readonly resolveSessionStoreAgentId;
+    private readonly runtime;
+    private readonly channels;
+    private readonly persistedSessions;
+    private loadedSessionStoreAgentId;
+    private stopped;
+    private sessionStoreLoadPromise;
+    private sessionStoreWriteQueue;
+    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined);
+    generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
+    dispose(): Promise<void>;
+    private getOrCreateChannelState;
+    private processChannelQueue;
+    private runTurn;
+    private runTurnAttempt;
+    private currentSessionStoreAgentId;
+    private ensureSessionStoreLoaded;
+    private hydrateChannelState;
+    private persistSession;
+    private persistSessionBestEffort;
+    private resetPersistedSession;
+    private resetPersistedSessionBestEffort;
+    private enqueueSessionStoreWrite;
     private run;
 }
+export {};