adaptive-memory-multi-model-router 1.2.2 → 1.3.1

package/tmlpd-pi-extension/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/tmlpd-pi-extension/dist/index.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * TMLPD PI Extension - v1.1.0
+ *
+ * Parallel Multi-LLM Processing with Streaming, Caching, Cost Tracking, Reliability
+ * + Reference Architecture to Full TMLPD (Episodic Memory, MCTS, HALO)
+ *
+ * @example
+ * ```typescript
+ * import { createTMLPD, HALOOrchestrator, EpisodicMemoryStore } from "tmlpd-pi";
+ *
+ * // Lightweight usage (core features)
+ * const tmlpd = createTMLPD({ cache: { ttl_seconds: 3600 } });
+ * const result = await tmlpd.executeParallel(prompt, ["gpt-4o", "claude"]);
+ *
+ * // Advanced: HALO orchestration with episodic memory
+ * const halo = new HALOOrchestrator({ maxConcurrent: 3, enableMCTS: true });
+ * const haloResult = await halo.execute("Build a REST API", async (subtask, agent) => {
+ *   // Execute via agent
+ * });
+ *
+ * // Query episodic memory
+ * const similar = memory.getSimilarTasks("Python async API", 5);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TMLPD_PI_TOOLS = exports.EagleSpeculative = exports.MedusaPredictor = exports.estimateSpeedupPotential = exports.speculativeBatch = exports.SpeculativeDecoder = exports.createWarmedCache = exports.PrefixCache = exports.MODEL_PROFILES = exports.updateModelProfile = exports.extractQueryFeatures = exports.recommendForTask = exports.routeBatch = exports.routeQuery = exports.executeBatch = exports.BatchProcessor = exports.createLMStudioProvider = exports.createVLLMProvider = exports.createOllamaProvider = exports.LocalProviderManager = exports.LocalProvider = exports.calculateCompressionRatio = exports.truncateToTokenBudget = exports.truncateMessages = exports.compressText = exports.isonDecode = exports.isonEncode = exports.MODEL_COSTS = exports.findCheapestModels = exports.listModelsByCost = exports.getModelCost = exports.estimateCostFromText = exports.estimateCost = exports.countTokens = exports.HALOOrchestrator = exports.MCTSWorkflowOptimizer = exports.EpisodicMemoryStore = exports.DEFAULT_RETRY_CONFIG = exports.isRetryableStatus = exports.calculateRetryDelay = exports.withRetry = exports.CircuitBreaker = exports.ProviderRegistry = exports.CostTracker = exports.ResponseCache = exports.TMLPDTools = exports.createTMLPD = void 0;
+const tmlpdTools_1 = require("./tools/tmlpdTools");
+Object.defineProperty(exports, "createTMLPD", { enumerable: true, get: function () { return tmlpdTools_1.createTMLPD; } });
+Object.defineProperty(exports, "TMLPDTools", { enumerable: true, get: function () { return tmlpdTools_1.TMLPDTools; } });
+const responseCache_1 = require("./cache/responseCache");
+Object.defineProperty(exports, "ResponseCache", { enumerable: true, get: function () { return responseCache_1.ResponseCache; } });
+const costTracker_1 = require("./cost/costTracker");
+Object.defineProperty(exports, "CostTracker", { enumerable: true, get: function () { return costTracker_1.CostTracker; } });
+const registry_1 = require("./providers/registry");
+Object.defineProperty(exports, "ProviderRegistry", { enumerable: true, get: function () { return registry_1.ProviderRegistry; } });
+const reliability_1 = require("./utils/reliability");
+Object.defineProperty(exports, "CircuitBreaker", { enumerable: true, get: function () { return reliability_1.CircuitBreaker; } });
+Object.defineProperty(exports, "withRetry", { enumerable: true, get: function () { return reliability_1.withRetry; } });
+Object.defineProperty(exports, "calculateRetryDelay", { enumerable: true, get: function () { return reliability_1.calculateRetryDelay; } });
+Object.defineProperty(exports, "isRetryableStatus", { enumerable: true, get: function () { return reliability_1.isRetryableStatus; } });
+Object.defineProperty(exports, "DEFAULT_RETRY_CONFIG", { enumerable: true, get: function () { return reliability_1.DEFAULT_RETRY_CONFIG; } });
+const episodicMemory_1 = require("./memory/episodicMemory");
+Object.defineProperty(exports, "EpisodicMemoryStore", { enumerable: true, get: function () { return episodicMemory_1.EpisodicMemoryStore; } });
+const mctsWorkflow_1 = require("./orchestration/mctsWorkflow");
+Object.defineProperty(exports, "MCTSWorkflowOptimizer", { enumerable: true, get: function () { return mctsWorkflow_1.MCTSWorkflowOptimizer; } });
+const haloOrchestrator_1 = require("./orchestration/haloOrchestrator");
+Object.defineProperty(exports, "HALOOrchestrator", { enumerable: true, get: function () { return haloOrchestrator_1.HALOOrchestrator; } });
+const tokenUtils_1 = require("./utils/tokenUtils");
+Object.defineProperty(exports, "countTokens", { enumerable: true, get: function () { return tokenUtils_1.countTokens; } });
+Object.defineProperty(exports, "estimateCost", { enumerable: true, get: function () { return tokenUtils_1.estimateCost; } });
+Object.defineProperty(exports, "estimateCostFromText", { enumerable: true, get: function () { return tokenUtils_1.estimateCostFromText; } });
+Object.defineProperty(exports, "getModelCost", { enumerable: true, get: function () { return tokenUtils_1.getModelCost; } });
+Object.defineProperty(exports, "listModelsByCost", { enumerable: true, get: function () { return tokenUtils_1.listModelsByCost; } });
+Object.defineProperty(exports, "findCheapestModels", { enumerable: true, get: function () { return tokenUtils_1.findCheapestModels; } });
+Object.defineProperty(exports, "MODEL_COSTS", { enumerable: true, get: function () { return tokenUtils_1.MODEL_COSTS; } });
+const compression_1 = require("./utils/compression");
+Object.defineProperty(exports, "isonEncode", { enumerable: true, get: function () { return compression_1.isonEncode; } });
+Object.defineProperty(exports, "isonDecode", { enumerable: true, get: function () { return compression_1.isonDecode; } });
+Object.defineProperty(exports, "compressText", { enumerable: true, get: function () { return compression_1.compressText; } });
+Object.defineProperty(exports, "truncateMessages", { enumerable: true, get: function () { return compression_1.truncateMessages; } });
+Object.defineProperty(exports, "truncateToTokenBudget", { enumerable: true, get: function () { return compression_1.truncateToTokenBudget; } });
+Object.defineProperty(exports, "calculateCompressionRatio", { enumerable: true, get: function () { return compression_1.calculateCompressionRatio; } });
+const localProvider_1 = require("./providers/localProvider");
+Object.defineProperty(exports, "LocalProvider", { enumerable: true, get: function () { return localProvider_1.LocalProvider; } });
+Object.defineProperty(exports, "LocalProviderManager", { enumerable: true, get: function () { return localProvider_1.LocalProviderManager; } });
+Object.defineProperty(exports, "createOllamaProvider", { enumerable: true, get: function () { return localProvider_1.createOllamaProvider; } });
+Object.defineProperty(exports, "createVLLMProvider", { enumerable: true, get: function () { return localProvider_1.createVLLMProvider; } });
+Object.defineProperty(exports, "createLMStudioProvider", { enumerable: true, get: function () { return localProvider_1.createLMStudioProvider; } });
+const batchProcessor_1 = require("./utils/batchProcessor");
+Object.defineProperty(exports, "BatchProcessor", { enumerable: true, get: function () { return batchProcessor_1.BatchProcessor; } });
+Object.defineProperty(exports, "executeBatch", { enumerable: true, get: function () { return batchProcessor_1.executeBatch; } });
+const advancedRouter_1 = require("./routing/advancedRouter");
+Object.defineProperty(exports, "routeQuery", { enumerable: true, get: function () { return advancedRouter_1.routeQuery; } });
+Object.defineProperty(exports, "routeBatch", { enumerable: true, get: function () { return advancedRouter_1.routeBatch; } });
+Object.defineProperty(exports, "recommendForTask", { enumerable: true, get: function () { return advancedRouter_1.recommendForTask; } });
+Object.defineProperty(exports, "extractQueryFeatures", { enumerable: true, get: function () { return advancedRouter_1.extractQueryFeatures; } });
+Object.defineProperty(exports, "updateModelProfile", { enumerable: true, get: function () { return advancedRouter_1.updateModelProfile; } });
+Object.defineProperty(exports, "MODEL_PROFILES", { enumerable: true, get: function () { return advancedRouter_1.MODEL_PROFILES; } });
+const prefixCache_1 = require("./cache/prefixCache");
+Object.defineProperty(exports, "PrefixCache", { enumerable: true, get: function () { return prefixCache_1.PrefixCache; } });
+Object.defineProperty(exports, "createWarmedCache", { enumerable: true, get: function () { return prefixCache_1.createWarmedCache; } });
+const speculativeDecoding_1 = require("./utils/speculativeDecoding");
+Object.defineProperty(exports, "SpeculativeDecoder", { enumerable: true, get: function () { return speculativeDecoding_1.SpeculativeDecoder; } });
+Object.defineProperty(exports, "speculativeBatch", { enumerable: true, get: function () { return speculativeDecoding_1.speculativeBatch; } });
+Object.defineProperty(exports, "estimateSpeedupPotential", { enumerable: true, get: function () { return speculativeDecoding_1.estimateSpeedupPotential; } });
+Object.defineProperty(exports, "MedusaPredictor", { enumerable: true, get: function () { return speculativeDecoding_1.MedusaPredictor; } });
+Object.defineProperty(exports, "EagleSpeculative", { enumerable: true, get: function () { return speculativeDecoding_1.EagleSpeculative; } });
+// PI Tool definitions (for PI agent integration)
+exports.TMLPD_PI_TOOLS = [
+    {
+        name: "tmlpd_execute",
+        description: "Execute prompt across multiple LLM providers in parallel. Optimizes for cost-quality tradeoff with automatic model selection. Use when comparing multiple AI responses or needing faster results via parallel execution.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "The prompt to execute" },
+                models: { type: "array", items: { type: "string" }, description: "Optional model list (auto-selects if omitted)" },
+                streaming: { type: "object", properties: { enabled: { type: "boolean" }, chunk_size: { type: "number" } } }
+            },
+            required: ["prompt"]
+        }
+    },
+    {
+        name: "tmlpd_execute_single",
+        description: "Execute with single model via smart routing. Analyzes prompt to select optimal agent based on task type (coding, explanation, analysis, etc.) with cost-quality optimization.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "The prompt to execute" },
+                model: { type: "string", description: "Optional specific model" }
+            },
+            required: ["prompt"]
+        }
+    },
+    {
+        name: "tmlpd_cost_summary",
+        description: "Get real-time cost tracking summary. Shows spending by provider, model, daily/monthly breakdowns, and remaining budget. Essential for cost monitoring in production.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "tmlpd_cache_stats",
+        description: "Get response cache statistics. Shows hit rate, cache size, and effectiveness. Cache hits cost $0 and provide instant responses.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "tmlpd_provider_status",
+        description: "Get status of all configured LLM providers. Shows readiness, cooldown status, failure counts. Use for debugging or selecting specific providers.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "tmlpd_invalidate_cache",
+        description: "Invalidate cached responses. Use when prompt content has changed and fresh response needed, or to clear stale cache entries.",
+        inputSchema: {
+            type: "object",
+            properties: { model: { type: "string", description: "Optional model to invalidate (all if omitted)" } }
+        }
+    },
+    {
+        name: "tmlpd_get_budget",
+        description: "Get remaining budget for cost controls. Returns daily, monthly, and per-model limits. Use for budget enforcement and alerting.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "tmlpd_halo_execute",
+        description: "Execute via HALO (Hierarchical Autonomous Logic-Oriented) orchestrator with 3-tier planning: decompose → assign → execute. Includes episodic memory for learning from past executions. For complex multi-step tasks.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task_description: { type: "string", description: "Task to execute" },
+                max_concurrent: { type: "number", description: "Max parallel executions (default: 3)" },
+                enable_mcts: { type: "boolean", description: "Enable MCTS optimization (slower but better)" }
+            },
+            required: ["task_description"]
+        }
+    },
+    {
+        name: "tmlpd_episodic_query",
+        description: "Query episodic memory for similar past tasks. Useful for learning from past executions and improving future routing decisions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task_description: { type: "string", description: "Task to find similar executions for" },
+                limit: { type: "number", description: "Max results (default: 5)" }
+            },
+            required: ["task_description"]
+        }
+    },
+    {
+        name: "tmlpd_count_tokens",
+        description: "Count tokens in text for cost estimation. Supports all major models (GPT-4, Claude, Gemini, Llama). Use for estimating costs before execution or calculating context window usage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string", description: "Text to count tokens in" },
+                model: { type: "string", description: "Model for tokenization (default: gpt-4o)" }
+            },
+            required: ["text"]
+        }
+    },
+    {
+        name: "tmlpd_compress_context",
+        description: "Compress context/messages using ISON encoding for token reduction. Reduces context by ~20-40% while preserving meaning. Useful for fitting more content in context windows.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                messages: { type: "array", description: "Messages to compress", items: { type: "object" } },
+                strategy: { type: "string", enum: ["smart", "first", "last"], description: "Compression strategy (default: smart)" },
+                max_tokens: { type: "number", description: "Target token budget" }
+            },
+            required: ["messages"]
+        }
+    },
+    {
+        name: "tmlpd_local_generate",
+        description: "Generate using local LLM runtime (Ollama, vLLM, LM Studio). Zero cost, privacy-preserving. Use for development, testing, or when local GPU available. Falls back to cloud if local unavailable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "Prompt for generation" },
+                runtime: { type: "string", enum: ["ollama", "vllm", "lmstudio"], description: "Local runtime type" },
+                model: { type: "string", description: "Model name (default: llama-3.3-70b)" }
+            },
+            required: ["prompt", "runtime"]
+        }
+    },
+    {
+        name: "tmlpd_batch_execute",
+        description: "Execute batch of prompts with concurrency control. Supports priority queuing, progress callbacks, rate limiting. Use for processing multiple prompts efficiently.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompts: { type: "array", items: { type: "string" }, description: "Prompts to execute" },
+                concurrency: { type: "number", description: "Max parallel executions (default: 5)" },
+                model: { type: "string", description: "Model to use (default: gpt-4o)" }
+            },
+            required: ["prompts"]
+        }
+    }
+];
+/**
+ * Reference to Full TMLPD
+ *
+ * This package provides:
+ * - Core: streaming, caching, cost tracking, reliability
+ * - Reference: episodic memory, MCTS, HALO orchestrator
+ *
+ * For production with full features:
+ * - Python TMLPD: https://github.com/Das-rebel/tmlpd-skill
+ * - Full memory: 3-tier (episodic + semantic + working)
+ * - Full MCTS: UCB1, deterministic rollouts, strategy caching
+ * - Full HALO: NLP decomposition, capability matching, verification
+ */
+exports.default = {
+    createTMLPD: tmlpdTools_1.createTMLPD,
+    TMLPDTools: tmlpdTools_1.TMLPDTools,
+    TMLPD_PI_TOOLS: exports.TMLPD_PI_TOOLS
+};
+//# sourceMappingURL=index.js.map

package/tmlpd-pi-extension/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/tmlpd-pi-extension/dist/memory/episodicMemory.d.ts

@@ -0,0 +1,82 @@
+/**
+ * TMLPD Episodic Memory Store
+ *
+ * Stores specific task executions with full context.
+ * Reference implementation - for full features see TMLPD v2.x
+ *
+ * Full TMLPD includes:
+ * - JSON-based episodic storage with keyword indexing
+ * - Importance scoring and time-based decay
+ * - Episodic retrieval by task similarity
+ */
+export interface EpisodicEntry {
+    id: string;
+    timestamp: number;
+    task: {
+        description: string;
+        type: string;
+        complexity: number;
+    };
+    result: {
+        success: boolean;
+        output: string;
+        duration_ms: number;
+    };
+    agent: {
+        id: string;
+        model: string;
+        provider: string;
+    };
+    metadata: Record<string, any>;
+    importance: number;
+}
+export interface MemoryQuery {
+    task_type?: string;
+    keywords?: string[];
+    limit?: number;
+}
+export declare class EpisodicMemoryStore {
+    private entries;
+    private maxEntries;
+    private keywordIndex;
+    constructor(maxEntries?: number);
+    /**
+     * Store an episodic memory
+     */
+    store(entry: Omit<EpisodicEntry, "id" | "timestamp">): string;
+    /**
+     * Query episodic memories
+     */
+    query(query: MemoryQuery): EpisodicEntry[];
+    /**
+     * Get similar tasks (for learning)
+     */
+    getSimilarTasks(taskDescription: string, limit?: number): EpisodicEntry[];
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        total_entries: number;
+        indexed_keywords: number;
+        success_rate: number;
+        avg_duration_ms: number;
+    };
+    /**
+     * Clear all memories
+     */
+    clear(): void;
+}
+/**
+ * Reference to Full TMLPD Memory System
+ *
+ * For production use with full features:
+ * - Install: npm install tmlpd-skill (Python)
+ * - Or integrate with tmlpd-clean/src/memory/
+ *
+ * Full features include:
+ * - Semantic memory with ChromaDB vector embeddings
+ * - Time-based importance decay (A-Mem pattern)
+ * - Cross-session learning
+ * - Episodic + Semantic + Working 3-tier architecture
+ */ 
+//# sourceMappingURL=episodicMemory.d.ts.map

package/tmlpd-pi-extension/dist/memory/episodicMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"episodicMemory.d.ts","sourceRoot":"","sources":["../../src/memory/episodicMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE;QACJ,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,MAAM,EAAE;QACN,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,KAAK,EAAE;QACL,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAwB;gBAEhC,UAAU,SAAO;IAK7B;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,MAAM;IAyC7D;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,EAAE;IAyB1C;;OAEG;IACH,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,aAAa,EAAE;IAwBpE;;OAEG;IACH,QAAQ;;;;;;IASR;;OAEG;IACH,KAAK;CAIN;AAED;;;;;;;;;;;;GAYG"}

package/tmlpd-pi-extension/dist/memory/episodicMemory.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * TMLPD Episodic Memory Store
+ *
+ * Stores specific task executions with full context.
+ * Reference implementation - for full features see TMLPD v2.x
+ *
+ * Full TMLPD includes:
+ * - JSON-based episodic storage with keyword indexing
+ * - Importance scoring and time-based decay
+ * - Episodic retrieval by task similarity
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EpisodicMemoryStore = void 0;
+const nanoid_1 = require("nanoid");
+class EpisodicMemoryStore {
+    entries = [];
+    maxEntries;
+    keywordIndex;
+    constructor(maxEntries = 1000) {
+        this.maxEntries = maxEntries;
+        this.keywordIndex = new Map();
+    }
+    /**
+     * Store an episodic memory
+     */
+    store(entry) {
+        const id = (0, nanoid_1.nanoid)(12);
+        const fullEntry = {
+            ...entry,
+            id,
+            timestamp: Date.now()
+        };
+        this.entries.push(fullEntry);
+        // Index keywords
+        if (entry.task.description) {
+            const words = entry.task.description.toLowerCase().split(/\s+/);
+            words.forEach(word => {
+                if (word.length > 3) {
+                    const existing = this.keywordIndex.get(word) || [];
+                    existing.push(id);
+                    this.keywordIndex.set(word, existing);
+                }
+            });
+        }
+        // Evict oldest if at capacity
+        if (this.entries.length > this.maxEntries) {
+            const evicted = this.entries.shift();
+            if (evicted) {
+                // Clean up keyword index for evicted entry
+                for (const [word, ids] of this.keywordIndex.entries()) {
+                    const filtered = ids.filter(existingId => existingId !== evicted.id);
+                    if (filtered.length === 0) {
+                        this.keywordIndex.delete(word);
+                    }
+                    else {
+                        this.keywordIndex.set(word, filtered);
+                    }
+                }
+            }
+        }
+        return id;
+    }
+    /**
+     * Query episodic memories
+     */
+    query(query) {
+        let results = [...this.entries];
+        if (query.task_type) {
+            results = results.filter(e => e.task.type === query.task_type);
+        }
+        if (query.keywords && query.keywords.length > 0) {
+            const matchingIds = new Set();
+            query.keywords.forEach(kw => {
+                const lower = kw.toLowerCase();
+                for (const [word, ids] of this.keywordIndex.entries()) {
+                    if (word.includes(lower)) {
+                        ids.forEach(id => matchingIds.add(id));
+                    }
+                }
+            });
+            if (matchingIds.size > 0) {
+                results = results.filter(e => matchingIds.has(e.id));
+            }
+        }
+        return results.slice(-(query.limit || 10));
+    }
+    /**
+     * Get similar tasks (for learning)
+     */
+    getSimilarTasks(taskDescription, limit = 5) {
+        const words = taskDescription.toLowerCase().split(/\s+/);
+        const scores = new Map();
+        this.entries.forEach(entry => {
+            let score = 0;
+            const entryWords = entry.task.description.toLowerCase().split(/\s+/);
+            words.forEach(w => {
+                if (entryWords.includes(w))
+                    score++;
+            });
+            if (score > 0) {
+                scores.set(entry.id, score);
+            }
+        });
+        const sorted = Array.from(scores.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, limit)
+            .map(([id]) => this.entries.find(e => e.id === id))
+            .filter(Boolean);
+        return sorted;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            total_entries: this.entries.length,
+            indexed_keywords: this.keywordIndex.size,
+            success_rate: this.entries.filter(e => e.result.success).length / Math.max(1, this.entries.length),
+            avg_duration_ms: this.entries.reduce((sum, e) => sum + e.result.duration_ms, 0) / Math.max(1, this.entries.length)
+        };
+    }
+    /**
+     * Clear all memories
+     */
+    clear() {
+        this.entries = [];
+        this.keywordIndex.clear();
+    }
+}
+exports.EpisodicMemoryStore = EpisodicMemoryStore;
+/**
+ * Reference to Full TMLPD Memory System
+ *
+ * For production use with full features:
+ * - Install: npm install tmlpd-skill (Python)
+ * - Or integrate with tmlpd-clean/src/memory/
+ *
+ * Full features include:
+ * - Semantic memory with ChromaDB vector embeddings
+ * - Time-based importance decay (A-Mem pattern)
+ * - Cross-session learning
+ * - Episodic + Semantic + Working 3-tier architecture
+ */ 
+//# sourceMappingURL=episodicMemory.js.map

package/tmlpd-pi-extension/dist/memory/episodicMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"episodicMemory.js","sourceRoot":"","sources":["../../src/memory/episodicMemory.ts"],"names":[],"mappings":"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"}

package/tmlpd-pi-extension/dist/orchestration/haloOrchestrator.d.ts

@@ -0,0 +1,102 @@
+/**
+ * TMLPD HALO Orchestrator Reference
+ *
+ * Hierarchical Autonomous Logic-Oriented Orchestration
+ *
+ * Reference implementation - for full features see TMLPD v2.x
+ *
+ * Full TMLPD includes:
+ * - 3-tier hierarchical planning
+ * - TaskPlanner: Decompose with dependencies
+ * - RoleAssigner: Specialized agent assignment
+ * - ExecutionEngine: Parallel with verification
+ * - 19.6% improvement on complex tasks
+ */
+export interface SubTask {
+    id: string;
+    description: string;
+    dependencies: string[];
+    estimatedComplexity: number;
+}
+export interface AgentAssignment {
+    subtaskId: string;
+    agentId: string;
+    model: string;
+    estimatedDuration: number;
+}
+export interface ExecutionResult {
+    subtaskId: string;
+    success: boolean;
+    output: string;
+    duration_ms: number;
+}
+export interface HALOConfig {
+    maxConcurrent: number;
+    optimizationTarget: "quality" | "cost" | "balanced";
+    enableMCTS: boolean;
+}
+/**
+ * HALO Orchestrator
+ *
+ * Hierarchical orchestration with 3 tiers:
+ * 1. Plan: Decompose task into subtasks with dependencies
+ * 2. Assign: Match subtasks to optimal agents
+ * 3. Execute: Run in parallel with result verification
+ */
+export declare class HALOOrchestrator {
+    private config;
+    private memory;
+    private mcts;
+    constructor(config?: Partial<HALOConfig>);
+    /**
+     * Execute task with HALO orchestration
+     */
+    execute(taskDescription: string, executeFn: (subtask: SubTask, agentId: string) => Promise<ExecutionResult>): Promise<{
+        success: boolean;
+        results: ExecutionResult[];
+        strategy: Record<string, string>;
+        metadata: any;
+    }>;
+    /**
+     * Decompose task into subtasks
+     */
+    decomposeTask(taskDescription: string): SubTask[];
+    /**
+     * Classify task type
+     */
+    classifyTask(description: string): string;
+    /**
+     * Quick agent assignment without MCTS
+     */
+    quickAssign(subtasks: SubTask[]): Record<string, string>;
+    /**
+     * Optimize assignment with MCTS
+     */
+    private optimizeWithMCTS;
+    /**
+     * Execute subtasks in parallel with concurrency limit
+     */
+    private executeParallel;
+    /**
+     * Get memory statistics
+     */
+    getMemoryStats(): {
+        total_entries: number;
+        indexed_keywords: number;
+        success_rate: number;
+        avg_duration_ms: number;
+    };
+}
+/**
+ * Reference to Full TMLPD HALO
+ *
+ * Full implementation in tmlpd-clean/src/orchestration/halo_orchestrator.py
+ *
+ * Features:
+ * - NLP-based task decomposition
+ * - Dependency graph resolution
+ * - Agent capability matching
+ * - Result verification and retry
+ * - Multi-round refinement for low confidence
+ */ 
+//# sourceMappingURL=haloOrchestrator.d.ts.map

package/tmlpd-pi-extension/dist/orchestration/haloOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"haloOrchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestration/haloOrchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,CAAC;IACpD,UAAU,EAAE,OAAO,CAAC;CACrB;AAQD;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,IAAI,CAAwB;gBAExB,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM;IAM5C;;OAEG;IACG,OAAO,CACX,eAAe,EAAE,MAAM,EACvB,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,GACzE,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,eAAe,EAAE,CAAC;QAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,QAAQ,EAAE,GAAG,CAAC;KACf,CAAC;IA2CF;;OAEG;IACH,aAAa,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,EAAE;IAkCjD;;OAEG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAUzC;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAgBxD;;OAEG;YACW,gBAAgB;IAkB9B;;OAEG;YACW,eAAe;IA6B7B;;OAEG;IACH,cAAc;;;;;;CAGf;AAED;;;;;;;;;;;GAWG"}