orquesta-cli 0.1.27 → 0.2.0

package/dist/agents/planner/index.d.ts

@@ -7,7 +7,8 @@ export interface PlanningWithDocsResult extends PlanningResult {
 export declare class PlanningLLM {
     private llmClient;
     private askUserCallback;
-    constructor(llmClient: LLMClient);
+    private modelOverride?;
+    constructor(llmClient: LLMClient, modelOverride?: string);
     setAskUserCallback(callback: AskUserCallback): void;
     clearAskUserCallback(): void;
     generateTODOList(userRequest: string, contextMessages?: Message[]): Promise<PlanningResult>;

package/dist/agents/planner/index.js

@@ -5,8 +5,10 @@ import { getProjectContext } from '../../core/project-context.js';
 export class PlanningLLM {
     llmClient;
     askUserCallback = null;
-    constructor(llmClient) {
+    modelOverride;
+    constructor(llmClient, modelOverride) {
         this.llmClient = llmClient;
+        this.modelOverride = modelOverride;
     }
     setAskUserCallback(callback) {
         logger.flow('Setting ask-user callback for Planning LLM');
@@ -73,6 +75,7 @@ Choose one of your 3 tools now.`,
                         tool_choice: 'required',
                         temperature: 0.7,
                         max_tokens: 2000,
+                        ...(this.modelOverride ? { model: this.modelOverride } : {}),
                     });
                     const choicesCount = response.choices?.length ?? 0;
                     const message = response.choices?.[0]?.message;
@@ -174,6 +177,9 @@ Choose one of your 3 tools now.`,
                                 id: todo.id || `todo-${Date.now()}-${index}`,
                                 title: todo.title || 'Untitled task',
                                 status: (index === 0 ? 'in_progress' : 'pending'),
+                                ...(Array.isArray(todo.dependsOn) && todo.dependsOn.length > 0 ? { dependsOn: todo.dependsOn } : {}),
+                                ...(typeof todo.requiresFilesystem === 'boolean' ? { requiresFilesystem: todo.requiresFilesystem } : {}),
+                                ...(typeof todo.parallelGroup === 'string' && todo.parallelGroup ? { parallelGroup: todo.parallelGroup } : {}),
                             }));
                             return {
                                 todos,

package/dist/core/config/config-manager.d.ts

@@ -1,4 +1,4 @@
-import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig } from '../../types/index.js';
+import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig, OrchestrationConfig, OrchestrationRole } from '../../types/index.js';
 export declare class ConfigManager {
     private config;
     private initialized;
@@ -51,6 +51,16 @@ export declare class ConfigManager {
         unchanged: number;
     }>;
     getLocalOnlyEndpoints(): EndpointConfig[];
+    getOrchestrationConfig(): OrchestrationConfig;
+    getRoleModel(role: OrchestrationRole): string | null;
+    setRoleModel(role: OrchestrationRole, modelId: string | null): Promise<void>;
+    clearRoleModels(): Promise<void>;
+    getMaxParallelWorkers(): number;
+    setMaxParallelWorkers(n: number): Promise<void>;
+    isRefinerEnabled(): boolean;
+    setRefinerEnabled(enabled: boolean): Promise<void>;
+    isWorktreeIsolationEnabled(): boolean;
+    setWorktreeIsolationEnabled(enabled: boolean): Promise<void>;
 }
 export declare const configManager: ConfigManager;
 //# sourceMappingURL=config-manager.d.ts.map

package/dist/core/config/config-manager.js

@@ -337,6 +337,66 @@ export class ConfigManager {
         const config = this.getConfig();
         return config.endpoints;
     }
+    getOrchestrationConfig() {
+        return this.config?.orchestration ?? {};
+    }
+    getRoleModel(role) {
+        const override = this.config?.orchestration?.roleModels?.[role];
+        if (override)
+            return override;
+        return this.config?.currentModel ?? null;
+    }
+    async setRoleModel(role, modelId) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        if (!config.orchestration.roleModels)
+            config.orchestration.roleModels = {};
+        if (modelId === null) {
+            delete config.orchestration.roleModels[role];
+        }
+        else {
+            config.orchestration.roleModels[role] = modelId;
+        }
+        await this.saveConfig();
+    }
+    async clearRoleModels() {
+        const config = this.getConfig();
+        if (config.orchestration) {
+            config.orchestration.roleModels = {};
+            await this.saveConfig();
+        }
+    }
+    getMaxParallelWorkers() {
+        return this.config?.orchestration?.maxParallelWorkers ?? 3;
+    }
+    async setMaxParallelWorkers(n) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.maxParallelWorkers = Math.max(1, Math.min(10, n));
+        await this.saveConfig();
+    }
+    isRefinerEnabled() {
+        return this.config?.orchestration?.refinerEnabled ?? false;
+    }
+    async setRefinerEnabled(enabled) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.refinerEnabled = enabled;
+        await this.saveConfig();
+    }
+    isWorktreeIsolationEnabled() {
+        return this.config?.orchestration?.worktreeIsolation ?? false;
+    }
+    async setWorktreeIsolationEnabled(enabled) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.worktreeIsolation = enabled;
+        await this.saveConfig();
+    }
 }
 export const configManager = new ConfigManager();
 //# sourceMappingURL=config-manager.js.map

package/dist/core/config/providers.js

@@ -36,6 +36,22 @@ export const PROVIDERS = [
             { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', maxTokens: 200000, capabilities: ['vision', 'tools', 'streaming'] },
         ],
     },
+    {
+        id: 'anthropic-direct',
+        name: 'Anthropic (OpenAI-compat)',
+        baseUrl: 'https://api.anthropic.com/v1/openai',
+        authMethod: 'bearer',
+        envVars: ['ANTHROPIC_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', maxTokens: 200000, capabilities: ['vision', 'tools', 'streaming'] },
+        ],
+    },
     {
         id: 'google',
         name: 'Google Gemini',

package/dist/core/llm/llm-client.d.ts

@@ -61,6 +61,7 @@ export declare class LLMClient {
     chatCompletionWithTools(messages: Message[], tools: import('../../types/index.js').ToolDefinition[], options?: {
         getPendingMessage?: () => string | null;
         clearPendingMessage?: () => void;
+        model?: string;
     }): Promise<{
         message: Message;
         toolCalls: Array<{

package/dist/core/llm/llm-client.js

@@ -415,6 +415,7 @@ export class LLMClient {
         }
     }
     async chatCompletionWithTools(messages, tools, options) {
+        const roleModel = options?.model;
         let workingMessages = [...messages];
         const toolCallHistory = [];
         let iterations = 0;
@@ -443,6 +444,7 @@ export class LLMClient {
                     messages: workingMessages,
                     tools,
                     tool_choice: 'required',
+                    ...(roleModel ? { model: roleModel } : {}),
                 });
             }
             catch (error) {

package/dist/core/slash-command-handler.js

@@ -4,6 +4,7 @@ import { logger } from '../utils/logger.js';
 import { fullSync } from '../orquesta/config-sync.js';
 import { configManager } from './config/config-manager.js';
 import { getForcedTier, setForcedTier, resetBatutaSession } from './routing-state.js';
+import { auditLog } from '../orchestration/audit-log.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
@@ -169,6 +170,144 @@ export async function executeSlashCommand(command, context) {
             updatedContext: { messages: updatedMessages },
         };
     }
+    if (trimmedCommand === '/role' || trimmedCommand.startsWith('/role ')) {
+        const args = trimmedCommand.slice('/role'.length).trim().split(/\s+/).filter(Boolean);
+        const currentModelId = configManager.getConfig().currentModel ?? 'none';
+        const formatStatus = () => {
+            const roles = ['planner', 'executor', 'refiner'];
+            const lines = roles.map(r => {
+                const override = configManager.getOrchestrationConfig().roleModels?.[r];
+                const effective = override ?? currentModelId;
+                const suffix = override ? '' : '  (fallback to currentModel)';
+                return `  ${r.padEnd(10)} → ${effective}${suffix}`;
+            });
+            const parallel = configManager.getMaxParallelWorkers();
+            const refiner = configManager.isRefinerEnabled() ? 'on' : 'off';
+            const worktree = configManager.isWorktreeIsolationEnabled() ? 'on' : 'off';
+            return `Multi-role orchestration\n\n${lines.join('\n')}\n\n  max parallel workers: ${parallel}\n  refiner pass:         ${refiner}\n  worktree isolation:   ${worktree}\n\nUsage:\n  /role planner <model-id>\n  /role executor <model-id>\n  /role refiner <model-id> | off\n  /role parallel <N>\n  /role worktree on|off\n  /role clear`;
+        };
+        let body;
+        try {
+            if (args.length === 0) {
+                body = formatStatus();
+            }
+            else if (args[0] === 'clear') {
+                await configManager.clearRoleModels();
+                body = 'Role pins cleared. Every role falls back to currentModel.';
+            }
+            else if (args[0] === 'parallel' && args[1]) {
+                const n = parseInt(args[1], 10);
+                if (!Number.isFinite(n) || n < 1) {
+                    body = 'parallel must be an integer >= 1';
+                }
+                else {
+                    await configManager.setMaxParallelWorkers(n);
+                    body = `Max parallel workers set to ${configManager.getMaxParallelWorkers()}.`;
+                }
+            }
+            else if (args[0] === 'worktree' && (args[1] === 'on' || args[1] === 'off')) {
+                await configManager.setWorktreeIsolationEnabled(args[1] === 'on');
+                body = `Worktree isolation: ${args[1]}.`;
+            }
+            else if ((args[0] === 'planner' || args[0] === 'executor' || args[0] === 'refiner') && args[1]) {
+                const role = args[0];
+                if (role === 'refiner' && args[1] === 'off') {
+                    await configManager.setRefinerEnabled(false);
+                    body = 'Refiner pass disabled.';
+                }
+                else {
+                    await configManager.setRoleModel(role, args[1]);
+                    if (role === 'refiner') {
+                        await configManager.setRefinerEnabled(true);
+                        body = `Refiner pinned to ${args[1]} and refiner pass enabled.`;
+                    }
+                    else {
+                        body = `${role} pinned to ${args[1]}.`;
+                    }
+                }
+            }
+            else {
+                body = `Unknown /role usage. Run /role with no args for help.`;
+            }
+        }
+        catch (error) {
+            body = `Error: ${error.message}`;
+        }
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: body },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: { messages: updatedMessages },
+        };
+    }
+    if (trimmedCommand === '/audit' || trimmedCommand.startsWith('/audit ')) {
+        const args = trimmedCommand.slice('/audit'.length).trim().split(/\s+/).filter(Boolean);
+        let body;
+        try {
+            if (args[0] === 'tail') {
+                const n = Number(args[1]) || 20;
+                const events = await auditLog.tail(n);
+                if (events.length === 0) {
+                    body = '(no audit events yet)';
+                }
+                else {
+                    body = `Last ${events.length} audit events:\n\n` + events
+                        .map(e => `[${e.timestamp.slice(11, 19)}] ${e.kind.padEnd(22)} ${JSON.stringify(e.data).slice(0, 140)}`)
+                        .join('\n');
+                }
+            }
+            else if (args[0] === 'clear') {
+                await auditLog.clear();
+                body = 'Audit log cleared.';
+            }
+            else {
+                const sinceDays = args[0] === 'day' ? 1 : args[0] === 'week' ? 7 : undefined;
+                const s = await auditLog.stats({ sinceDays });
+                const period = sinceDays ? `last ${sinceDays}d` : 'lifetime';
+                const plannerLines = Object.entries(s.byPlannerModel)
+                    .map(([m, c]) => `    ${m}: ${c}`).join('\n') || '    (none)';
+                const executorLines = Object.entries(s.byExecutorModel)
+                    .map(([m, c]) => `    ${m}: ${c}`).join('\n') || '    (none)';
+                body = `Orchestration audit (${period})
+
+  runs:                 ${s.runs}
+  parallel runs:        ${s.parallelRuns}
+  sequential runs:      ${s.sequentialRuns}
+  total workers:        ${s.totalWorkers}
+  worker failures:      ${s.workerFailures}
+  avg planner ms:       ${s.avgPlannerMs}
+  avg worker ms:        ${s.avgWorkerMs}
+  avg waves per run:    ${s.avgWavesPerRun}
+  refiner runs:         ${s.refinerRuns}
+  refiner rewrites:     ${s.refinerRewrites}
+
+  by planner model:
+${plannerLines}
+
+  by executor model:
+${executorLines}
+
+  Subcommands: /audit | /audit day | /audit week | /audit tail [N] | /audit clear`;
+            }
+        }
+        catch (error) {
+            body = `Error: ${error.message}`;
+        }
+        const updatedMessages = [
+            ...context.messages,
+            { role: 'assistant', content: body },
+        ];
+        context.setMessages(updatedMessages);
+        return {
+            handled: true,
+            shouldContinue: false,
+            updatedContext: { messages: updatedMessages },
+        };
+    }
     if (trimmedCommand === '/cost') {
         const costMessage = usageTracker.formatCostDisplay();
         const updatedMessages = [

package/dist/orchestration/audit-log.d.ts

@@ -0,0 +1,40 @@
+declare const SCHEMA_VERSION = 1;
+export type AuditEventKind = 'run.start' | 'planner.complete' | 'orchestrator.decision' | 'worker.start' | 'worker.complete' | 'wave.complete' | 'refiner.complete' | 'run.complete' | 'run.error';
+export interface AuditEvent {
+    schema: typeof SCHEMA_VERSION;
+    timestamp: string;
+    sessionId: string;
+    runId: string;
+    kind: AuditEventKind;
+    data: Record<string, unknown>;
+}
+declare class AuditLogger {
+    private initialized;
+    private writeQueue;
+    private currentRunId;
+    startRun(sessionId: string, data?: Record<string, unknown>): string;
+    emit(sessionId: string, kind: AuditEventKind, data?: Record<string, unknown>): void;
+    private write;
+    tail(n?: number): Promise<AuditEvent[]>;
+    stats(opts?: {
+        sinceDays?: number;
+    }): Promise<{
+        runs: number;
+        parallelRuns: number;
+        sequentialRuns: number;
+        totalWorkers: number;
+        workerFailures: number;
+        avgPlannerMs: number;
+        avgWorkerMs: number;
+        avgWavesPerRun: number;
+        byPlannerModel: Record<string, number>;
+        byExecutorModel: Record<string, number>;
+        refinerRuns: number;
+        refinerRewrites: number;
+    }>;
+    private readAll;
+    clear(): Promise<void>;
+}
+export declare const auditLog: AuditLogger;
+export {};
+//# sourceMappingURL=audit-log.d.ts.map

package/dist/orchestration/audit-log.js

@@ -0,0 +1,156 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { LOCAL_HOME_DIR } from '../constants.js';
+import { logger } from '../utils/logger.js';
+const AUDIT_LOG_PATH = path.join(LOCAL_HOME_DIR, 'audit.jsonl');
+const SCHEMA_VERSION = 1;
+class AuditLogger {
+    initialized = false;
+    writeQueue = Promise.resolve();
+    currentRunId = null;
+    startRun(sessionId, data = {}) {
+        this.currentRunId = `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        this.emit(sessionId, 'run.start', data);
+        return this.currentRunId;
+    }
+    emit(sessionId, kind, data = {}) {
+        const runId = (typeof data['runId'] === 'string' ? data['runId'] : null) ?? this.currentRunId ?? 'unknown';
+        const event = {
+            schema: SCHEMA_VERSION,
+            timestamp: new Date().toISOString(),
+            sessionId,
+            runId,
+            kind,
+            data,
+        };
+        this.writeQueue = this.writeQueue.then(() => this.write(event)).catch(() => undefined);
+    }
+    async write(event) {
+        try {
+            if (!this.initialized) {
+                await fs.mkdir(LOCAL_HOME_DIR, { recursive: true });
+                this.initialized = true;
+            }
+            await fs.appendFile(AUDIT_LOG_PATH, JSON.stringify(event) + '\n', 'utf8');
+        }
+        catch (error) {
+            logger.warn('Audit log write failed', { error: error.message });
+        }
+    }
+    async tail(n = 50) {
+        try {
+            const raw = await fs.readFile(AUDIT_LOG_PATH, 'utf8');
+            const lines = raw.split('\n').filter(Boolean);
+            const last = lines.slice(-n);
+            const events = [];
+            for (const line of last) {
+                try {
+                    events.push(JSON.parse(line));
+                }
+                catch {
+                }
+            }
+            return events.reverse();
+        }
+        catch {
+            return [];
+        }
+    }
+    async stats(opts) {
+        const events = await this.readAll();
+        const cutoff = opts?.sinceDays ? Date.now() - opts.sinceDays * 86400_000 : 0;
+        const filtered = cutoff ? events.filter(e => Date.parse(e.timestamp) >= cutoff) : events;
+        const runs = new Set();
+        let parallelRuns = 0;
+        let sequentialRuns = 0;
+        let totalWorkers = 0;
+        let workerFailures = 0;
+        let plannerDurMs = 0;
+        let plannerCount = 0;
+        let workerDurMs = 0;
+        let workerCount = 0;
+        let waveCount = 0;
+        let refinerRuns = 0;
+        let refinerRewrites = 0;
+        const byPlannerModel = {};
+        const byExecutorModel = {};
+        for (const e of filtered) {
+            runs.add(e.runId);
+            const d = e.data;
+            if (e.kind === 'orchestrator.decision') {
+                if (d['parallel'])
+                    parallelRuns++;
+                else
+                    sequentialRuns++;
+            }
+            if (e.kind === 'planner.complete') {
+                plannerCount++;
+                const dur = d['durationMs'];
+                if (typeof dur === 'number')
+                    plannerDurMs += dur;
+                const model = d['model'];
+                if (typeof model === 'string')
+                    byPlannerModel[model] = (byPlannerModel[model] || 0) + 1;
+            }
+            if (e.kind === 'worker.complete') {
+                totalWorkers++;
+                if (d['success'] === false)
+                    workerFailures++;
+                const dur = d['durationMs'];
+                if (typeof dur === 'number') {
+                    workerDurMs += dur;
+                    workerCount++;
+                }
+                const model = d['model'];
+                if (typeof model === 'string')
+                    byExecutorModel[model] = (byExecutorModel[model] || 0) + 1;
+            }
+            if (e.kind === 'wave.complete')
+                waveCount++;
+            if (e.kind === 'refiner.complete') {
+                refinerRuns++;
+                if (d['rewrote'])
+                    refinerRewrites++;
+            }
+        }
+        return {
+            runs: runs.size,
+            parallelRuns,
+            sequentialRuns,
+            totalWorkers,
+            workerFailures,
+            avgPlannerMs: plannerCount ? Math.round(plannerDurMs / plannerCount) : 0,
+            avgWorkerMs: workerCount ? Math.round(workerDurMs / workerCount) : 0,
+            avgWavesPerRun: runs.size ? Number((waveCount / runs.size).toFixed(2)) : 0,
+            byPlannerModel,
+            byExecutorModel,
+            refinerRuns,
+            refinerRewrites,
+        };
+    }
+    async readAll() {
+        try {
+            const raw = await fs.readFile(AUDIT_LOG_PATH, 'utf8');
+            return raw.split('\n').filter(Boolean).flatMap(line => {
+                try {
+                    return [JSON.parse(line)];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    async clear() {
+        try {
+            await fs.rm(AUDIT_LOG_PATH, { force: true });
+        }
+        catch {
+        }
+    }
+}
+export const auditLog = new AuditLogger();
+//# sourceMappingURL=audit-log.js.map

package/dist/orchestration/index.d.ts

@@ -1,4 +1,7 @@
 export type { ExecutionPhase, PlanExecutionState, AskUserRequest, AskUserResponse, AskUserState, StateCallbacks, ExecutionContext, ExecutionResult, PlanExecutionActions, } from './types.js';
 export { formatErrorMessage, buildTodoContext, areAllTodosCompleted, findActiveTodo, getTodoStats, } from './utils.js';
 export { PlanExecutor, planExecutor } from './plan-executor.js';
+export { WorktreeManager, worktreeManager, type WorktreeAllocation, type WorktreeBackend, type MergeResult, } from './worktree-manager.js';
+export { MemoryStore, memoryStore, type MemoryEntry, } from './memory-store.js';
+export { auditLog, type AuditEvent, type AuditEventKind, } from './audit-log.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/orchestration/index.js

@@ -1,3 +1,6 @@
 export { formatErrorMessage, buildTodoContext, areAllTodosCompleted, findActiveTodo, getTodoStats, } from './utils.js';
 export { PlanExecutor, planExecutor } from './plan-executor.js';
+export { WorktreeManager, worktreeManager, } from './worktree-manager.js';
+export { MemoryStore, memoryStore, } from './memory-store.js';
+export { auditLog, } from './audit-log.js';
 //# sourceMappingURL=index.js.map

package/dist/orchestration/memory-store.d.ts

@@ -0,0 +1,21 @@
+export interface MemoryEntry {
+    writtenAt: string;
+    source?: 'planner' | 'executor' | 'worker' | 'refiner' | 'user' | string;
+    value: unknown;
+}
+export declare class MemoryStore {
+    private cache;
+    private pendingFlush;
+    private pendingLoad;
+    private filePath;
+    load(sessionId: string): Promise<void>;
+    get(sessionId: string, key: string): MemoryEntry | null;
+    all(sessionId: string): Record<string, MemoryEntry>;
+    bySource(sessionId: string, source: MemoryEntry['source']): MemoryEntry[];
+    set(sessionId: string, key: string, value: unknown, source?: MemoryEntry['source']): Promise<void>;
+    delete(sessionId: string, key: string): Promise<void>;
+    clear(sessionId: string): Promise<void>;
+    private scheduleFlush;
+}
+export declare const memoryStore: MemoryStore;
+//# sourceMappingURL=memory-store.d.ts.map

package/dist/orchestration/memory-store.js

@@ -0,0 +1,102 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { LOCAL_HOME_DIR } from '../constants.js';
+import { logger } from '../utils/logger.js';
+export class MemoryStore {
+    cache = new Map();
+    pendingFlush = new Map();
+    pendingLoad = new Map();
+    filePath(sessionId) {
+        return path.join(LOCAL_HOME_DIR, 'sessions', sessionId, 'memory.json');
+    }
+    async load(sessionId) {
+        if (this.cache.has(sessionId))
+            return;
+        const inFlight = this.pendingLoad.get(sessionId);
+        if (inFlight)
+            return inFlight;
+        const loadPromise = (async () => {
+            const fp = this.filePath(sessionId);
+            try {
+                const raw = await fs.readFile(fp, 'utf8');
+                const obj = JSON.parse(raw);
+                if (!this.cache.has(sessionId)) {
+                    this.cache.set(sessionId, new Map(Object.entries(obj)));
+                }
+            }
+            catch (error) {
+                const code = error.code;
+                if (code !== 'ENOENT') {
+                    logger.warn('MemoryStore load failed; starting empty', { sessionId, error: error.message });
+                }
+                if (!this.cache.has(sessionId)) {
+                    this.cache.set(sessionId, new Map());
+                }
+            }
+            finally {
+                this.pendingLoad.delete(sessionId);
+            }
+        })();
+        this.pendingLoad.set(sessionId, loadPromise);
+        return loadPromise;
+    }
+    get(sessionId, key) {
+        return this.cache.get(sessionId)?.get(key) ?? null;
+    }
+    all(sessionId) {
+        const map = this.cache.get(sessionId);
+        if (!map)
+            return {};
+        return Object.fromEntries(map);
+    }
+    bySource(sessionId, source) {
+        const map = this.cache.get(sessionId);
+        if (!map)
+            return [];
+        return Array.from(map.values()).filter(e => e.source === source);
+    }
+    async set(sessionId, key, value, source) {
+        if (!this.cache.has(sessionId))
+            await this.load(sessionId);
+        const map = this.cache.get(sessionId);
+        map.set(key, { writtenAt: new Date().toISOString(), source, value });
+        await this.scheduleFlush(sessionId);
+    }
+    async delete(sessionId, key) {
+        const map = this.cache.get(sessionId);
+        if (!map)
+            return;
+        map.delete(key);
+        await this.scheduleFlush(sessionId);
+    }
+    async clear(sessionId) {
+        this.cache.delete(sessionId);
+        const fp = this.filePath(sessionId);
+        await fs.rm(fp, { force: true }).catch(() => { });
+    }
+    async scheduleFlush(sessionId) {
+        const existing = this.pendingFlush.get(sessionId);
+        if (existing)
+            return existing;
+        const flushPromise = (async () => {
+            await new Promise(resolve => setTimeout(resolve, 0));
+            this.pendingFlush.delete(sessionId);
+            const map = this.cache.get(sessionId);
+            if (!map)
+                return;
+            const fp = this.filePath(sessionId);
+            try {
+                await fs.mkdir(path.dirname(fp), { recursive: true });
+                const obj = Object.fromEntries(map);
+                await fs.writeFile(fp, JSON.stringify(obj, null, 2), 'utf8');
+            }
+            catch (error) {
+                logger.warn('MemoryStore flush failed', { sessionId, error: error.message });
+            }
+        })();
+        this.pendingFlush.set(sessionId, flushPromise);
+        return flushPromise;
+    }
+}
+export const memoryStore = new MemoryStore();
+//# sourceMappingURL=memory-store.js.map