@nxuss/lemma 1.18.0 → 1.18.2

package/dist/esm/utils/ExecAuditLog.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ExecAuditLog — a persistent, append-only trail of every command Lemma ran or refused to
+ * run, and every file it wrote, outside of what any single session's in-memory ledger keeps.
+ *
+ * TokenReceipt's sessionLedger (../utils/TokenReceipt.ts) records similar events but only
+ * in a module-scoped array capped at 2000 entries and lost on process restart — fine for
+ * "what did this session just do", useless for "what has Lemma ever done in this workspace".
+ * This file exists so that question has a real, on-disk answer: same `~/.lemma-cache/`
+ * convention as SavingsLedger, but append-only JSONL rather than whole-file rewrite, so a
+ * crash mid-session can't lose prior entries.
+ */
+export type ExecAuditTool = "run_workspace_command" | "write_workspace_file" | "create_workspace_file" | "apply_workspace_patch";
+export interface ExecAuditEntry {
+    tool: ExecAuditTool;
+    /** Command text for run_workspace_command, resolved file path for write/create/patch tools. */
+    detail: string;
+    allowed: boolean;
+    /** Only set for run_workspace_command once it actually ran. */
+    exitCode?: number | null;
+    reason?: string;
+    timestamp: string;
+}
+export declare function recordExecAudit(entry: Omit<ExecAuditEntry, "timestamp">): void;
+/** Reads back the audit trail. Exposed mainly for tests; the file itself is plain JSONL. */
+export declare function readExecAuditLog(limit?: number): ExecAuditEntry[];
+export declare function getExecAuditLogPath(): string;
+//# sourceMappingURL=ExecAuditLog.d.ts.map

package/dist/esm/utils/ExecAuditLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecAuditLog.d.ts","sourceRoot":"","sources":["../../../src/utils/ExecAuditLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,MAAM,MAAM,aAAa,GACrB,uBAAuB,GACvB,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,+FAA+F;IAC/F,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,GAAG,IAAI,CAW9E;AAED,4FAA4F;AAC5F,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,cAAc,EAAE,CASjE;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/esm/utils/ExecAuditLog.js

@@ -0,0 +1,45 @@
+/**
+ * ExecAuditLog — a persistent, append-only trail of every command Lemma ran or refused to
+ * run, and every file it wrote, outside of what any single session's in-memory ledger keeps.
+ *
+ * TokenReceipt's sessionLedger (../utils/TokenReceipt.ts) records similar events but only
+ * in a module-scoped array capped at 2000 entries and lost on process restart — fine for
+ * "what did this session just do", useless for "what has Lemma ever done in this workspace".
+ * This file exists so that question has a real, on-disk answer: same `~/.lemma-cache/`
+ * convention as SavingsLedger, but append-only JSONL rather than whole-file rewrite, so a
+ * crash mid-session can't lose prior entries.
+ */
+import fs from "fs";
+import path from "path";
+const HOME = process.env.HOME || process.env.USERPROFILE || "~";
+const AUDIT_LOG_FILE = path.join(HOME, ".lemma-cache", "exec-audit.jsonl");
+export function recordExecAudit(entry) {
+    try {
+        const dir = path.dirname(AUDIT_LOG_FILE);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const line = JSON.stringify({ ...entry, timestamp: new Date().toISOString() });
+        fs.appendFileSync(AUDIT_LOG_FILE, line + "\n", "utf8");
+    }
+    catch {
+        // Auditing must never be why a legitimate action fails.
+    }
+}
+/** Reads back the audit trail. Exposed mainly for tests; the file itself is plain JSONL. */
+export function readExecAuditLog(limit) {
+    try {
+        if (!fs.existsSync(AUDIT_LOG_FILE))
+            return [];
+        const lines = fs.readFileSync(AUDIT_LOG_FILE, "utf8").split("\n").filter((l) => l.trim().length > 0);
+        const entries = lines.map((l) => JSON.parse(l));
+        return limit ? entries.slice(-limit) : entries;
+    }
+    catch {
+        return [];
+    }
+}
+export function getExecAuditLogPath() {
+    return AUDIT_LOG_FILE;
+}
+//# sourceMappingURL=ExecAuditLog.js.map

package/dist/esm/utils/ExecAuditLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecAuditLog.js","sourceRoot":"","sources":["../../../src/utils/ExecAuditLog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC;AAChE,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,EAAE,kBAAkB,CAAC,CAAC;AAmB3E,MAAM,UAAU,eAAe,CAAC,KAAwC;IACtE,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QACzC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QAC/E,EAAE,CAAC,cAAc,CAAC,cAAc,EAAE,IAAI,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;IACzD,CAAC;IAAC,MAAM,CAAC;QACP,wDAAwD;IAC1D,CAAC;AACH,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,CAAC;QACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC;YAAE,OAAO,EAAE,CAAC;QAC9C,MAAM,KAAK,GAAG,EAAE,CAAC,YAAY,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACrG,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAmB,CAAC,CAAC;QAClE,OAAO,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IACjD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,mBAAmB;IACjC,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/esm/utils/ExecutiveReport.js

@@ -7,7 +7,7 @@
  */
 import fs from 'fs';
 import path from 'path';
-import { savingsLedger } from './SavingsLedger';
+import { savingsLedger } from './SavingsLedger.js';
 /**
  * Calculates metrics and writes a highly structured Markdown corporate report.
  */

package/dist/esm/utils/OutputLedger.js

@@ -17,8 +17,8 @@
  * costs the user a correct answer.
  */
 import crypto from "crypto";
-import { shouldEmitDelta } from "./OutputDelta";
-import { getSharedEntry, setSharedEntry } from "./SharedLedgerStore";
+import { shouldEmitDelta } from "./OutputDelta.js";
+import { getSharedEntry, setSharedEntry } from "./SharedLedgerStore.js";
 const entries = new Map();
 /** Mirrors the read cache's bound: this exists to save tokens, not to grow forever. */
 const MAX_LEDGER_CHARS = 2000000;

package/dist/esm/utils/ReadWorkspaceCache.js

@@ -1,5 +1,5 @@
 import crypto from "crypto";
-import { getSharedEntry, setSharedEntry } from "./SharedLedgerStore";
+import { getSharedEntry, setSharedEntry } from "./SharedLedgerStore.js";
 // Session-scoped (lives for the MCP server process lifetime, which is normally the
 // whole conversation). Tracks the content hash we last actually sent back to the
 // model for a given (filePath, view) pair, so a second identical read doesn't

package/dist/esm/utils/SpeculativeWarmer.d.ts

@@ -9,7 +9,7 @@
  * every failure is swallowed — a warming run that throws or runs slow must never be visible
  * to whoever is waiting on the actual tool call.
  */
-import { AstSymbol } from "./AstSymbolCache";
+import { AstSymbol } from "./AstSymbolCache.js";
 /**
  * `extractSymbolsWithTsCompiler` lives in `mcp/tools.ts`, which already imports this module —
  * importing it back here would be circular. The dispatcher registers it once at startup instead.

package/dist/esm/utils/SpeculativeWarmer.js

@@ -11,8 +11,8 @@
  */
 import fs from "fs";
 import path from "path";
-import { buildDepGraphMap, bfsDepGraph } from "./DepGraph";
-import { getOrExtractSymbols, hasFreshEntry } from "./AstSymbolCache";
+import { buildDepGraphMap, bfsDepGraph } from "./DepGraph.js";
+import { getOrExtractSymbols, hasFreshEntry } from "./AstSymbolCache.js";
 /** How many neighbor files a single warm pass will touch — bounded so this stays cheap. */
 const MAX_NEIGHBORS = 8;
 const MAX_DEPTH = 1;

package/dist/esm/utils/StateHashCache.js

@@ -14,7 +14,7 @@
 import fs from 'fs';
 import path from 'path';
 import crypto from 'crypto';
-import { LocalFsResolver } from '../subconscious/freshness/LocalFsResolver';
+import { LocalFsResolver } from '../subconscious/freshness/LocalFsResolver.js';
 const CACHE_FILE = '.lemma/state-hash-cache.json';
 function getCachePath(projectRoot) {
     return path.join(projectRoot, CACHE_FILE);

package/dist/esm/utils/StructuralSearch.d.ts

@@ -1,4 +1,4 @@
-import type { SearchMatch } from "./WorkspaceSearch";
+import type { SearchMatch } from "./WorkspaceSearch.js";
 export interface DeclaredSymbol {
     kind: "function" | "class" | "method" | "interface" | "type" | "enum" | "arrow";
     name: string;

package/dist/esm/utils/SurgicalASTInsert.js

@@ -9,7 +9,7 @@
  */
 import fs from 'fs';
 import * as ts from 'typescript';
-import { safeResolvePath } from '../mcp/utils';
+import { safeResolvePath } from '../mcp/utils.js';
 /**
  * Finds a class or interface node by name.
  */

package/dist/esm/utils/SymbolSurgicalContext.js

@@ -10,7 +10,7 @@
 import fs from 'fs';
 import path from 'path';
 import * as ts from 'typescript';
-import { safeResolvePath } from '../mcp/utils';
+import { safeResolvePath } from '../mcp/utils.js';
 /**
  * Traverses AST to find the node defining the specified symbol name.
  */

package/dist/esm/utils/TestAutofixInterceptor.js

@@ -1,5 +1,5 @@
 import { execSync } from 'child_process';
-import { getBrain, deriveProjectId } from '../subconscious/TheBrainV2';
+import { getBrain, deriveProjectId } from '../subconscious/TheBrainV2.js';
 function extractFailures(output) {
     const failures = [];
     // Jest/Vitest failure pattern

package/dist/esm/utils/logger.js

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { config } from '../config';
+import { config } from '../config/index.js';
 /**
  * Log levels
  */

package/dist/esm/utils/reportSavings.js

@@ -8,7 +8,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import http from 'http';
-import { recordRoiSaved, recordRoiSpent } from './RoiLedger';
+import { recordRoiSaved, recordRoiSpent } from './RoiLedger.js';
 function getProxyPort() {
     try {
         const portFile = path.join(os.homedir(), '.lemma-cache/proxy.port');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxuss/lemma",
-  "version": "1.18.0",
+  "version": "1.18.2",
   "description": "Intelligent AI Gateway for IDEs & Agents — Semantic cache, Privacy Firewall, Infrastructure Command Center, and Autonomous Cost-Optimization.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -179,6 +179,7 @@
     "express": "^4.18.2",
     "openai": "^6.37.0",
     "pg": "^8.11.0",
+    "shell-quote": "^1.10.0",
     "socket.io": "^4.7.2",
     "typescript": "^5.3.3",
     "uuid": "^14.0.0"
@@ -195,6 +196,7 @@
     "@types/jest": "^29.5.11",
     "@types/node": "^20.11.0",
     "@types/pg": "^8.20.0",
+    "@types/shell-quote": "^1.7.5",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.5.10",
     "jest": "^29.7.0",

package/sdks/crewai/dist/crewai/src/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Lemma Crew Configuration
+ */
+export interface LemmaCrewConfig {
+    /** WebSocket URL of the Lemma router */
+    routerUrl: string;
+    /** Agent ID */
+    agentId: string;
+    /** Agent role (CrewAI concept) */
+    role: string;
+    /** Agent goal */
+    goal: string;
+    /** Agent backstory */
+    backstory?: string;
+    /** Capabilities this agent provides */
+    capabilities?: string[];
+    /** Enable verbose logging */
+    verbose?: boolean;
+    /** Allow task delegation */
+    allowDelegation?: boolean;
+}
+/**
+ * Task execution request
+ */
+export interface TaskRequest {
+    description: string;
+    expectedOutput?: string;
+    context?: any;
+    allowDelegation?: boolean;
+}
+/**
+ * Task execution result
+ */
+export interface TaskResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+    executionTime: number;
+    cached?: boolean;
+    similarity?: number;
+}
+/**
+ * CrewAI Agent integrated with Lemma Router
+ */
+export declare class LemmaCrewAgent {
+    private ws;
+    private config;
+    private connected;
+    private pendingTasks;
+    constructor(config: LemmaCrewConfig);
+    /**
+     * Connect to Lemma router
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from router
+     */
+    disconnect(): void;
+    /**
+     * Execute a task
+     */
+    execute(task: TaskRequest): Promise<TaskResult>;
+    /**
+     * Handle incoming message from router
+     */
+    private handleMessage;
+    /**
+     * Handle task assignment from router
+     */
+    private handleTaskAssign;
+    /**
+     * Handle task response from router
+     */
+    private handleTaskResponse;
+    /**
+     * Perform task (override in subclasses)
+     */
+    protected performTask(description: string, parameters: any): Promise<string>;
+    /**
+     * Send message to router
+     */
+    private send;
+    /**
+     * Log message if verbose
+     */
+    private log;
+    /**
+     * Get agent info
+     */
+    getInfo(): {
+        agentId: string;
+        role: string;
+        goal: string;
+        backstory: string;
+        capabilities: string[];
+    };
+}
+/**
+ * Lemma Crew - Multi-agent orchestration
+ */
+export interface LemmaCrewOptions {
+    routerUrl: string;
+    agents: Omit<LemmaCrewConfig, 'routerUrl'>[];
+    verbose?: boolean;
+}
+export declare class LemmaCrew {
+    private agents;
+    private config;
+    constructor(config: LemmaCrewOptions);
+    /**
+     * Connect all agents
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect all agents
+     */
+    disconnect(): void;
+    /**
+     * Execute a multi-agent workflow
+     */
+    kickoff(options: {
+        task: string;
+        process?: 'sequential' | 'hierarchical';
+    }): Promise<any>;
+    /**
+     * Get all agents
+     */
+    getAgents(): LemmaCrewAgent[];
+}
+export default LemmaCrewAgent;
+export * from './memory';

package/sdks/crewai/dist/crewai/src/index.js

@@ -0,0 +1,325 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LemmaCrew = exports.LemmaCrewAgent = void 0;
+const ws_1 = __importDefault(require("ws"));
+const uuid_1 = require("uuid");
+/**
+ * CrewAI Agent integrated with Lemma Router
+ */
+class LemmaCrewAgent {
+    constructor(config) {
+        this.ws = null;
+        this.connected = false;
+        this.pendingTasks = new Map();
+        this.config = {
+            routerUrl: config.routerUrl,
+            agentId: config.agentId,
+            role: config.role,
+            goal: config.goal,
+            backstory: config.backstory || '',
+            capabilities: config.capabilities || ['crewai'],
+            verbose: config.verbose || false,
+            allowDelegation: config.allowDelegation !== false,
+        };
+    }
+    /**
+     * Connect to Lemma router
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.ws = new ws_1.default(this.config.routerUrl);
+            this.ws.on('open', () => {
+                this.log('Connected to Lemma router');
+                // Send handshake
+                this.send({
+                    type: 'HANDSHAKE',
+                    messageId: (0, uuid_1.v4)(),
+                    timestamp: Date.now(),
+                    payload: {
+                        agentId: this.config.agentId,
+                        agentName: `${this.config.role} (CrewAI)`,
+                        version: '1.0.0',
+                        capabilities: this.config.capabilities.map(name => ({
+                            name,
+                            version: '1.0.0',
+                        })),
+                        metadata: {
+                            role: this.config.role,
+                            goal: this.config.goal,
+                            backstory: this.config.backstory,
+                            framework: 'crewai',
+                        },
+                    },
+                });
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(message);
+                    if (message.type === 'HANDSHAKE_ACK') {
+                        this.connected = true;
+                        this.log('Handshake acknowledged');
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    console.error('Error parsing message:', error);
+                }
+            });
+            this.ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+                if (!this.connected) {
+                    reject(error);
+                }
+            });
+            this.ws.on('close', () => {
+                this.connected = false;
+                this.log('Disconnected from router');
+            });
+            // Connection timeout
+            setTimeout(() => {
+                if (!this.connected) {
+                    reject(new Error('Connection timeout'));
+                }
+            }, 10000);
+        });
+    }
+    /**
+     * Disconnect from router
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this.connected = false;
+        }
+    }
+    /**
+     * Execute a task
+     */
+    async execute(task) {
+        if (!this.connected) {
+            throw new Error('Not connected to router. Call connect() first.');
+        }
+        const taskId = (0, uuid_1.v4)();
+        this.log(`Executing task: ${task.description}`);
+        return new Promise((resolve, reject) => {
+            this.pendingTasks.set(taskId, { resolve, reject });
+            // Send task request to router
+            this.send({
+                type: 'TASK_REQUEST',
+                messageId: (0, uuid_1.v4)(),
+                timestamp: Date.now(),
+                payload: {
+                    taskId,
+                    description: task.description,
+                    requiredCapabilities: this.config.capabilities,
+                    parameters: {
+                        expectedOutput: task.expectedOutput,
+                        context: task.context,
+                        allowDelegation: task.allowDelegation ?? this.config.allowDelegation,
+                    },
+                },
+            });
+        });
+    }
+    /**
+     * Handle incoming message from router
+     */
+    handleMessage(message) {
+        switch (message.type) {
+            case 'TASK_ASSIGN':
+                this.handleTaskAssign(message);
+                break;
+            case 'TASK_RESPONSE':
+                this.handleTaskResponse(message);
+                break;
+            case 'PING':
+                this.send({
+                    type: 'PONG',
+                    messageId: (0, uuid_1.v4)(),
+                    timestamp: Date.now(),
+                    payload: {
+                        originalMessageId: message.messageId,
+                    },
+                });
+                break;
+        }
+    }
+    /**
+     * Handle task assignment from router
+     */
+    async handleTaskAssign(message) {
+        const { taskId, description, parameters } = message.payload;
+        const startTime = Date.now();
+        this.log(`Received task assignment: ${description}`);
+        try {
+            // Execute the task (override this method in subclasses)
+            const output = await this.performTask(description, parameters);
+            // Send response back to router
+            this.send({
+                type: 'TASK_RESPONSE',
+                messageId: (0, uuid_1.v4)(),
+                timestamp: Date.now(),
+                payload: {
+                    taskId,
+                    success: true,
+                    result: output,
+                    executionTime: Date.now() - startTime,
+                    taskDescription: description,
+                },
+            });
+        }
+        catch (error) {
+            this.send({
+                type: 'TASK_RESPONSE',
+                messageId: (0, uuid_1.v4)(),
+                timestamp: Date.now(),
+                payload: {
+                    taskId,
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    executionTime: Date.now() - startTime,
+                },
+            });
+        }
+    }
+    /**
+     * Handle task response from router
+     */
+    handleTaskResponse(message) {
+        const { taskId, success, result, error, executionTime, cached, similarity } = message.payload;
+        const pending = this.pendingTasks.get(taskId);
+        if (!pending) {
+            return;
+        }
+        this.pendingTasks.delete(taskId);
+        if (success) {
+            this.log(`Task completed in ${executionTime}ms${cached ? ' (cached)' : ''}`);
+            pending.resolve({
+                success: true,
+                output: result,
+                executionTime,
+                cached,
+                similarity,
+            });
+        }
+        else {
+            pending.reject(new Error(error || 'Task failed'));
+        }
+    }
+    /**
+     * Perform task (override in subclasses)
+     */
+    async performTask(description, parameters) {
+        // Default implementation - subclasses should override
+        return `Task completed: ${description}`;
+    }
+    /**
+     * Send message to router
+     */
+    send(message) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected to router');
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    /**
+     * Log message if verbose
+     */
+    log(message) {
+        if (this.config.verbose) {
+            console.log(`[${this.config.role}] ${message}`);
+        }
+    }
+    /**
+     * Get agent info
+     */
+    getInfo() {
+        return {
+            agentId: this.config.agentId,
+            role: this.config.role,
+            goal: this.config.goal,
+            backstory: this.config.backstory,
+            capabilities: this.config.capabilities,
+        };
+    }
+}
+exports.LemmaCrewAgent = LemmaCrewAgent;
+class LemmaCrew {
+    constructor(config) {
+        this.agents = [];
+        this.config = config;
+        // Create agents
+        this.agents = config.agents.map(agentConfig => new LemmaCrewAgent({
+            ...agentConfig,
+            routerUrl: config.routerUrl,
+            verbose: config.verbose,
+        }));
+    }
+    /**
+     * Connect all agents
+     */
+    async connect() {
+        await Promise.all(this.agents.map(agent => agent.connect()));
+    }
+    /**
+     * Disconnect all agents
+     */
+    disconnect() {
+        this.agents.forEach(agent => agent.disconnect());
+    }
+    /**
+     * Execute a multi-agent workflow
+     */
+    async kickoff(options) {
+        const { task, process = 'sequential' } = options;
+        if (process === 'sequential') {
+            // Execute tasks sequentially through agents
+            let result = task;
+            for (const agent of this.agents) {
+                const taskResult = await agent.execute({
+                    description: result,
+                });
+                result = taskResult.output || result;
+            }
+            return result;
+        }
+        else {
+            // Hierarchical - first agent coordinates others
+            const manager = this.agents[0];
+            return await manager.execute({
+                description: task,
+                allowDelegation: true,
+            });
+        }
+    }
+    /**
+     * Get all agents
+     */
+    getAgents() {
+        return this.agents;
+    }
+}
+exports.LemmaCrew = LemmaCrew;
+exports.default = LemmaCrewAgent;
+// Lemma /v2 Verifiable Memory API — a separate surface from LemmaCrewAgent
+// above (that talks to the WebSocket orchestration router). See memory.ts.
+__exportStar(require("./memory"), exports);