@compass-ai/nova 1.0.73 → 1.0.74

package/dist/acp/modes.js

@@ -0,0 +1,135 @@
+/**
+ * ACP Mode Configurations - Defines behavior for Default, Code, and Plan modes.
+ *
+ * Maps ACP protocol modes to CLI behavior settings including:
+ * - System prompt additions
+ * - Approval settings
+ * - Execution mode preferences
+ */
+import { logger } from '../utils/logger.js';
+const log = logger.child('ACPModes');
+/**
+ * Default mode configuration.
+ * Standard assistant behavior with smart approval.
+ */
+const DEFAULT_MODE = {
+    id: 'default',
+    name: 'Default',
+    description: 'Standard assistant mode with balanced behavior',
+    autoApprove: true,
+    forcePlanMode: false,
+    preferDirectExecution: false,
+};
+/**
+ * Code mode configuration.
+ * Optimized for coding tasks with more permissive operations.
+ */
+const CODE_MODE = {
+    id: 'code',
+    name: 'Code',
+    description: 'Code-focused mode with streamlined file operations',
+    systemPromptAddition: `
+## Code Mode Active
+
+You are in CODE MODE - optimized for software development tasks:
+
+1. **Prioritize Action**: When the user asks for code changes, implement them directly rather than just explaining.
+
+2. **File Operations**: You have streamlined permissions for file operations. Create, edit, and organize files efficiently.
+
+3. **Best Practices**: Apply coding best practices automatically:
+   - Follow existing code style and patterns in the project
+   - Add appropriate error handling
+   - Write clean, maintainable code
+   - Include necessary imports
+
+4. **Testing Awareness**: When making changes, consider if tests need to be updated or added.
+
+5. **Concise Communication**: Keep explanations brief. Show code, not lengthy descriptions.
+`,
+    autoApprove: true,
+    forcePlanMode: false,
+    preferDirectExecution: true,
+};
+/**
+ * Plan mode configuration.
+ * Requires detailed implementation plans before execution.
+ */
+const PLAN_MODE = {
+    id: 'plan',
+    name: 'Plan',
+    description: 'Planning mode - creates detailed plans before implementing',
+    systemPromptAddition: `
+## Plan Mode Active - MANDATORY enter_plan_mode Tool Usage
+
+You are in PLAN MODE. The user has explicitly chosen this mode because they want to review and approve all changes before implementation.
+
+**YOUR FIRST ACTION MUST BE**: Call the \`enter_plan_mode\` tool immediately when given any task involving code or file changes.
+
+### Required Workflow
+1. **IMMEDIATELY** call \`enter_plan_mode\` with a task summary
+2. **WAIT** for the plan to be generated and approved
+3. **EXECUTE** tasks one at a time after approval
+4. **REPORT** progress using \`complete_plan_task\` after each task
+5. **ADAPT** using \`update_plan\` if changes are needed
+
+### Plan Structure (handled by the tool)
+The \`enter_plan_mode\` tool will generate a structured plan including:
+- Overview of the approach
+- Step-by-step tasks with clear descriptions
+- Files that will be created or modified
+- Potential risks or considerations
+
+### Important Reminders
+- Do NOT skip the tool call even for "simple" tasks
+- Do NOT use edit_file/write_file before plan approval
+- Do NOT just describe a plan in text - USE THE TOOL
+`,
+    autoApprove: true,
+    forcePlanMode: true,
+    preferDirectExecution: false,
+};
+/**
+ * Map of all available modes.
+ */
+const MODES = {
+    default: DEFAULT_MODE,
+    code: CODE_MODE,
+    plan: PLAN_MODE,
+};
+/**
+ * Gets the configuration for a specific mode.
+ *
+ * @param modeId - The mode identifier
+ * @returns The mode configuration, or default if not found
+ */
+export function getModeConfig(modeId) {
+    const config = MODES[modeId];
+    if (!config) {
+        log.warn('Unknown mode, falling back to default', { modeId });
+        return DEFAULT_MODE;
+    }
+    return config;
+}
+/**
+ * Gets all available mode configurations for ACP.
+ *
+ * @returns Array of mode configs with id, name, and description
+ */
+export function getAvailableModes() {
+    return Object.values(MODES).map(mode => ({
+        id: mode.id,
+        name: mode.name,
+        description: mode.description,
+    }));
+}
+/**
+ * Checks if a mode ID is valid.
+ *
+ * @param modeId - The mode identifier to check
+ * @returns True if the mode exists
+ */
+export function isValidMode(modeId) {
+    return modeId in MODES;
+}
+//# sourceMappingURL=modes.js.map

package/dist/acp/modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.js","sourceRoot":"","sources":["../../src/acp/modes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE5C,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;AA2BrC;;;GAGG;AACH,MAAM,YAAY,GAAkB;IAClC,EAAE,EAAE,SAAS;IACb,IAAI,EAAE,SAAS;IACf,WAAW,EAAE,gDAAgD;IAC7D,WAAW,EAAE,IAAI;IACjB,aAAa,EAAE,KAAK;IACpB,qBAAqB,EAAE,KAAK;CAC7B,CAAC;AAEF;;;GAGG;AACH,MAAM,SAAS,GAAkB;IAC/B,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,oDAAoD;IACjE,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;CAkBvB;IACC,WAAW,EAAE,IAAI;IACjB,aAAa,EAAE,KAAK;IACpB,qBAAqB,EAAE,IAAI;CAC5B,CAAC;AAEF;;;GAGG;AACH,MAAM,SAAS,GAAkB;IAC/B,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,MAAM;IACZ,WAAW,EAAE,4DAA4D;IACzE,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBvB;IACC,WAAW,EAAE,IAAI;IACjB,aAAa,EAAE,IAAI;IACnB,qBAAqB,EAAE,KAAK;CAC7B,CAAC;AAEF;;GAEG;AACH,MAAM,KAAK,GAAqC;IAC9C,OAAO,EAAE,YAAY;IACrB,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,SAAS;CAChB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,MAAM,MAAM,GAAG,KAAK,CAAC,MAAmB,CAAC,CAAC;IAC1C,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,GAAG,CAAC,IAAI,CAAC,uCAAuC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9D,OAAO,YAAY,CAAC;IACtB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACvC,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,WAAW,EAAE,IAAI,CAAC,WAAW;KAC9B,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,MAAc;IACxC,OAAO,MAAM,IAAI,KAAK,CAAC;AACzB,CAAC"}

package/dist/acp/session-manager.d.ts

@@ -0,0 +1,170 @@
+/**
+ * ACP Session Manager with hybrid storage (memory + periodic snapshots).
+ *
+ * Manages the lifecycle of ACP sessions including creation, loading,
+ * state management, and persistence to disk.
+ */
+import type { ACPSessionState, ACPModelConfig, ACPMCPServer, ACPMessage } from './types.js';
+/**
+ * ACP Session Manager class.
+ * Provides hybrid storage with in-memory caching and periodic disk snapshots.
+ */
+export declare class ACPSessionManager {
+    /** In-memory session storage */
+    private sessions;
+    /** Snapshot timers for each session */
+    private snapshotTimers;
+    /** Base directory for session persistence */
+    private baseDir;
+    /** Snapshot interval in milliseconds (default: 60 seconds) */
+    private snapshotInterval;
+    /**
+     * Creates a new ACPSessionManager instance.
+     *
+     * @param options - Configuration options
+     */
+    constructor(options?: {
+        baseDir?: string;
+        snapshotInterval?: number;
+    });
+    /**
+     * Creates a new ACP session.
+     *
+     * @param workingDir - Working directory for the session
+     * @param model - Model configuration
+     * @param mcpServers - Optional MCP server configurations
+     * @returns The created session state
+     */
+    create(workingDir: string, model: ACPModelConfig, mcpServers?: ACPMCPServer[]): Promise<ACPSessionState>;
+    /**
+     * Loads an existing session from disk or memory.
+     *
+     * @param sessionId - Session identifier
+     * @param workingDir - Working directory (for validation)
+     * @param mcpServers - Optional MCP servers to attach
+     * @param model - Optional model configuration override
+     * @returns The loaded session state
+     */
+    load(sessionId: string, _workingDir: string, mcpServers?: ACPMCPServer[], model?: ACPModelConfig): Promise<ACPSessionState>;
+    /**
+     * Gets a session by ID. Throws if not found.
+     *
+     * @param sessionId - Session identifier
+     * @returns The session state
+     * @throws Error if session not found
+     */
+    get(sessionId: string): ACPSessionState;
+    /**
+     * Tries to get a session by ID.
+     *
+     * @param sessionId - Session identifier
+     * @returns The session state or undefined
+     */
+    tryGet(sessionId: string): ACPSessionState | undefined;
+    /**
+     * Gets the model configuration for a session.
+     *
+     * @param sessionId - Session identifier
+     * @returns The model configuration
+     */
+    getModel(sessionId: string): ACPModelConfig;
+    /**
+     * Sets the model configuration for a session.
+     *
+     * @param sessionId - Session identifier
+     * @param model - New model configuration
+     * @returns The updated session state
+     */
+    setModel(sessionId: string, model: ACPModelConfig): ACPSessionState;
+    /**
+     * Sets the mode/agent for a session.
+     *
+     * @param sessionId - Session identifier
+     * @param modeId - New mode/agent identifier
+     * @returns The updated session state
+     */
+    setMode(sessionId: string, modeId: string): ACPSessionState;
+    /**
+     * Updates the last activity timestamp for a session.
+     *
+     * @param sessionId - Session identifier
+     */
+    touch(sessionId: string): void;
+    /**
+     * Adds a message to the session's conversation history.
+     *
+     * @param sessionId - Session identifier
+     * @param message - Message to add
+     */
+    addMessage(sessionId: string, message: ACPMessage): void;
+    /**
+     * Gets the conversation history for a session.
+     *
+     * @param sessionId - Session identifier
+     * @returns Array of messages
+     */
+    getMessages(sessionId: string): ACPMessage[];
+    /**
+     * Lists all sessions, optionally filtered by working directory.
+     *
+     * @param workingDir - Optional working directory filter
+     * @returns Array of session states
+     */
+    list(workingDir?: string): Promise<ACPSessionState[]>;
+    /**
+     * Creates a fork of an existing session.
+     *
+     * @param sessionId - Session to fork
+     * @param workingDir - Working directory for the forked session
+     * @param mcpServers - Optional MCP servers for the fork
+     * @returns The forked session state
+     */
+    fork(sessionId: string, workingDir: string, mcpServers?: ACPMCPServer[]): Promise<ACPSessionState>;
+    /**
+     * Saves a snapshot of a session to disk.
+     *
+     * @param sessionId - Session identifier
+     */
+    snapshot(sessionId: string): Promise<void>;
+    /**
+     * Disposes of a session, saving final state and cleaning up resources.
+     *
+     * @param sessionId - Session identifier
+     */
+    dispose(sessionId: string): Promise<void>;
+    /**
+     * Deletes a session from memory and disk.
+     *
+     * @param sessionId - Session identifier
+     */
+    delete(sessionId: string): Promise<void>;
+    /**
+     * Gracefully shuts down all sessions.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Schedules periodic snapshots for a session.
+     */
+    private scheduleSnapshot;
+    /**
+     * Clears the snapshot timer for a session.
+     */
+    private clearSnapshot;
+}
+/**
+ * Gets the singleton ACPSessionManager instance.
+ *
+ * @returns The ACPSessionManager instance
+ */
+export declare function getACPSessionManager(): ACPSessionManager;
+/**
+ * Creates a new ACPSessionManager instance.
+ *
+ * @param options - Configuration options
+ * @returns A new ACPSessionManager instance
+ */
+export declare function createACPSessionManager(options?: {
+    baseDir?: string;
+    snapshotInterval?: number;
+}): ACPSessionManager;
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/acp/session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../../src/acp/session-manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,YAAY,EACZ,UAAU,EACX,MAAM,YAAY,CAAC;AAIpB;;;GAGG;AACH,qBAAa,iBAAiB;IAC5B,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAsC;IAEtD,uCAAuC;IACvC,OAAO,CAAC,cAAc,CAAqC;IAE3D,6CAA6C;IAC7C,OAAO,CAAC,OAAO,CAAS;IAExB,8DAA8D;IAC9D,OAAO,CAAC,gBAAgB,CAAS;IAEjC;;;;OAIG;gBACS,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE;IAKrE;;;;;;;OAOG;IACG,MAAM,CACV,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,cAAc,EACrB,UAAU,GAAE,YAAY,EAAO,GAC9B,OAAO,CAAC,eAAe,CAAC;IA2B3B;;;;;;;;OAQG;IACG,IAAI,CACR,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,UAAU,GAAE,YAAY,EAAO,EAC/B,KAAK,CAAC,EAAE,cAAc,GACrB,OAAO,CAAC,eAAe,CAAC;IA0C3B;;;;;;OAMG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe;IASvC;;;;;OAKG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAItD;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc;IAI3C;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,eAAe;IASnE;;;;;;OAMG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe;IAS3D;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAO9B;;;;;OAKG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IASxD;;;;;OAKG;IACH,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,EAAE;IAK5C;;;;;OAKG;IACG,IAAI,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAgD3D;;;;;;;OAOG;IACG,IAAI,CACR,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,YAAY,EAAO,GAC9B,OAAO,CAAC,eAAe,CAAC;IA0B3B;;;;OAIG;IACG,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBhD;;;;OAIG;IACG,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/C;;;;OAIG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAS/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,aAAa;CAOtB;AAKD;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CAKxD;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,iBAAiB,CAEpB"}

package/dist/acp/session-manager.js

@@ -0,0 +1,381 @@
+/**
+ * ACP Session Manager with hybrid storage (memory + periodic snapshots).
+ *
+ * Manages the lifecycle of ACP sessions including creation, loading,
+ * state management, and persistence to disk.
+ */
+import { v4 as uuidv4 } from 'uuid';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { logger } from '../utils/logger.js';
+const log = logger.child('ACPSessionManager');
+/**
+ * ACP Session Manager class.
+ * Provides hybrid storage with in-memory caching and periodic disk snapshots.
+ */
+export class ACPSessionManager {
+    /** In-memory session storage */
+    sessions = new Map();
+    /** Snapshot timers for each session */
+    snapshotTimers = new Map();
+    /** Base directory for session persistence */
+    baseDir;
+    /** Snapshot interval in milliseconds (default: 60 seconds) */
+    snapshotInterval;
+    /**
+     * Creates a new ACPSessionManager instance.
+     *
+     * @param options - Configuration options
+     */
+    constructor(options) {
+        this.baseDir = options?.baseDir ?? path.join(os.homedir(), '.compass', 'acp-sessions');
+        this.snapshotInterval = options?.snapshotInterval ?? 60000;
+    }
+    /**
+     * Creates a new ACP session.
+     *
+     * @param workingDir - Working directory for the session
+     * @param model - Model configuration
+     * @param mcpServers - Optional MCP server configurations
+     * @returns The created session state
+     */
+    async create(workingDir, model, mcpServers = []) {
+        const session = {
+            id: uuidv4(),
+            workingDir,
+            model,
+            mcpServers,
+            modeId: 'default',
+            createdAt: new Date(),
+            lastActivity: new Date(),
+            conversationHistory: [],
+            metadata: {},
+        };
+        log.info('Creating ACP session', { sessionId: session.id, workingDir });
+        // Store in memory
+        this.sessions.set(session.id, session);
+        // Initial snapshot
+        await this.snapshot(session.id);
+        // Schedule periodic snapshots
+        this.scheduleSnapshot(session.id);
+        return session;
+    }
+    /**
+     * Loads an existing session from disk or memory.
+     *
+     * @param sessionId - Session identifier
+     * @param workingDir - Working directory (for validation)
+     * @param mcpServers - Optional MCP servers to attach
+     * @param model - Optional model configuration override
+     * @returns The loaded session state
+     */
+    async load(sessionId, _workingDir, mcpServers = [], model) {
+        // Try memory first (workingDir used for validation in future)
+        if (this.sessions.has(sessionId)) {
+            const session = this.sessions.get(sessionId);
+            session.lastActivity = new Date();
+            if (mcpServers.length > 0) {
+                session.mcpServers = mcpServers;
+            }
+            if (model) {
+                session.model = model;
+            }
+            log.info('Loaded ACP session from memory', { sessionId });
+            return session;
+        }
+        // Fall back to disk
+        const sessionFile = path.join(this.baseDir, `${sessionId}.json`);
+        if (!(await fs.pathExists(sessionFile))) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        const data = await fs.readFile(sessionFile, 'utf-8');
+        const sessionData = JSON.parse(data);
+        const session = {
+            ...sessionData,
+            createdAt: new Date(sessionData.createdAt),
+            lastActivity: new Date(),
+            mcpServers: mcpServers.length > 0 ? mcpServers : sessionData.mcpServers || [],
+            model: model || sessionData.model,
+        };
+        log.info('Loaded ACP session from disk', { sessionId });
+        // Load into memory
+        this.sessions.set(sessionId, session);
+        this.scheduleSnapshot(sessionId);
+        return session;
+    }
+    /**
+     * Gets a session by ID. Throws if not found.
+     *
+     * @param sessionId - Session identifier
+     * @returns The session state
+     * @throws Error if session not found
+     */
+    get(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            log.error('Session not found', { sessionId });
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        return session;
+    }
+    /**
+     * Tries to get a session by ID.
+     *
+     * @param sessionId - Session identifier
+     * @returns The session state or undefined
+     */
+    tryGet(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Gets the model configuration for a session.
+     *
+     * @param sessionId - Session identifier
+     * @returns The model configuration
+     */
+    getModel(sessionId) {
+        return this.get(sessionId).model;
+    }
+    /**
+     * Sets the model configuration for a session.
+     *
+     * @param sessionId - Session identifier
+     * @param model - New model configuration
+     * @returns The updated session state
+     */
+    setModel(sessionId, model) {
+        const session = this.get(sessionId);
+        session.model = model;
+        session.lastActivity = new Date();
+        this.sessions.set(sessionId, session);
+        log.debug('Model updated', { sessionId, model });
+        return session;
+    }
+    /**
+     * Sets the mode/agent for a session.
+     *
+     * @param sessionId - Session identifier
+     * @param modeId - New mode/agent identifier
+     * @returns The updated session state
+     */
+    setMode(sessionId, modeId) {
+        const session = this.get(sessionId);
+        session.modeId = modeId;
+        session.lastActivity = new Date();
+        this.sessions.set(sessionId, session);
+        log.debug('Mode updated', { sessionId, modeId });
+        return session;
+    }
+    /**
+     * Updates the last activity timestamp for a session.
+     *
+     * @param sessionId - Session identifier
+     */
+    touch(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastActivity = new Date();
+        }
+    }
+    /**
+     * Adds a message to the session's conversation history.
+     *
+     * @param sessionId - Session identifier
+     * @param message - Message to add
+     */
+    addMessage(sessionId, message) {
+        const session = this.get(sessionId);
+        if (!session.conversationHistory) {
+            session.conversationHistory = [];
+        }
+        session.conversationHistory.push(message);
+        session.lastActivity = new Date();
+    }
+    /**
+     * Gets the conversation history for a session.
+     *
+     * @param sessionId - Session identifier
+     * @returns Array of messages
+     */
+    getMessages(sessionId) {
+        const session = this.get(sessionId);
+        return session.conversationHistory || [];
+    }
+    /**
+     * Lists all sessions, optionally filtered by working directory.
+     *
+     * @param workingDir - Optional working directory filter
+     * @returns Array of session states
+     */
+    async list(workingDir) {
+        // Ensure base directory exists
+        await fs.ensureDir(this.baseDir);
+        // Get all session files
+        const files = await fs.readdir(this.baseDir);
+        const sessionFiles = files.filter(f => f.endsWith('.json') && !f.endsWith('.tmp'));
+        const sessions = [];
+        for (const file of sessionFiles) {
+            try {
+                const sessionId = file.replace('.json', '');
+                // Check memory first
+                if (this.sessions.has(sessionId)) {
+                    const session = this.sessions.get(sessionId);
+                    if (!workingDir || session.workingDir === workingDir) {
+                        sessions.push(session);
+                    }
+                    continue;
+                }
+                // Load from disk
+                const data = await fs.readFile(path.join(this.baseDir, file), 'utf-8');
+                const sessionData = JSON.parse(data);
+                if (!workingDir || sessionData.workingDir === workingDir) {
+                    sessions.push({
+                        ...sessionData,
+                        createdAt: new Date(sessionData.createdAt),
+                        lastActivity: new Date(sessionData.lastActivity || sessionData.createdAt),
+                    });
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                log.warn('Failed to read session file, removing corrupt file', { file, error: msg });
+                // Remove corrupt/unreadable session files so they don't keep triggering warnings
+                await fs.remove(path.join(this.baseDir, file)).catch(() => { });
+            }
+        }
+        // Sort by last activity (newest first)
+        return sessions.sort((a, b) => b.lastActivity.getTime() - a.lastActivity.getTime());
+    }
+    /**
+     * Creates a fork of an existing session.
+     *
+     * @param sessionId - Session to fork
+     * @param workingDir - Working directory for the forked session
+     * @param mcpServers - Optional MCP servers for the fork
+     * @returns The forked session state
+     */
+    async fork(sessionId, workingDir, mcpServers = []) {
+        const source = this.get(sessionId);
+        const forked = {
+            ...source,
+            id: uuidv4(),
+            workingDir,
+            mcpServers: mcpServers.length > 0 ? mcpServers : source.mcpServers,
+            createdAt: new Date(),
+            lastActivity: new Date(),
+            conversationHistory: [...(source.conversationHistory || [])],
+            metadata: {
+                ...source.metadata,
+                forkedFrom: sessionId,
+            },
+        };
+        log.info('Forked ACP session', { sourceId: sessionId, forkId: forked.id });
+        this.sessions.set(forked.id, forked);
+        await this.snapshot(forked.id);
+        this.scheduleSnapshot(forked.id);
+        return forked;
+    }
+    /**
+     * Saves a snapshot of a session to disk.
+     *
+     * @param sessionId - Session identifier
+     */
+    async snapshot(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        try {
+            await fs.ensureDir(this.baseDir);
+            const sessionFile = path.join(this.baseDir, `${sessionId}.json`);
+            const tmpFile = sessionFile + '.tmp';
+            // Atomic write: write to temp file then rename to avoid read-during-write corruption
+            await fs.writeFile(tmpFile, JSON.stringify(session, null, 2));
+            await fs.rename(tmpFile, sessionFile);
+            log.debug('Session snapshot saved', { sessionId });
+        }
+        catch (error) {
+            log.error('Failed to save session snapshot', { sessionId, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    /**
+     * Disposes of a session, saving final state and cleaning up resources.
+     *
+     * @param sessionId - Session identifier
+     */
+    async dispose(sessionId) {
+        await this.snapshot(sessionId);
+        this.clearSnapshot(sessionId);
+        this.sessions.delete(sessionId);
+        log.info('Session disposed', { sessionId });
+    }
+    /**
+     * Deletes a session from memory and disk.
+     *
+     * @param sessionId - Session identifier
+     */
+    async delete(sessionId) {
+        this.clearSnapshot(sessionId);
+        this.sessions.delete(sessionId);
+        const sessionFile = path.join(this.baseDir, `${sessionId}.json`);
+        if (await fs.pathExists(sessionFile)) {
+            await fs.remove(sessionFile);
+        }
+        log.info('Session deleted', { sessionId });
+    }
+    /**
+     * Gracefully shuts down all sessions.
+     */
+    async shutdown() {
+        log.info('Shutting down ACP session manager');
+        const sessionIds = Array.from(this.sessions.keys());
+        await Promise.all(sessionIds.map(id => this.dispose(id)));
+        log.info('ACP session manager shutdown complete');
+    }
+    /**
+     * Schedules periodic snapshots for a session.
+     */
+    scheduleSnapshot(sessionId) {
+        // Clear existing timer if any
+        this.clearSnapshot(sessionId);
+        const timer = setInterval(async () => {
+            await this.snapshot(sessionId).catch(err => {
+                log.error('Periodic snapshot failed', { sessionId, error: err instanceof Error ? err.message : String(err) });
+            });
+        }, this.snapshotInterval);
+        this.snapshotTimers.set(sessionId, timer);
+    }
+    /**
+     * Clears the snapshot timer for a session.
+     */
+    clearSnapshot(sessionId) {
+        const timer = this.snapshotTimers.get(sessionId);
+        if (timer) {
+            clearInterval(timer);
+            this.snapshotTimers.delete(sessionId);
+        }
+    }
+}
+// Singleton instance
+let sessionManagerInstance = null;
+/**
+ * Gets the singleton ACPSessionManager instance.
+ *
+ * @returns The ACPSessionManager instance
+ */
+export function getACPSessionManager() {
+    if (!sessionManagerInstance) {
+        sessionManagerInstance = new ACPSessionManager();
+    }
+    return sessionManagerInstance;
+}
+/**
+ * Creates a new ACPSessionManager instance.
+ *
+ * @param options - Configuration options
+ * @returns A new ACPSessionManager instance
+ */
+export function createACPSessionManager(options) {
+    return new ACPSessionManager(options);
+}
+//# sourceMappingURL=session-manager.js.map