@borgee/agents-host 0.2.0 → 0.2.1

package/README.md

@@ -315,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

@@ -27,6 +27,7 @@ export declare class AgentsHost {
     private readonly progressChannelQueues;
     private readonly progressDrafts;
     private selfAgentId;
+    private selfAgentIdPromise;
     private started;
     private controlPlaneClosed;
     constructor(config: AgentsHostConfig, deps?: {
@@ -39,4 +40,5 @@ export declare class AgentsHost {
     private trackActiveTurn;
     private enqueueProgressChannelTurn;
     private ensureProgressDraft;
+    private ensureSelfAgentId;
 }

package/dist/agents-host.js

@@ -1,6 +1,13 @@
+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;
 }
@@ -128,29 +135,37 @@ export class AgentsHost {
     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) => {
             if (!this.started) {
                 return;
@@ -159,11 +174,11 @@ export class AgentsHost {
                 ? 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,
         });
@@ -187,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();
@@ -276,4 +292,19 @@ export class AgentsHost {
         }
         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,6 +1,6 @@
 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<PostedMessage>;
     editMessage(messageId: string, content: string): Promise<void>;

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

@@ -3,6 +3,7 @@ import type { ChannelMessageEvent, MeResponseUser, PostedMessage } from '../type
 import type { ChatControlPlane } from './chat-control-plane.js';
 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,12 +11,11 @@ type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
  */
 export declare class SdkChatControlPlane implements ChatControlPlane {
     private readonly client;
-    private pendingMessages;
     private unsubscribe;
     private connected;
     private me;
-    constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, pluginId?: string);
-    connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
+    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<PostedMessage>;
     editMessage(messageId: string, content: string): Promise<void>;

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

@@ -6,43 +6,35 @@ import { createBorgeePlugin, } from '@borgee/plugin-sdk';
  */
 export class SdkChatControlPlane {
     client;
-    pendingMessages = [];
     unsubscribe = null;
     connected = false;
     me = null;
-    constructor(baseUrl, apiKey, createClient = createBorgeePlugin, pluginId) {
-        this.client = createClient({ baseUrl, apiKey, pluginId });
+    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;
+            await this.client.connect();
             if (this.client.agentId) {
                 this.me = { id: this.client.agentId };
             }
-            for (const message of this.pendingMessages) {
-                onMessage(message);
-            }
-            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();

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/cli-client.d.ts

@@ -1,5 +1,6 @@
 import spawn from 'cross-spawn';
 import type { ProviderGenerateOptions } from '../../types.js';
+import type { ClaudeChannelSessionStore } from './session-store.js';
 interface ClaudeCliRuntime {
     spawn: typeof spawn;
 }
@@ -14,15 +15,30 @@ interface ClaudeCliRuntime {
 export declare class ClaudeCliClient {
     private readonly command;
     private readonly args;
+    private readonly sessionStore?;
+    private readonly resolveSessionStoreAgentId;
     private readonly runtime;
     private readonly channels;
+    private readonly persistedSessions;
+    private loadedSessionStoreAgentId;
     private stopped;
-    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>);
+    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 {};

package/dist/providers/claude/cli-client.js

@@ -4,6 +4,10 @@ const DEFAULT_RUNTIME = {
     spawn,
 };
 const STREAM_JSON_ARGS = ['--verbose', '--output-format', 'stream-json', '--include-partial-messages'];
+function isStaleResumeFailure(error) {
+    const message = normalizeError(error).message.toLowerCase();
+    return message.includes('session not found') || message.includes('cannot resume');
+}
 function normalizeError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
@@ -157,12 +161,20 @@ class ClaudeStreamCollector {
 export class ClaudeCliClient {
     command;
     args;
+    sessionStore;
+    resolveSessionStoreAgentId;
     runtime;
     channels = new Map();
+    persistedSessions = new Map();
+    loadedSessionStoreAgentId = null;
     stopped = false;
-    constructor(command, args, runtimeOverrides = {}) {
+    sessionStoreLoadPromise = null;
+    sessionStoreWriteQueue = Promise.resolve();
+    constructor(command, args, runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined) {
         this.command = command;
         this.args = args;
+        this.sessionStore = sessionStore;
+        this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
     }
     async generateReply(channelId, prompt, options) {
@@ -195,6 +207,7 @@ export class ClaudeCliClient {
             state = {
                 processing: false,
                 queue: [],
+                sessionHydrated: false,
                 sessionEstablished: false,
             };
             this.channels.set(channelId, state);
@@ -209,13 +222,26 @@ export class ClaudeCliClient {
         void (async () => {
             try {
                 while (!this.stopped) {
+                    const queuedTurn = state.queue[0];
+                    if (!queuedTurn) {
+                        return;
+                    }
+                    try {
+                        if (await this.ensureSessionStoreLoaded()) {
+                            this.hydrateChannelState(channelId, state);
+                        }
+                    }
+                    catch (error) {
+                        state.queue.shift()?.reject(error);
+                        continue;
+                    }
                     const turn = state.queue.shift();
                     if (!turn) {
                         return;
                     }
                     state.activeTurn = turn;
                     try {
-                        const text = await this.runTurn(state, turn);
+                        const text = await this.runTurn(channelId, state, turn);
                         turn.resolve(text);
                     }
                     catch (error) {
@@ -234,16 +260,138 @@ export class ClaudeCliClient {
             }
         })();
     }
-    async runTurn(state, turn) {
+    async runTurn(channelId, state, turn) {
+        return this.runTurnAttempt(channelId, state, turn, true);
+    }
+    async runTurnAttempt(channelId, state, turn, allowFreshRetryAfterStaleResume) {
         if (this.stopped) {
             throw new Error('Claude CLI backend stopped');
         }
         const sessionId = state.sessionEstablished ? state.sessionId : randomUUID();
         const sessionArgs = state.sessionEstablished ? ['--resume', sessionId] : ['--session-id', sessionId];
-        const text = await this.run(state, [...this.args, ...sessionArgs, ...STREAM_JSON_ARGS], turn.prompt, turn.options);
-        state.sessionId = sessionId;
+        try {
+            const text = await this.run(state, [...this.args, ...sessionArgs, ...STREAM_JSON_ARGS], turn.prompt, turn.options);
+            state.sessionId = sessionId;
+            state.sessionEstablished = true;
+            await this.persistSessionBestEffort(channelId, sessionId);
+            return text;
+        }
+        catch (error) {
+            if (state.sessionEstablished && isStaleResumeFailure(error)) {
+                await this.resetPersistedSessionBestEffort(channelId, state);
+                if (allowFreshRetryAfterStaleResume) {
+                    return this.runTurnAttempt(channelId, state, turn, false);
+                }
+            }
+            throw error;
+        }
+    }
+    currentSessionStoreAgentId() {
+        const agentId = this.resolveSessionStoreAgentId()?.trim();
+        return agentId && agentId.length > 0 ? agentId : null;
+    }
+    async ensureSessionStoreLoaded() {
+        if (!this.sessionStore) {
+            return true;
+        }
+        const agentId = this.currentSessionStoreAgentId();
+        if (!agentId) {
+            return false;
+        }
+        if (this.loadedSessionStoreAgentId && this.loadedSessionStoreAgentId !== agentId) {
+            this.loadedSessionStoreAgentId = null;
+            this.sessionStoreLoadPromise = null;
+            this.persistedSessions.clear();
+            for (const state of this.channels.values()) {
+                state.sessionHydrated = false;
+            }
+        }
+        if (!this.sessionStoreLoadPromise) {
+            this.sessionStoreLoadPromise = (async () => {
+                try {
+                    const stored = await this.sessionStore.load(agentId);
+                    this.persistedSessions.clear();
+                    for (const [channelId, sessionId] of Object.entries(stored)) {
+                        this.persistedSessions.set(channelId, sessionId);
+                    }
+                    this.loadedSessionStoreAgentId = agentId;
+                }
+                catch (error) {
+                    this.sessionStoreLoadPromise = null;
+                    throw error;
+                }
+            })();
+        }
+        await this.sessionStoreLoadPromise;
+        return true;
+    }
+    hydrateChannelState(channelId, state) {
+        if (state.sessionHydrated) {
+            return;
+        }
+        state.sessionHydrated = true;
+        const persistedSessionId = this.persistedSessions.get(channelId);
+        if (!persistedSessionId) {
+            return;
+        }
+        state.sessionId = persistedSessionId;
         state.sessionEstablished = true;
-        return text;
+    }
+    async persistSession(channelId, sessionId) {
+        if (!this.sessionStore || !this.loadedSessionStoreAgentId) {
+            return;
+        }
+        await this.enqueueSessionStoreWrite(async () => {
+            if (this.persistedSessions.get(channelId) === sessionId) {
+                return;
+            }
+            this.persistedSessions.set(channelId, sessionId);
+            await this.sessionStore.save(this.loadedSessionStoreAgentId, Object.fromEntries(this.persistedSessions));
+        });
+    }
+    async persistSessionBestEffort(channelId, sessionId) {
+        try {
+            await this.persistSession(channelId, sessionId);
+        }
+        catch (error) {
+            console.error('[agents-host] failed to persist Claude session map; keeping reply delivery', {
+                agentId: this.loadedSessionStoreAgentId,
+                channelId,
+                sessionId,
+                error,
+            });
+        }
+    }
+    async resetPersistedSession(channelId, state) {
+        state.sessionEstablished = false;
+        state.sessionId = undefined;
+        if (!this.sessionStore || !this.loadedSessionStoreAgentId) {
+            return;
+        }
+        await this.enqueueSessionStoreWrite(async () => {
+            if (!this.persistedSessions.has(channelId)) {
+                return;
+            }
+            this.persistedSessions.delete(channelId);
+            await this.sessionStore.save(this.loadedSessionStoreAgentId, Object.fromEntries(this.persistedSessions));
+        });
+    }
+    async resetPersistedSessionBestEffort(channelId, state) {
+        try {
+            await this.resetPersistedSession(channelId, state);
+        }
+        catch (error) {
+            console.error('[agents-host] failed to clear stale Claude session map; retrying in-memory only', {
+                agentId: this.loadedSessionStoreAgentId,
+                channelId,
+                error,
+            });
+        }
+    }
+    async enqueueSessionStoreWrite(writeOperation) {
+        const queuedWrite = this.sessionStoreWriteQueue.then(writeOperation);
+        this.sessionStoreWriteQueue = queuedWrite.catch(() => undefined);
+        await queuedWrite;
     }
     async run(state, args, prompt, options) {
         return new Promise((resolve, reject) => {

package/dist/providers/claude/session-store.d.ts

@@ -0,0 +1,14 @@
+export interface ClaudeChannelSessionStore {
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}
+export interface FileClaudeChannelSessionStoreOptions {
+    resolvePath(agentId: string): string;
+}
+export declare class FileClaudeChannelSessionStore implements ClaudeChannelSessionStore {
+    private readonly options;
+    constructor(options: FileClaudeChannelSessionStoreOptions);
+    private loadFromPath;
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}

package/dist/providers/claude/session-store.js

@@ -0,0 +1,103 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+async function syncDirectory(path) {
+    const directoryHandle = await open(path, 'r');
+    try {
+        await directoryHandle.sync();
+    }
+    finally {
+        await directoryHandle.close();
+    }
+}
+function normalizePersistedSessions(raw, filePath) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new Error(`invalid Claude session file: ${filePath}`);
+    }
+    const entries = Object.entries(raw);
+    const sessions = {};
+    for (const [channelId, sessionId] of entries) {
+        if (typeof sessionId !== 'string' || sessionId.trim().length === 0) {
+            throw new Error(`invalid Claude session file: ${filePath}`);
+        }
+        sessions[channelId] = sessionId;
+    }
+    return sessions;
+}
+export class FileClaudeChannelSessionStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async loadFromPath(filePath) {
+        let raw;
+        try {
+            raw = await readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            throw error;
+        }
+        return normalizePersistedSessions(JSON.parse(raw), filePath);
+    }
+    async load(agentId) {
+        const filePath = this.options.resolvePath(agentId);
+        try {
+            return await this.loadFromPath(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            return {};
+        }
+    }
+    async save(agentId, sessions) {
+        const filePath = this.options.resolvePath(agentId);
+        const parentPath = dirname(filePath);
+        await mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0) {
+            try {
+                await unlink(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                return;
+            }
+            await syncDirectory(parentPath);
+            return;
+        }
+        const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryHandle;
+        try {
+            temporaryHandle = await open(temporaryPath, 'wx', 0o600);
+            await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
+                encoding: 'utf8',
+            });
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            await rename(temporaryPath, filePath);
+            await syncDirectory(parentPath);
+        }
+        catch (error) {
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                }
+                catch {
+                    // Preserve the original durability failure.
+                }
+            }
+            try {
+                await unlink(temporaryPath);
+            }
+            catch {
+                // Cleanup is best effort.
+            }
+            throw error;
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
 import type { ProviderGenerateOptions } from '../../types.js';
+import type { CopilotChannelSessionStore } from './session-store.js';
 interface CopilotAcpRuntime {
     spawn: typeof spawn;
     client: typeof client;
@@ -22,8 +23,11 @@ interface CopilotAcpRuntime {
  */
 export declare class CopilotCliClient {
     private readonly command;
+    private readonly sessionStore?;
+    private readonly resolveSessionStoreAgentId;
     private readonly runtime;
     private readonly channels;
+    private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
     private readonly pendingSessionCloses;
@@ -38,7 +42,11 @@ export declare class CopilotCliClient {
     private fatalError;
     private disposing;
     private backendClosed;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>);
+    private loadedSessionStoreAgentId;
+    private sessionStoreLoadPromise;
+    private sessionStoreWriteQueue;
+    private sessionCapabilities;
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined);
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
     private ensureStarted;
@@ -46,6 +54,10 @@ export declare class CopilotCliClient {
     private getOrCreateChannelState;
     private processChannelQueue;
     private getOrCreateSession;
+    private startFreshSession;
+    private restoreOrCreateSession;
+    private restoreSession;
+    private clearBufferedSessionReplay;
     private runTurn;
     private raceWithFatal;
     private failAll;
@@ -54,6 +66,12 @@ export declare class CopilotCliClient {
     private rejectQueuedTurnsAfterSessionTaint;
     private clearIdleTimer;
     private reconcileIdleChannelState;
+    private ensureSessionStoreLoaded;
+    private persistSession;
+    private persistSessionBestEffort;
+    private clearPersistedSession;
+    private clearPersistedSessionBestEffort;
+    private flushSessionStore;
     private evictIdleChannel;
     private shutdownBackend;
     private waitForPendingSessionStarts;

package/dist/providers/copilot/cli-client.js

@@ -17,6 +17,10 @@ const DEFAULT_RUNTIME = {
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
 };
+const DEFAULT_SESSION_CAPABILITIES = {
+    loadSession: false,
+    resumeSession: false,
+};
 function hasVisibleText(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
@@ -127,6 +131,24 @@ function createDeferredTurn(prompt, options) {
 function normalizeError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
+function asObject(value) {
+    return typeof value === 'object' && value !== null ? value : null;
+}
+function isStaleRestoreFailure(error) {
+    const message = normalizeError(error).message.toLowerCase();
+    return message.includes('session not found')
+        || message.includes('unknown session')
+        || message.includes('cannot resume')
+        || message.includes('not found');
+}
+function readSessionCapabilities(response) {
+    const agentCapabilities = asObject(asObject(response)?.agentCapabilities);
+    const sessionCapabilities = asObject(agentCapabilities?.sessionCapabilities ?? agentCapabilities?.session);
+    return {
+        loadSession: agentCapabilities?.loadSession === true,
+        resumeSession: asObject(sessionCapabilities?.resume) !== null,
+    };
+}
 function markSessionTainted(error) {
     const normalized = normalizeError(error);
     SESSION_TAINTED_ERRORS.add(normalized);
@@ -153,8 +175,11 @@ function selectPermissionOption(options) {
  */
 export class CopilotCliClient {
     command;
+    sessionStore;
+    resolveSessionStoreAgentId;
     runtime;
     channels = new Map();
+    persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
     pendingSessionCloses = new Set();
@@ -169,8 +194,14 @@ export class CopilotCliClient {
     fatalError = null;
     disposing = false;
     backendClosed = false;
-    constructor(command, _ignoredArgs = [], runtimeOverrides = {}) {
+    loadedSessionStoreAgentId = null;
+    sessionStoreLoadPromise = null;
+    sessionStoreWriteQueue = Promise.resolve();
+    sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined) {
         this.command = command;
+        this.sessionStore = sessionStore;
+        this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
         this.fatalPromise = new Promise((_, reject) => {
             this.rejectFatalPromise = reject;
@@ -248,7 +279,7 @@ export class CopilotCliClient {
             }
         });
         try {
-            await connection.agent.request(this.runtime.methods.agent.initialize, {
+            const initializeResponse = await connection.agent.request(this.runtime.methods.agent.initialize, {
                 protocolVersion: this.runtime.protocolVersion,
                 clientCapabilities: {},
                 clientInfo: {
@@ -256,6 +287,7 @@ export class CopilotCliClient {
                     version: '0.1.6',
                 },
             });
+            this.sessionCapabilities = readSessionCapabilities(initializeResponse);
         }
         catch (error) {
             const normalized = new Error(`Copilot ACP initialize failed: ${normalizeError(error).message}`);
@@ -328,7 +360,11 @@ export class CopilotCliClient {
         if (!this.connection) {
             throw new Error('Copilot ACP connection is not available');
         }
-        const sessionPromise = this.connection.agent.buildSession(this.runtime.cwd).start();
+        await this.ensureSessionStoreLoaded();
+        const persistedSessionId = this.persistedSessions.get(channelId);
+        const sessionPromise = persistedSessionId
+            ? this.restoreOrCreateSession(channelId, persistedSessionId)
+            : this.startFreshSession(channelId);
         this.pendingSessionStarts.add(sessionPromise);
         state.sessionPromise = sessionPromise;
         let sessionAdopted = false;
@@ -363,6 +399,69 @@ export class CopilotCliClient {
             }
         }
     }
+    async startFreshSession(channelId) {
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+        const session = await this.connection.agent.buildSession(this.runtime.cwd).start();
+        await this.persistSessionBestEffort(channelId, session.sessionId);
+        return session;
+    }
+    async restoreOrCreateSession(channelId, sessionId) {
+        if (!this.sessionCapabilities.resumeSession && !this.sessionCapabilities.loadSession) {
+            return this.startFreshSession(channelId);
+        }
+        try {
+            return await this.restoreSession(sessionId);
+        }
+        catch (error) {
+            if (!isStaleRestoreFailure(error)) {
+                throw normalizeError(error);
+            }
+            await this.clearPersistedSessionBestEffort(channelId);
+            return this.startFreshSession(channelId);
+        }
+    }
+    async restoreSession(sessionId) {
+        if (!this.connection) {
+            throw new Error('Copilot ACP connection is not available');
+        }
+        const agent = this.connection.agent;
+        if (typeof agent.attachSession !== 'function') {
+            throw new Error('Copilot ACP SDK does not expose session attachment helpers');
+        }
+        const session = agent.attachSession({ sessionId });
+        try {
+            if (this.sessionCapabilities.resumeSession) {
+                await this.connection.agent.request(this.runtime.methods.agent.session.resume, {
+                    sessionId,
+                    cwd: this.runtime.cwd,
+                    mcpServers: [],
+                });
+                return session;
+            }
+            if (this.sessionCapabilities.loadSession) {
+                await this.connection.agent.request(this.runtime.methods.agent.session.load, {
+                    sessionId,
+                    cwd: this.runtime.cwd,
+                    mcpServers: [],
+                });
+                this.clearBufferedSessionReplay(session);
+                return session;
+            }
+            throw new Error('Copilot ACP agent does not advertise session restore capabilities');
+        }
+        catch (error) {
+            session.dispose();
+            throw normalizeError(error);
+        }
+    }
+    clearBufferedSessionReplay(session) {
+        const updates = session.updates;
+        if (updates && Array.isArray(updates.values)) {
+            updates.values = [];
+        }
+    }
     async runTurn(session, prompt, options) {
         const promptPromise = this.raceWithFatal(session.prompt(prompt));
         const promptFailure = new Promise((_, reject) => {
@@ -438,6 +537,12 @@ export class CopilotCliClient {
             state.session = undefined;
         }
         this.closeSession(session);
+        for (const [channelId, candidate] of this.channels.entries()) {
+            if (candidate === state) {
+                void this.clearPersistedSessionBestEffort(channelId);
+                break;
+            }
+        }
     }
     closeSession(session) {
         if (this.closingSessions.has(session)) {
@@ -507,6 +612,78 @@ export class CopilotCliClient {
             this.evictIdleChannel(channelId, state, generation);
         }, this.runtime.idleSessionTtlMs);
     }
+    async ensureSessionStoreLoaded() {
+        if (!this.sessionStore) {
+            return;
+        }
+        const agentId = this.resolveSessionStoreAgentId()?.trim();
+        if (!agentId) {
+            return;
+        }
+        if (this.loadedSessionStoreAgentId === agentId) {
+            return;
+        }
+        if (!this.sessionStoreLoadPromise) {
+            this.sessionStoreLoadPromise = (async () => {
+                const loaded = await this.sessionStore.load(agentId);
+                this.persistedSessions.clear();
+                for (const [channelId, sessionId] of Object.entries(loaded)) {
+                    this.persistedSessions.set(channelId, sessionId);
+                }
+                this.loadedSessionStoreAgentId = agentId;
+            })().finally(() => {
+                this.sessionStoreLoadPromise = null;
+            });
+        }
+        await this.sessionStoreLoadPromise;
+    }
+    async persistSession(channelId, sessionId) {
+        await this.ensureSessionStoreLoaded();
+        this.persistedSessions.set(channelId, sessionId);
+        await this.flushSessionStore();
+    }
+    async persistSessionBestEffort(channelId, sessionId) {
+        try {
+            await this.persistSession(channelId, sessionId);
+        }
+        catch (error) {
+            console.error('[agents-host] failed to persist Copilot session map; keeping reply delivery', {
+                agentId: this.loadedSessionStoreAgentId,
+                channelId,
+                sessionId,
+                error,
+            });
+        }
+    }
+    async clearPersistedSession(channelId) {
+        await this.ensureSessionStoreLoaded();
+        if (!this.persistedSessions.delete(channelId)) {
+            return;
+        }
+        await this.flushSessionStore();
+    }
+    async clearPersistedSessionBestEffort(channelId) {
+        try {
+            await this.clearPersistedSession(channelId);
+        }
+        catch (error) {
+            console.error('[agents-host] failed to clear Copilot session map; retrying in-memory only', {
+                agentId: this.loadedSessionStoreAgentId,
+                channelId,
+                error,
+            });
+        }
+    }
+    async flushSessionStore() {
+        if (!this.sessionStore || !this.loadedSessionStoreAgentId) {
+            return;
+        }
+        const agentId = this.loadedSessionStoreAgentId;
+        const snapshot = Object.fromEntries(this.persistedSessions.entries());
+        const write = this.sessionStoreWriteQueue.then(() => this.sessionStore.save(agentId, snapshot));
+        this.sessionStoreWriteQueue = write.catch(() => { });
+        await write;
+    }
     evictIdleChannel(channelId, state, generation) {
         if (this.disposing || this.fatalError || this.backendClosed) {
             return;

package/dist/providers/copilot/session-store.d.ts

@@ -0,0 +1,14 @@
+export interface CopilotChannelSessionStore {
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}
+export interface FileCopilotChannelSessionStoreOptions {
+    resolvePath(agentId: string): string;
+}
+export declare class FileCopilotChannelSessionStore implements CopilotChannelSessionStore {
+    private readonly options;
+    constructor(options: FileCopilotChannelSessionStoreOptions);
+    private loadFromPath;
+    load(agentId: string): Promise<Record<string, string>>;
+    save(agentId: string, sessions: Record<string, string>): Promise<void>;
+}

package/dist/providers/copilot/session-store.js

@@ -0,0 +1,97 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+async function syncDirectory(path) {
+    const directoryHandle = await open(path, 'r');
+    try {
+        await directoryHandle.sync();
+    }
+    finally {
+        await directoryHandle.close();
+    }
+}
+function normalizePersistedSessions(raw, filePath) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw new Error(`invalid Copilot session file: ${filePath}`);
+    }
+    const entries = Object.entries(raw);
+    const sessions = {};
+    for (const [channelId, sessionId] of entries) {
+        if (typeof sessionId !== 'string' || sessionId.trim().length === 0) {
+            throw new Error(`invalid Copilot session file: ${filePath}`);
+        }
+        sessions[channelId] = sessionId;
+    }
+    return sessions;
+}
+export class FileCopilotChannelSessionStore {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async loadFromPath(filePath) {
+        const raw = await readFile(filePath, 'utf8');
+        return normalizePersistedSessions(JSON.parse(raw), filePath);
+    }
+    async load(agentId) {
+        const filePath = this.options.resolvePath(agentId);
+        try {
+            return await this.loadFromPath(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            return {};
+        }
+    }
+    async save(agentId, sessions) {
+        const filePath = this.options.resolvePath(agentId);
+        const parentPath = dirname(filePath);
+        await mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0) {
+            try {
+                await unlink(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                return;
+            }
+            await syncDirectory(parentPath);
+            return;
+        }
+        const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryHandle;
+        try {
+            temporaryHandle = await open(temporaryPath, 'wx', 0o600);
+            await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
+                encoding: 'utf8',
+            });
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            await rename(temporaryPath, filePath);
+            await syncDirectory(parentPath);
+        }
+        catch (error) {
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                }
+                catch {
+                    // Preserve the original durability failure.
+                }
+            }
+            try {
+                await unlink(temporaryPath);
+            }
+            catch {
+                // Cleanup is best effort.
+            }
+            throw error;
+        }
+    }
+}

package/dist/providers/create-provider.js

@@ -1,17 +1,24 @@
 import { ClaudeCliClient } from './claude/cli-client.js';
 import { ClaudeProviderAdapter } from './claude/adapter.js';
+import { FileClaudeChannelSessionStore } from './claude/session-store.js';
 import { CopilotCliClient } from './copilot/cli-client.js';
 import { CopilotProviderAdapter } from './copilot/adapter.js';
+import { FileCopilotChannelSessionStore } from './copilot/session-store.js';
+import { resolveClaudeSessionMapPath, resolveCopilotSessionMapPath } from '../state-paths.js';
 export function createProvider(config) {
     switch (config.provider) {
         case 'claude': {
-            const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs);
+            const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs, {}, new FileClaudeChannelSessionStore({
+                resolvePath: (agentId) => resolveClaudeSessionMapPath(config.stateRootDir, agentId),
+            }), config.resolveStableAgentId);
             return new ClaudeProviderAdapter(cli);
         }
         case 'copilot': {
             const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
                 idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
-            });
+            }, new FileCopilotChannelSessionStore({
+                resolvePath: (agentId) => resolveCopilotSessionMapPath(config.stateRootDir, agentId),
+            }), config.resolveStableAgentId);
             return new CopilotProviderAdapter(cli);
         }
         default:

package/dist/state-paths.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveSingleAgentStateRoot(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
+export declare function resolveManagedStateRoot(rootPath: string): string;
+export declare function resolveLocalConfigAgentStateRoot(rootPath: string, agentKey: string): string;
+export declare function resolveAgentCursorPath(stateRootDir: string, agentId: string): string;
+export declare function resolveClaudeSessionMapPath(stateRootDir: string, agentId: string): string;
+export declare function resolveCopilotSessionMapPath(stateRootDir: string, agentId: string): string;

package/dist/state-paths.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+const SINGLE_AGENT_HOME_ROOT = '.borgee';
+const AGENTS_HOST_ROOT = 'agents-host';
+const SINGLE_AGENT_NAMESPACE = 'single-agent';
+const MANAGED_STATE_DIRNAME = '.state';
+const STATE_ROOT_LABEL_MAX_LENGTH = 48;
+function encodeSegment(value) {
+    return encodeURIComponent(value);
+}
+function sanitizeStateRootLabel(agentKey) {
+    const sanitized = encodeSegment(agentKey)
+        .toLowerCase()
+        .replace(/%/g, '-')
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, STATE_ROOT_LABEL_MAX_LENGTH);
+    return sanitized.length > 0 ? sanitized : 'agent';
+}
+function hashStateRootKey(agentKey) {
+    return createHash('sha256').update(agentKey).digest('hex').slice(0, 12);
+}
+export function resolveSingleAgentStateRoot(env = process.env, resolvedHomeDir = homedir()) {
+    const home = env.HOME?.trim() || resolvedHomeDir.trim();
+    if (!home) {
+        throw new Error('Unable to resolve a user home directory for agents-host state');
+    }
+    return join(home, SINGLE_AGENT_HOME_ROOT, AGENTS_HOST_ROOT, SINGLE_AGENT_NAMESPACE);
+}
+export function resolveManagedStateRoot(rootPath) {
+    return join(resolve(rootPath), MANAGED_STATE_DIRNAME);
+}
+export function resolveLocalConfigAgentStateRoot(rootPath, agentKey) {
+    return join(resolveManagedStateRoot(rootPath), `${sanitizeStateRootLabel(agentKey)}-${hashStateRootKey(agentKey)}`);
+}
+export function resolveAgentCursorPath(stateRootDir, agentId) {
+    return join(stateRootDir, `bpp-cursor-${encodeSegment(agentId)}.json`);
+}
+export function resolveClaudeSessionMapPath(stateRootDir, agentId) {
+    return join(stateRootDir, `claude-channel-sessions-${encodeSegment(agentId)}.json`);
+}
+export function resolveCopilotSessionMapPath(stateRootDir, agentId) {
+    return join(stateRootDir, `copilot-channel-sessions-${encodeSegment(agentId)}.json`);
+}

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface ProviderCommandConfig {
 }
 export interface ProviderRuntimeConfig extends ProviderCommandConfig {
     provider: ProviderKind;
+    stateRootDir: string;
+    resolveStableAgentId?: () => string | undefined;
 }
 export interface HostedAgentConfig {
     agentApiKey: string;
@@ -16,6 +18,7 @@ export interface HostedAgentConfig {
 }
 export interface AgentsHostConfig extends ProviderCommandConfig {
     borgeeBaseUrl: string;
+    stateRootDir: string;
     agent: HostedAgentConfig;
 }
 export interface LocalHostConfigFile {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -8,7 +8,7 @@
   "type": "module",
   "description": "Minimal local agents host: connects a local Claude/Copilot CLI to a Borgee agent over @borgee/plugin-sdk",
   "bin": {
-    "agents-host": "./dist/cli.js"
+    "agents-host": "dist/cli.js"
   },
   "files": [
     "dist",
@@ -20,19 +20,6 @@
     "directory": "packages/agents-host"
   },
   "license": "MIT",
-  "dependencies": {
-    "@agentclientprotocol/sdk": "^1.2.1",
-    "cross-spawn": "^7.0.6",
-    "yaml": "^2.8.1",
-    "@borgee/plugin-sdk": "0.1.2"
-  },
-  "devDependencies": {
-    "@types/cross-spawn": "^6.0.6",
-    "@types/node": "^24.3.0",
-    "tsx": "^4.20.5",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.5"
-  },
   "scripts": {
     "predev": "pnpm --filter @borgee/plugin-sdk build",
     "dev": "tsx src/index.ts",
@@ -46,5 +33,18 @@
     "pretest": "pnpm --filter @borgee/plugin-sdk build",
     "test": "vitest run --testTimeout=10000",
     "pretypecheck": "pnpm --filter @borgee/plugin-sdk build"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^1.2.1",
+    "@borgee/plugin-sdk": "0.1.4",
+    "cross-spawn": "^7.0.6",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.5"
   }
-}
+}