@borgee/agents-host 0.2.0 → 0.2.2

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

@@ -0,0 +1,156 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+const nodeFileSystem = {
+    async mkdir(path, options) {
+        await mkdir(path, options);
+    },
+    async openDirectory(path) {
+        return open(path, 'r');
+    },
+    async openFile(path, flags, mode) {
+        return open(path, flags, mode);
+    },
+    async readFile(path, encoding) {
+        return readFile(path, encoding);
+    },
+    async rename(from, to) {
+        await rename(from, to);
+    },
+    async unlink(path) {
+        await unlink(path);
+    },
+};
+function shouldIgnoreDirectorySyncError(platform, error) {
+    const code = error.code;
+    return platform === 'win32' && (code === 'EPERM' || code === 'EINVAL');
+}
+async function syncDirectory(path, fileSystem, platform) {
+    let directoryHandle;
+    try {
+        try {
+            directoryHandle = await fileSystem.openDirectory(path);
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+            return;
+        }
+        try {
+            await directoryHandle.sync();
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        if (directoryHandle) {
+            try {
+                await directoryHandle.close();
+            }
+            catch {
+                // Preserve the original directory durability failure.
+            }
+        }
+        throw error;
+    }
+    if (directoryHandle) {
+        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 (this.options.fileSystem ?? nodeFileSystem).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);
+        const fileSystem = this.options.fileSystem ?? nodeFileSystem;
+        const platform = this.options.platform ?? process.platform;
+        await fileSystem.mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0) {
+            try {
+                await fileSystem.unlink(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                return;
+            }
+            await syncDirectory(parentPath, fileSystem, platform);
+            return;
+        }
+        const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryHandle;
+        try {
+            temporaryHandle = await fileSystem.openFile(temporaryPath, 'wx', 0o600);
+            await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
+                encoding: 'utf8',
+            });
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            await fileSystem.rename(temporaryPath, filePath);
+            await syncDirectory(parentPath, fileSystem, platform);
+        }
+        catch (error) {
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                }
+                catch {
+                    // Preserve the original durability failure.
+                }
+            }
+            try {
+                await fileSystem.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,37 @@
+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;
+    fileSystem?: CopilotSessionStoreFileSystem;
+    platform?: NodeJS.Platform;
+}
+interface CopilotSessionStoreDirectoryHandle {
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+interface CopilotSessionStoreFileHandle extends CopilotSessionStoreDirectoryHandle {
+    writeFile(data: string, options: {
+        encoding: BufferEncoding;
+    }): Promise<void>;
+}
+interface CopilotSessionStoreFileSystem {
+    mkdir(path: string, options: {
+        recursive: true;
+        mode: number;
+    }): Promise<void>;
+    openDirectory(path: string): Promise<CopilotSessionStoreDirectoryHandle>;
+    openFile(path: string, flags: string, mode: number): Promise<CopilotSessionStoreFileHandle>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+}
+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>;
+}
+export {};

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

@@ -0,0 +1,150 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
+import { dirname } from 'node:path';
+const nodeFileSystem = {
+    async mkdir(path, options) {
+        await mkdir(path, options);
+    },
+    async openDirectory(path) {
+        return open(path, 'r');
+    },
+    async openFile(path, flags, mode) {
+        return open(path, flags, mode);
+    },
+    async readFile(path, encoding) {
+        return readFile(path, encoding);
+    },
+    async rename(from, to) {
+        await rename(from, to);
+    },
+    async unlink(path) {
+        await unlink(path);
+    },
+};
+function shouldIgnoreDirectorySyncError(platform, error) {
+    const code = error.code;
+    return platform === 'win32' && (code === 'EPERM' || code === 'EINVAL');
+}
+async function syncDirectory(path, fileSystem, platform) {
+    let directoryHandle;
+    try {
+        try {
+            directoryHandle = await fileSystem.openDirectory(path);
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+            return;
+        }
+        try {
+            await directoryHandle.sync();
+        }
+        catch (error) {
+            if (!shouldIgnoreDirectorySyncError(platform, error)) {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        if (directoryHandle) {
+            try {
+                await directoryHandle.close();
+            }
+            catch {
+                // Preserve the original directory durability failure.
+            }
+        }
+        throw error;
+    }
+    if (directoryHandle) {
+        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 (this.options.fileSystem ?? nodeFileSystem).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);
+        const fileSystem = this.options.fileSystem ?? nodeFileSystem;
+        const platform = this.options.platform ?? process.platform;
+        await fileSystem.mkdir(parentPath, { recursive: true, mode: 0o700 });
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0) {
+            try {
+                await fileSystem.unlink(filePath);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+                return;
+            }
+            await syncDirectory(parentPath, fileSystem, platform);
+            return;
+        }
+        const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+        let temporaryHandle;
+        try {
+            temporaryHandle = await fileSystem.openFile(temporaryPath, 'wx', 0o600);
+            await temporaryHandle.writeFile(JSON.stringify(Object.fromEntries(entries)), {
+                encoding: 'utf8',
+            });
+            await temporaryHandle.sync();
+            await temporaryHandle.close();
+            temporaryHandle = undefined;
+            await fileSystem.rename(temporaryPath, filePath);
+            await syncDirectory(parentPath, fileSystem, platform);
+        }
+        catch (error) {
+            if (temporaryHandle) {
+                try {
+                    await temporaryHandle.close();
+                }
+                catch {
+                    // Preserve the original durability failure.
+                }
+            }
+            try {
+                await fileSystem.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;