snow-flow 4.2.0 → 4.2.2

package/dist/mcp/advanced/servicenow-advanced-features-mcp.js

@@ -1826,7 +1826,7 @@ class ServiceNowAdvancedFeaturesMCP extends base_mcp_server_js_1.BaseMCPServer {
                 params: {
                     sysparm_query: `name=${tableName}^internal_type=reference`,
                     sysparm_fields: 'element,column_label,reference,reference.name,reference.label,mandatory,active',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             for (const field of response.result) {
@@ -1872,7 +1872,7 @@ class ServiceNowAdvancedFeaturesMCP extends base_mcp_server_js_1.BaseMCPServer {
                 params: {
                     sysparm_query: `reference=${tableName}^internal_type=reference`,
                     sysparm_fields: 'name,element,column_label,mandatory,active',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             // Group by table
@@ -2335,7 +2335,7 @@ class ServiceNowAdvancedFeaturesMCP extends base_mcp_server_js_1.BaseMCPServer {
                 params: {
                     sysparm_query: `name=${tableName}^ORname=${tableName}.parent`,
                     sysparm_fields: 'element,column_label,internal_type,max_length,mandatory,unique,reference',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             const schema = {
@@ -2868,7 +2868,7 @@ class ServiceNowAdvancedFeaturesMCP extends base_mcp_server_js_1.BaseMCPServer {
                 params: {
                     sysparm_query: query,
                     sysparm_fields: 'element,column_label,internal_type,mandatory,max_length,read_only,display',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             return response.result || [];
@@ -3523,7 +3523,7 @@ class ServiceNowAdvancedFeaturesMCP extends base_mcp_server_js_1.BaseMCPServer {
                 params: {
                     sysparm_query: `name=${tableName}^active=true`,
                     sysparm_fields: 'element,column_label,internal_type,max_length,mandatory,read_only,reference,default_value,unique,primary',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             const fields = fieldsResponse.result.map((field) => ({
@@ -4553,7 +4553,7 @@ WHERE ${m.target_field} IS NULL;`).join('\n')}`;
                 params: {
                     sysparm_query: `name=${tableName}^active=true`,
                     sysparm_fields: 'element,column_label,internal_type,max_length,mandatory,read_only,reference,default_value,unique,primary,virtual,calculated,formula,depends_on,choice,dependent_on_field,spell_check',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             // Get record count and basic stats
@@ -4673,7 +4673,7 @@ WHERE ${m.target_field} IS NULL;`).join('\n')}`;
                 params: {
                     sysparm_query: `name=${tableName}^active=true`,
                     sysparm_fields: 'element,internal_type,mandatory,max_length,reference',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             const fields = schemaResponse.result;
@@ -10152,7 +10152,7 @@ function getIncidentsByUser(userSysId) {
                 params: {
                     sysparm_query: auditQuery,
                     sysparm_fields: 'tablename,fieldname,oldvalue,newvalue,sys_created_on,sys_created_by,documentkey',
-                    sysparm_limit: 5000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             if (auditResult.success && auditResult.result?.result) {
@@ -10201,7 +10201,7 @@ function getIncidentsByUser(userSysId) {
                 params: {
                     sysparm_query: workflowQuery,
                     sysparm_fields: 'context,workflow_version,state,started,sys_created_on,sys_created_by',
-                    sysparm_limit: 2000
+                    sysparm_limit: 100000 // Remove artificial 10k limit0 // Remove artificial 2k limit
                 }
             });
             if (workflowResult.success && workflowResult.result?.result) {
@@ -11109,7 +11109,7 @@ function getIncidentsByUser(userSysId) {
                 params: {
                     sysparm_query: query,
                     sysparm_fields: 'sys_id,name,description,table,condition,active,category,workflow_version,published',
-                    sysparm_limit: 1000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             if (workflowResult.success && workflowResult.result?.result) {
@@ -11227,7 +11227,7 @@ function getIncidentsByUser(userSysId) {
                 params: {
                     sysparm_query: executionQuery,
                     sysparm_fields: 'sys_id,workflow_version,context,state,started,ended,duration,priority,sys_created_on,sys_created_by',
-                    sysparm_limit: 10000
+                    sysparm_limit: 100000 // Remove artificial limit0
                 }
             });
             if (executionsResult.success && executionsResult.result?.result) {
@@ -11248,7 +11248,7 @@ function getIncidentsByUser(userSysId) {
                 params: {
                     sysparm_query: executionQuery.replace('wf_executing', 'wf_history'),
                     sysparm_fields: 'sys_id,workflow_version,context,state,started,ended,duration,result',
-                    sysparm_limit: 5000
+                    sysparm_limit: 100000 // Remove artificial limit
                 }
             });
             if (historyResult.success && historyResult.result?.result) {

package/dist/mcp/bridge.d.ts

@@ -0,0 +1,10 @@
+export interface MCPStartup {
+    cmd: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export declare function loadMCPTools(start: MCPStartup): Promise<{
+    tools: any[];
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/mcp/bridge.js

@@ -0,0 +1,31 @@
+"use strict";
+// Minimal MCP bridge placeholder. We will hook this into AI SDK tools in a next step.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMCPTools = loadMCPTools;
+async function loadMCPTools(start) {
+    // Prefer using AI SDK's experimental MCP client to yield ready-to-use Tool[]
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { experimental_createMCPClient } = require('ai');
+        // Use SDK-provided stdio transport
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio');
+        const client = await experimental_createMCPClient({
+            name: 'snow-flow',
+            transport: new StdioClientTransport({
+                command: start.cmd,
+                args: start.args ?? [],
+                env: start.env ?? {},
+            }),
+        });
+        const tools = await client.tools();
+        return { tools, close: client.close };
+    }
+    catch (err) {
+        // Fallback: no AI SDK available, return empty tools and noop close but with a hint.
+        const hint = 'AI SDK MCP bridge not available. Install "ai" or verify version to enable MCP tools.';
+        console.warn(`[snow-flow] ${hint}`);
+        return { tools: [], close: async () => { } };
+    }
+}
+//# sourceMappingURL=bridge.js.map

package/dist/mcp/servicenow-development-assistant-mcp.js

@@ -2131,7 +2131,7 @@ class ServiceNowDevelopmentAssistantMCP {
             // Estimate token count (rough estimate: 1 token ≈ 4 characters)
             const jsonString = JSON.stringify(formattedArtifact, null, 2);
             const estimatedTokens = Math.ceil(jsonString.length / 4);
-            const maxTokens = 25000; // MCP response limit
+            const maxTokens = 200000; // Claude's actual context window limit
             let responseText;
             if (estimatedTokens > maxTokens) {
                 // Response too large - return essential fields only and suggest specific field access

package/dist/mcp/servicenow-machine-learning-mcp.js

@@ -2157,7 +2157,7 @@ class ServiceNowMachineLearningMCP {
         startDate.setDate(startDate.getDate() - days);
         const queryParams = {
             sysparm_query: `sys_created_on>=${startDate.toISOString()}^sys_created_on<=${endDate.toISOString()}`,
-            sysparm_limit: 1000
+            sysparm_limit: 100000
         };
         let tableName = '';
         switch (metricType) {
@@ -2689,7 +2689,7 @@ class ServiceNowMachineLearningMCP {
                 sysparm_breakdown: breakdown || '',
                 sysparm_from: new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
                 sysparm_to: new Date().toISOString().split('T')[0],
-                sysparm_limit: 1000
+                sysparm_limit: 100000
             });
             return {
                 content: [{

package/dist/mcp/servicenow-reporting-analytics-mcp.js

@@ -1124,7 +1124,7 @@ class ServiceNowReportingAnalyticsMCP {
     }
     async getReportData(report, maxRows) {
         // Simulate getting report data
-        const limit = maxRows || 1000;
+        const limit = maxRows || 100000; // Remove artificial 1k limit
         const data = await this.client.searchRecords(report.table, report.conditions || '', limit);
         return data.success ? data.data.result : [];
     }

package/dist/mcp/shared/mcp-types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MCP Types
+ * Common types for MCP server implementations
+ */
+export interface MCPServerConfig {
+    name: string;
+    description?: string;
+    version?: string;
+}
+export interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: any;
+}
+export interface MCPResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    message?: string;
+}
+export interface MCPRequest {
+    tool: string;
+    params: any;
+}
+export interface MCPLogger {
+    info(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}
+export interface MCPMemoryManager {
+    store(key: string, value: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    list(): Promise<string[]>;
+}
+//# sourceMappingURL=mcp-types.d.ts.map

package/dist/mcp/shared/mcp-types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * MCP Types
+ * Common types for MCP server implementations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=mcp-types.js.map

package/dist/mcp/shared/response-limiter.js

@@ -112,5 +112,5 @@ exports.ResponseLimiter = ResponseLimiter;
 // Configurable via environment variable, default to 500KB (reasonable for widgets/flows)
 ResponseLimiter.MAX_RESPONSE_SIZE = parseInt(process.env.MCP_MAX_RESPONSE_SIZE || '500000'); // 500KB default
 ResponseLimiter.MAX_ARRAY_ITEMS = parseInt(process.env.MCP_MAX_ARRAY_ITEMS || '500'); // 500 items default
-ResponseLimiter.MAX_TOKEN_ESTIMATE = 125000; // ~500KB / 4 chars per token
+ResponseLimiter.MAX_TOKEN_ESTIMATE = 200000; // Claude's actual 200k context window
 //# sourceMappingURL=response-limiter.js.map

package/dist/memory/hierarchical-memory-system.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Hierarchical Memory System
+ * Extended memory system with hierarchical organization
+ */
+import { MemorySystem } from './memory-system.js';
+export interface HierarchicalMemorySystem extends MemorySystem {
+    dbPath?: string;
+    namespace?: string;
+    cache?: any;
+    ttl?: number;
+    storeInNamespace(namespace: string, key: string, value: any): Promise<void>;
+    retrieveFromNamespace(namespace: string, key: string): Promise<any>;
+    listNamespaces(): Promise<string[]>;
+    clearNamespace(namespace: string): Promise<void>;
+    storeHierarchical?(path: string, data: any): Promise<void>;
+    getHierarchical?(path: string): Promise<any>;
+    search?(pattern: string): Promise<any[]>;
+    getAgentMemory?(agentId: string): Promise<any>;
+    trackAccessPattern?(key: string): Promise<void>;
+    createRelationship?(from: string, to: string, type: string): Promise<void>;
+    getNamespaceStats?(namespace: string): Promise<any>;
+    cleanupExpired?(): Promise<void>;
+}
+export declare class DefaultHierarchicalMemorySystem implements HierarchicalMemorySystem {
+    private memory;
+    dbPath?: string;
+    namespace?: string;
+    constructor(dbPath?: string, namespace?: string);
+    private getNamespaceMap;
+    store(key: string, value: any): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+    storeInNamespace(namespace: string, key: string, value: any): Promise<void>;
+    retrieveFromNamespace(namespace: string, key: string): Promise<any>;
+    listNamespaces(): Promise<string[]>;
+    clearNamespace(namespace: string): Promise<void>;
+}
+//# sourceMappingURL=hierarchical-memory-system.d.ts.map

package/dist/memory/hierarchical-memory-system.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Hierarchical Memory System
+ * Extended memory system with hierarchical organization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultHierarchicalMemorySystem = void 0;
+class DefaultHierarchicalMemorySystem {
+    constructor(dbPath, namespace) {
+        this.memory = new Map();
+        this.dbPath = dbPath;
+        this.namespace = namespace || 'default';
+    }
+    getNamespaceMap(namespace) {
+        if (!this.memory.has(namespace)) {
+            this.memory.set(namespace, new Map());
+        }
+        return this.memory.get(namespace);
+    }
+    async store(key, value) {
+        await this.storeInNamespace(this.namespace || 'default', key, value);
+    }
+    async retrieve(key) {
+        return this.retrieveFromNamespace(this.namespace || 'default', key);
+    }
+    async get(key) {
+        return this.retrieve(key);
+    }
+    async delete(key) {
+        const nsMap = this.getNamespaceMap(this.namespace || 'default');
+        return nsMap.delete(key);
+    }
+    async clear() {
+        await this.clearNamespace(this.namespace || 'default');
+    }
+    async list() {
+        const nsMap = this.getNamespaceMap(this.namespace || 'default');
+        return Array.from(nsMap.keys());
+    }
+    async exists(key) {
+        const nsMap = this.getNamespaceMap(this.namespace || 'default');
+        return nsMap.has(key);
+    }
+    async storeInNamespace(namespace, key, value) {
+        const nsMap = this.getNamespaceMap(namespace);
+        nsMap.set(key, value);
+    }
+    async retrieveFromNamespace(namespace, key) {
+        const nsMap = this.getNamespaceMap(namespace);
+        return nsMap.get(key);
+    }
+    async listNamespaces() {
+        return Array.from(this.memory.keys());
+    }
+    async clearNamespace(namespace) {
+        this.memory.delete(namespace);
+    }
+}
+exports.DefaultHierarchicalMemorySystem = DefaultHierarchicalMemorySystem;
+//# sourceMappingURL=hierarchical-memory-system.js.map

package/dist/memory/memory-system.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Basic Memory System Interface
+ * Minimal implementation to satisfy missing imports
+ */
+export interface MemorySystem {
+    store(key: string, value: any, ttl?: number): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+    query?(query: string): Promise<any[]>;
+    execute?(sql: string): Promise<any>;
+    insert?(table: string, data: any): Promise<any>;
+    getDatabaseStats?(): Promise<any>;
+    getCacheStats?(): Promise<any>;
+    initialize?(): Promise<void>;
+    close?(): Promise<void>;
+    invalidateCache?(key: string): Promise<void>;
+    createEmergencyBackup?(): Promise<string>;
+}
+export declare class BasicMemorySystem implements MemorySystem {
+    private memory;
+    store(key: string, value: any, ttl?: number): Promise<void>;
+    retrieve(key: string): Promise<any>;
+    get(key: string): Promise<any>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    list(): Promise<string[]>;
+    exists(key: string): Promise<boolean>;
+}
+export declare const defaultMemorySystem: BasicMemorySystem;
+//# sourceMappingURL=memory-system.d.ts.map

package/dist/memory/memory-system.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Basic Memory System Interface
+ * Minimal implementation to satisfy missing imports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMemorySystem = exports.BasicMemorySystem = void 0;
+class BasicMemorySystem {
+    constructor() {
+        this.memory = new Map();
+    }
+    async store(key, value, ttl) {
+        this.memory.set(key, value);
+    }
+    async retrieve(key) {
+        return this.memory.get(key);
+    }
+    async get(key) {
+        return this.memory.get(key);
+    }
+    async delete(key) {
+        return this.memory.delete(key);
+    }
+    async clear() {
+        this.memory.clear();
+    }
+    async list() {
+        return Array.from(this.memory.keys());
+    }
+    async exists(key) {
+        return this.memory.has(key);
+    }
+}
+exports.BasicMemorySystem = BasicMemorySystem;
+exports.defaultMemorySystem = new BasicMemorySystem();
+//# sourceMappingURL=memory-system.js.map

package/dist/memory/snow-flow-memory-patterns.d.ts

@@ -1,33 +1,52 @@
 /**
- * Snow-Flow Memory Patterns - Stub Implementation
- * Minimal implementation to support Queen Memory System
+ * Snow-Flow Memory Patterns
+ * Common memory patterns and utilities for Snow-Flow
  */
+export interface MemoryPattern {
+    pattern: string;
+    namespace: string;
+    type: string;
+}
+export declare const MEMORY_PATTERNS: {
+    readonly AGENT: "agent/*";
+    readonly TASK: "task/*";
+    readonly SESSION: "session/*";
+    readonly ARTIFACT: "artifact/*";
+    readonly CONFIG: "config/*";
+    readonly TEMP: "temp/*";
+};
+export declare const MEMORY_NAMESPACES: {
+    readonly QUEEN: "queen";
+    readonly AGENTS: "agents";
+    readonly TASKS: "tasks";
+    readonly SESSIONS: "sessions";
+    readonly ARTIFACTS: "artifacts";
+    readonly CONFIG: "config";
+    readonly TEMP: "temp";
+};
+export declare function createMemoryKey(namespace: string, type: string, id: string): string;
+export declare function parseMemoryKey(key: string): {
+    namespace: string;
+    type: string;
+    id: string;
+} | null;
+export declare function matchesPattern(key: string, pattern: string): boolean;
 export declare class SnowFlowMemoryOrganizer {
-    static getWidgetMemoryStructure(name: string): {
-        key: string;
-        patterns: string[];
-        context: {
-            type: string;
-            name: string;
-        };
-    };
-    static getFlowMemoryStructure(name: string): {
-        key: string;
-        patterns: string[];
-        context: {
-            type: string;
-            name: string;
-        };
-    };
-    static getScriptMemoryStructure(name: string, scriptType?: string): {
-        key: string;
-        patterns: string[];
-        context: {
-            type: string;
-            name: string;
-            scriptType: string;
-        };
-    };
-    static generateKey(category: string, type: string, name: string): string;
+    static organize(data: any): any;
+}
+export declare const SNOW_FLOW_AGENT_CAPABILITIES: {
+    RESEARCHER: string;
+    CODER: string;
+    ANALYST: string;
+};
+export interface HierarchicalMemoryEntry {
+    key: string;
+    value: any;
+    namespace: string;
+}
+export interface MemorySearchOptions {
+    pattern?: string;
+    limit?: number;
+    namespace?: string;
 }
 //# sourceMappingURL=snow-flow-memory-patterns.d.ts.map

package/dist/memory/snow-flow-memory-patterns.js

@@ -1,35 +1,56 @@
 "use strict";
 /**
- * Snow-Flow Memory Patterns - Stub Implementation
- * Minimal implementation to support Queen Memory System
+ * Snow-Flow Memory Patterns
+ * Common memory patterns and utilities for Snow-Flow
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnowFlowMemoryOrganizer = void 0;
-class SnowFlowMemoryOrganizer {
-    static getWidgetMemoryStructure(name) {
-        return {
-            key: this.generateKey('artifacts', 'widget', name),
-            patterns: ['template', 'script', 'client_script'],
-            context: { type: 'widget', name }
-        };
-    }
-    static getFlowMemoryStructure(name) {
-        return {
-            key: this.generateKey('artifacts', 'flow', name),
-            patterns: ['actions', 'conditions', 'variables'],
-            context: { type: 'flow', name }
-        };
-    }
-    static getScriptMemoryStructure(name, scriptType = 'server') {
+exports.SNOW_FLOW_AGENT_CAPABILITIES = exports.SnowFlowMemoryOrganizer = exports.MEMORY_NAMESPACES = exports.MEMORY_PATTERNS = void 0;
+exports.createMemoryKey = createMemoryKey;
+exports.parseMemoryKey = parseMemoryKey;
+exports.matchesPattern = matchesPattern;
+exports.MEMORY_PATTERNS = {
+    AGENT: 'agent/*',
+    TASK: 'task/*',
+    SESSION: 'session/*',
+    ARTIFACT: 'artifact/*',
+    CONFIG: 'config/*',
+    TEMP: 'temp/*'
+};
+exports.MEMORY_NAMESPACES = {
+    QUEEN: 'queen',
+    AGENTS: 'agents',
+    TASKS: 'tasks',
+    SESSIONS: 'sessions',
+    ARTIFACTS: 'artifacts',
+    CONFIG: 'config',
+    TEMP: 'temp'
+};
+function createMemoryKey(namespace, type, id) {
+    return `${namespace}/${type}/${id}`;
+}
+function parseMemoryKey(key) {
+    const parts = key.split('/');
+    if (parts.length >= 3) {
         return {
-            key: this.generateKey('artifacts', 'script', name),
-            patterns: ['functions', 'variables', 'dependencies'],
-            context: { type: 'script', name, scriptType }
+            namespace: parts[0],
+            type: parts[1],
+            id: parts.slice(2).join('/')
         };
     }
-    static generateKey(category, type, name) {
-        return `${category}:${type}:${name}`;
-    }
+    return null;
+}
+function matchesPattern(key, pattern) {
+    const regex = new RegExp(pattern.replace('*', '.*'));
+    return regex.test(key);
+}
+// Export stub implementations for compatibility
+class SnowFlowMemoryOrganizer {
+    static organize(data) { return data; }
 }
 exports.SnowFlowMemoryOrganizer = SnowFlowMemoryOrganizer;
+exports.SNOW_FLOW_AGENT_CAPABILITIES = {
+    RESEARCHER: 'researcher',
+    CODER: 'coder',
+    ANALYST: 'analyst'
+};
 //# sourceMappingURL=snow-flow-memory-patterns.js.map

package/dist/session/store.d.ts

@@ -0,0 +1,47 @@
+export interface SessionMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    timestamp: string;
+    meta?: Record<string, unknown>;
+}
+export interface SessionRecord {
+    id: string;
+    startedAt: string;
+    endedAt?: string;
+    objective: string;
+    provider: {
+        id: string;
+        model: string;
+        baseURL?: string;
+    };
+    mcp: {
+        cmd: string;
+        args?: string[];
+    };
+    messages: SessionMessage[];
+    toolEvents?: {
+        name: string;
+        when: string;
+        argsPreview?: string;
+        resultPreview?: string;
+    }[];
+    summary?: string;
+}
+export declare function createSessionId(): string;
+export declare function startSession(rec: Omit<SessionRecord, 'messages' | 'toolEvents'> & {
+    messages?: SessionMessage[];
+}): SessionRecord;
+export declare function readSession(id: string): SessionRecord | undefined;
+export declare function listSessions(): {
+    id: string;
+    startedAt: string;
+    objective: string;
+}[];
+export declare function appendMessage(id: string, msg: SessionMessage): void;
+export declare function appendToolEvent(id: string, ev: {
+    name: string;
+    argsPreview?: string;
+    resultPreview?: string;
+}): void;
+export declare function endSession(id: string, summary?: string): void;
+//# sourceMappingURL=store.d.ts.map