@compass-ai/nova 1.0.74 → 1.0.75

package/dist/acp/modes.js

@@ -1,135 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,170 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,381 +0,0 @@
-/**
- * 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