@leverageaiapps/locus 2.2.9 → 2.3.0

package/dist/agent/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../../src/agent/agent-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAkBH,OAAO,KAAK,EACV,eAAe,EAChB,MAAM,SAAS,CAAC;AAcjB,wBAAgB,iBAAiB,IAAI,OAAO,CAI3C;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAI7E;AAED,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAsCD,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAketE"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../../src/agent/agent-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAsBH,OAAO,KAAK,EACV,eAAe,EAChB,MAAM,SAAS,CAAC;AA+KjB,wBAAgB,iBAAiB,IAAI,OAAO,CAI3C;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAI7E;AAED,wBAAgB,SAAS,IAAI,OAAO,CAEnC;AAsCD,wBAAsB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAykBtE"}

package/dist/agent/agent-loop.js

@@ -52,6 +52,8 @@ exports.isRunning = isRunning;
 exports.runAgentLoop = runAgentLoop;
 const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
 const worker_proxy_1 = require("./worker-proxy");
 const claude_client_1 = require("./claude-client");
 const tool_defs_1 = require("./tool-defs");
@@ -61,6 +63,167 @@ const types_1 = require("./types");
 const crypto = __importStar(require("node:crypto"));
 // ─── Memory Path ────────────────────────────────────────────────
 const MEMORY_DIR = `${(0, node_os_1.homedir)()}/.leverage/memory`;
+// ─── Platform Detection (ported from container-agent) ────────────
+function detectLocalPlatform() {
+    const p = (0, node_os_1.platform)();
+    if (p === 'darwin')
+        return 'macOS';
+    if (p === 'win32')
+        return 'Windows';
+    if (p === 'linux')
+        return 'Linux';
+    return p;
+}
+function macosVersion() {
+    try {
+        const res = (0, node_child_process_1.spawnSync)('sw_vers', ['-productVersion'], {
+            encoding: 'utf-8', timeout: 1000, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const out = typeof res.stdout === 'string' ? res.stdout.trim() : '';
+        return out || (0, node_os_1.release)();
+    }
+    catch {
+        return (0, node_os_1.release)();
+    }
+}
+function detectShell() {
+    if ((0, node_os_1.platform)() === 'win32') {
+        try {
+            const res = (0, node_child_process_1.spawnSync)('pwsh', ['--version'], {
+                encoding: 'utf-8', timeout: 1000, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            if (res.status === 0)
+                return 'pwsh';
+        }
+        catch { }
+        return 'powershell';
+    }
+    const envShell = process.env.SHELL?.trim();
+    return envShell ? (0, node_path_1.basename)(envShell) : 'sh';
+}
+/** Build Runtime line for system prompt (like OpenClaw's buildRuntimeLine) */
+function buildRuntimeLine() {
+    const p = (0, node_os_1.platform)();
+    const parts = [];
+    try {
+        parts.push(`host=${(0, node_os_1.hostname)()}`);
+    }
+    catch { }
+    let osLabel;
+    if (p === 'darwin') {
+        osLabel = `macOS ${macosVersion()}`;
+    }
+    else if (p === 'win32') {
+        osLabel = `Windows ${(0, node_os_1.release)()}`;
+    }
+    else {
+        osLabel = `${p} ${(0, node_os_1.release)()}`;
+    }
+    parts.push(`os=${osLabel} (${(0, node_os_1.arch)()})`);
+    parts.push(`shell=${detectShell()}`);
+    parts.push(`node=${process.version}`);
+    parts.push(`home=${(0, node_os_1.homedir)()}`);
+    // Timezone (useful for scheduling and user context)
+    try {
+        const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        if (tz)
+            parts.push(`timezone=${tz}`);
+    }
+    catch { }
+    // Current time
+    try {
+        const now = new Date();
+        parts.push(`time=${now.toLocaleString('en-US', { hour12: false })}`);
+    }
+    catch { }
+    return `Runtime: ${parts.join(' | ')}`;
+}
+// ─── CJK keyword extraction (ported from container-agent) ────────
+const LOCAL_STOP_EN = new Set([
+    'a', 'an', 'the', 'is', 'am', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+    'do', 'does', 'did', 'will', 'would', 'shall', 'should', 'may', 'might', 'must', 'can', 'could',
+    'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'him', 'his', 'she', 'her', 'it', 'its', 'they', 'them', 'their',
+    'this', 'that', 'these', 'those', 'what', 'which', 'who', 'whom', 'where', 'when', 'how', 'why',
+    'not', 'no', 'nor', 'if', 'then', 'than', 'too', 'very', 'just', 'about', 'all', 'also', 'and', 'any', 'as',
+    'at', 'but', 'by', 'for', 'from', 'in', 'into', 'of', 'on', 'or', 'so', 'to', 'with',
+    'please', 'help', 'find', 'show', 'tell', 'give', 'want', 'need', 'know', 'think', 'like',
+]);
+const LOCAL_STOP_ZH = new Set([
+    '我', '我们', '你', '你们', '他', '她', '它', '他们', '这', '那', '这个', '那个',
+    '的', '了', '着', '过', '得', '地', '吗', '呢', '吧', '啊', '哦', '呀', '嗯',
+    '是', '有', '在', '做', '说', '看', '找', '想', '要', '能', '会', '可以',
+    '和', '与', '或', '但', '因为', '所以', '如果', '但是', '而且',
+    '把', '被', '让', '给', '到', '从', '对', '比', '跟', '为', '用',
+    '都', '也', '就', '才', '又', '再', '还', '已经', '很', '太', '最', '更',
+    '什么', '哪个', '怎么', '为什么', '请', '帮', '帮忙', '告诉', '知道',
+]);
+const LOCAL_STOP_JA = new Set([
+    'の', 'に', 'は', 'を', 'た', 'が', 'で', 'て', 'と', 'し', 'れ', 'さ', 'ある', 'いる', 'も',
+    'する', 'から', 'な', 'こと', 'い', 'や', 'など', 'なっ', 'ない', 'この', 'その', 'また',
+    'です', 'ます', 'ました', 'でした', 'ません', 'それ', 'あれ', 'ここ', 'そこ', 'どこ',
+]);
+const LOCAL_STOP_KO = new Set([
+    '이', '그', '저', '것', '수', '등', '들', '및', '에', '의', '가', '은', '는', '로', '를',
+    '와', '과', '도', '만', '에서', '으로', '하다', '있다', '되다', '않다', '이다', '합니다',
+]);
+const LOCAL_STOP_ES = new Set([
+    'el', 'la', 'los', 'las', 'un', 'una', 'y', 'o', 'pero', 'de', 'en', 'a', 'por', 'para', 'con', 'que', 'se', 'es', 'no',
+]);
+const LOCAL_STOP_PT = new Set([
+    'o', 'a', 'os', 'as', 'um', 'uma', 'e', 'ou', 'mas', 'de', 'em', 'por', 'para', 'com', 'que', 'se', 'é', 'não',
+]);
+const RE_ANY_CJK_LOCAL = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u1100-\u11ff\u3130-\u318f]/;
+const RE_CJK_LOCAL = /[\u4e00-\u9fff]/;
+const RE_HIRAGANA_LOCAL = /[\u3040-\u309f]/;
+const RE_KATAKANA_LOCAL = /[\u30a0-\u30ff]/;
+const RE_HANGUL_LOCAL = /[\uac00-\ud7af\u1100-\u11ff\u3130-\u318f]/;
+function isLocalStopWord(t) {
+    return LOCAL_STOP_EN.has(t) || LOCAL_STOP_ZH.has(t) ||
+        LOCAL_STOP_JA.has(t) || LOCAL_STOP_KO.has(t) ||
+        LOCAL_STOP_ES.has(t) || LOCAL_STOP_PT.has(t);
+}
+function extractLocalKeywords(query) {
+    const tokens = [];
+    const segments = query.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u1100-\u11ff\u3130-\u318f]+|[^\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af\u1100-\u11ff\u3130-\u318f]+/g) || [];
+    for (const seg of segments) {
+        if (RE_ANY_CJK_LOCAL.test(seg)) {
+            const chars = Array.from(seg);
+            for (const c of chars) {
+                if (RE_CJK_LOCAL.test(c) || RE_HIRAGANA_LOCAL.test(c) || RE_KATAKANA_LOCAL.test(c) || RE_HANGUL_LOCAL.test(c)) {
+                    tokens.push(c);
+                }
+            }
+            for (let i = 0; i < chars.length - 1; i++) {
+                const a = chars[i], b = chars[i + 1];
+                if ((RE_CJK_LOCAL.test(a) && RE_CJK_LOCAL.test(b)) ||
+                    (RE_HIRAGANA_LOCAL.test(a) && RE_HIRAGANA_LOCAL.test(b)) ||
+                    (RE_KATAKANA_LOCAL.test(a) && RE_KATAKANA_LOCAL.test(b)) ||
+                    (RE_HANGUL_LOCAL.test(a) && RE_HANGUL_LOCAL.test(b))) {
+                    tokens.push(a + b);
+                }
+            }
+        }
+        else {
+            const words = seg.toLowerCase().match(/[\p{L}\p{N}_]+/gu) || [];
+            tokens.push(...words);
+        }
+    }
+    const seen = new Set();
+    const kws = [];
+    for (const t of tokens) {
+        if (isLocalStopWord(t))
+            continue;
+        if (t.length < 2 && !RE_ANY_CJK_LOCAL.test(t))
+            continue;
+        if (/^\d+$/.test(t))
+            continue;
+        if (seen.has(t))
+            continue;
+        seen.add(t);
+        kws.push(t);
+    }
+    return kws;
+}
 // ─── State ───────────────────────────────────────────────────────
 let cancelled = false;
 let currentTaskId = null;
@@ -166,7 +329,14 @@ async function runAgentLoop(req) {
             }
         }
         catch { }
-        const ctx = await proxy.loadContext(sandboxId, conversationId, isCronTask, memoryContent, '', req.workingDirectory);
+        // Detect platform locally (more accurate than iOS-passed value)
+        const detectedPlatform = detectLocalPlatform();
+        const ctx = await proxy.loadContext(sandboxId, conversationId, isCronTask, memoryContent, '', req.workingDirectory, true, detectedPlatform);
+        // Inject runtime info into system prompt (like OpenClaw's buildRuntimeLine)
+        // Gives Claude exact details: OS version, arch, shell, node, home dir
+        const runtimeLine = buildRuntimeLine();
+        ctx.systemPrompt = runtimeLine + '\n\n' + ctx.systemPrompt;
+        console.log(`[Agent] ${runtimeLine}`);
         // Build messages array
         if (ctx.conversationHistory.length > 0) {
             messages.push(...ctx.conversationHistory);
@@ -186,6 +356,13 @@ async function runAgentLoop(req) {
         messages.push({ role: 'user', content: userContent.length === 1 ? cronPrefix + message : userContent });
         const systemPrompt = ctx.systemPrompt;
         let fullOutput = '';
+        // Usage accumulator — tracks total token usage across all API calls in this task
+        const accumulatedUsage = {
+            input_tokens: 0,
+            output_tokens: 0,
+            cache_read_input_tokens: 0,
+            cache_creation_input_tokens: 0,
+        };
         // Emit connected event
         await emitEvent(proxy, taskId, userId, conversationId, 'connected', {
             request_id: taskId,
@@ -193,8 +370,10 @@ async function runAgentLoop(req) {
         });
         const loopStartTime = Date.now();
         let compactionCount = 0;
+        let lastTurn = 0;
         // ─── Agentic Loop ────────────────────────────────────────
         for (let turn = 0; turn < types_1.MAX_AGENT_TURNS; turn++) {
+            lastTurn = turn;
             if (cancelled) {
                 await emitEvent(proxy, taskId, userId, conversationId, 'done', { finish_reason: 'cancelled' });
                 break;
@@ -377,6 +556,13 @@ async function runAgentLoop(req) {
                 break;
             }
             console.log(`[Agent] Turn ${turn}: stop_reason=${response.stop_reason}, blocks=${response.content.length}, usage=${JSON.stringify(response.usage)}`);
+            // Accumulate usage from this API call
+            if (response.usage) {
+                accumulatedUsage.input_tokens += response.usage.input_tokens || 0;
+                accumulatedUsage.output_tokens += response.usage.output_tokens || 0;
+                accumulatedUsage.cache_read_input_tokens += response.usage.cache_read_input_tokens || 0;
+                accumulatedUsage.cache_creation_input_tokens += response.usage.cache_creation_input_tokens || 0;
+            }
             // Turn 0: retry with tool_choice='any' if text-only
             const hasAnyToolUse = response.content.some((b) => b.type === 'tool_use' || b.type === 'server_tool_use');
             if (turn === 0 && !hasAnyToolUse && response.stop_reason === 'end_turn') {
@@ -394,6 +580,13 @@ async function runAgentLoop(req) {
                     });
                     if (retryResponse.content.length > 0) {
                         response = retryResponse;
+                        // Accumulate retry usage
+                        if (retryResponse.usage) {
+                            accumulatedUsage.input_tokens += retryResponse.usage.input_tokens || 0;
+                            accumulatedUsage.output_tokens += retryResponse.usage.output_tokens || 0;
+                            accumulatedUsage.cache_read_input_tokens += retryResponse.usage.cache_read_input_tokens || 0;
+                            accumulatedUsage.cache_creation_input_tokens += retryResponse.usage.cache_creation_input_tokens || 0;
+                        }
                     }
                     else {
                         console.log('[Agent] Turn 0 retry returned empty, keeping original text response');
@@ -491,8 +684,58 @@ async function runAgentLoop(req) {
                 console.error(`[Agent] Failed to save turn: ${err.message}`);
             }
         }
-        // Mark task completed
-        await proxy.updateTaskStatus('completed');
+        // Transcript digest + session log: write to daily log for searchability
+        try {
+            const today = new Date().toISOString().split('T')[0];
+            const filePath = `${MEMORY_DIR}/${today}.md`;
+            const timestamp = new Date().toLocaleTimeString('en-US', { hour12: false });
+            await (0, promises_1.mkdir)(MEMORY_DIR, { recursive: true });
+            // 1. Lightweight transcript digest
+            const digest = (0, compaction_1.buildTranscriptDigest)(messages, message, lastTurn + 1, accumulatedUsage);
+            await (0, promises_1.appendFile)(filePath, `\n## [transcript] ${timestamp}\n${digest}\n`, 'utf-8');
+            // 2. Session log for keyword searchability
+            const sessionLog = (0, compaction_1.buildEnrichedSnippet)(messages, 8000);
+            if (sessionLog.length > 200) {
+                await (0, promises_1.appendFile)(filePath, `\n## [session-log] ${timestamp}\n${sessionLog}\n`, 'utf-8');
+            }
+            // R2 backup (fire-and-forget)
+            const full = await (0, promises_1.readFile)(filePath, 'utf-8').catch(() => '');
+            proxy.memoryOp('backup_memory', filePath, full).catch(() => { });
+            proxy.memorySync(`${today}.md`, full).catch(() => { });
+        }
+        catch { }
+        // Post-task memory flush: extract key info → daily log (fire-and-forget)
+        (0, compaction_1.postTaskMemoryFlush)(messages, chatFn, async (content) => {
+            const today = new Date().toISOString().split('T')[0];
+            const filePath = `${MEMORY_DIR}/${today}.md`;
+            const entry = `\n## [task-summary] ${new Date().toLocaleTimeString('en-US', { hour12: false })}\n${content}\n`;
+            try {
+                await (0, promises_1.mkdir)(MEMORY_DIR, { recursive: true });
+                await (0, promises_1.appendFile)(filePath, entry, 'utf-8');
+                // R2 backup (fire-and-forget)
+                const full = await (0, promises_1.readFile)(filePath, 'utf-8').catch(() => content);
+                proxy.memoryOp('backup_memory', filePath, full).catch(() => { });
+                proxy.memorySync(`${today}.md`, full).catch(() => { });
+                console.log(`[Memory] Post-task flush: saved to ${filePath} + R2 backup`);
+            }
+            catch (writeErr) {
+                console.warn(`[Memory] Post-task flush write failed: ${writeErr.message}`);
+            }
+        }).catch(() => { });
+        // Auto-distill MEMORY.md if it's grown too large (fire-and-forget)
+        (0, compaction_1.autoDistillMemory)(MEMORY_DIR, chatFn, async (distilled) => {
+            try {
+                await (0, promises_1.writeFile)(`${MEMORY_DIR}/MEMORY.md`, distilled, 'utf-8');
+                proxy.memoryOp('backup_memory', `${MEMORY_DIR}/MEMORY.md`, distilled).catch(() => { });
+                proxy.memorySync('MEMORY.md', distilled).catch(() => { });
+            }
+            catch (err) {
+                console.warn(`[Memory] Failed to write distilled MEMORY.md: ${err.message}`);
+            }
+        }).catch(() => { });
+        // Mark task completed — pass accumulated usage for credit deduction
+        console.log(`[Agent] Task ${taskId} completed. Total usage: in=${accumulatedUsage.input_tokens} out=${accumulatedUsage.output_tokens} cacheRead=${accumulatedUsage.cache_read_input_tokens} cacheWrite=${accumulatedUsage.cache_creation_input_tokens}`);
+        await proxy.updateTaskStatus('completed', undefined, accumulatedUsage);
         // Finalize cron run if this was a scheduled task
         if (isCronTask && req.cronRunId && req.cronJobId) {
             try {
@@ -518,6 +761,22 @@ async function runAgentLoop(req) {
                 console.error(`[Agent] Failed to save turn on failure: ${saveErr.message}`);
             }
         }
+        // Post-task memory flush on failure too (fire-and-forget)
+        if (messages.length >= 3) {
+            (0, compaction_1.postTaskMemoryFlush)(messages, chatFn, async (content) => {
+                const today = new Date().toISOString().split('T')[0];
+                const filePath = `${MEMORY_DIR}/${today}.md`;
+                const entry = `\n## [task-failed] ${new Date().toLocaleTimeString('en-US', { hour12: false })}\n${content}\n[Error: ${err.message}]\n`;
+                try {
+                    await (0, promises_1.mkdir)(MEMORY_DIR, { recursive: true });
+                    await (0, promises_1.appendFile)(filePath, entry, 'utf-8');
+                    const full = await (0, promises_1.readFile)(filePath, 'utf-8').catch(() => content);
+                    proxy.memoryOp('backup_memory', filePath, full).catch(() => { });
+                    proxy.memorySync(`${today}.md`, full).catch(() => { });
+                }
+                catch { }
+            }).catch(() => { });
+        }
         // Emit error event
         try {
             await emitEvent(proxy, taskId, userId, conversationId, 'error', {
@@ -581,7 +840,27 @@ async function executeToolInner(proxy, taskId, userId, sandboxId, conversationId
     // ── Local tools ──
     if (toolName === 'bash') {
         const cmd = (toolInput.command || 'echo "no command"');
-        return await (0, local_tools_1.executeBash)(cmd);
+        const result = await (0, local_tools_1.executeBash)(cmd);
+        // Auto-detect package installs and save to environment.md (fire-and-forget)
+        if (!result.isError) {
+            const packages = detectInstalledPackages(cmd);
+            if (packages) {
+                const envFile = `${MEMORY_DIR}/environment.md`;
+                const timestamp = new Date().toLocaleTimeString('en-US', { hour12: false });
+                const entry = `\n## ${timestamp}\n${packages}\n`;
+                (async () => {
+                    try {
+                        await (0, promises_1.mkdir)(MEMORY_DIR, { recursive: true });
+                        await (0, promises_1.appendFile)(envFile, entry, 'utf-8');
+                        const full = await (0, promises_1.readFile)(envFile, 'utf-8').catch(() => entry);
+                        proxy.memoryOp('backup_memory', envFile, full).catch(() => { });
+                        proxy.memorySync('environment.md', full).catch(() => { });
+                    }
+                    catch { }
+                })();
+            }
+        }
+        return result;
     }
     if (toolName === 'write_file') {
         const writePath = toolInput.path || toolInput.file_path;
@@ -658,27 +937,43 @@ async function executeToolInner(proxy, taskId, userId, sandboxId, conversationId
         try {
             const query = toolInput.query || '';
             const maxResults = Math.min(toolInput.max_results || 5, 10);
-            // Try semantic search via Worker (Vectorize hybrid)
+            // Run Vectorize + local keyword search in parallel, merge results
+            // Local search is always needed because post-task flush writes locally
+            // and Vectorize indexing has latency — stale index misses fresh content
+            // 1. Vectorize search (may return stale results)
+            let vectorizeResults = [];
             try {
-                const results = await proxy.memorySearch(query, maxResults);
-                if (results && results.length > 0) {
-                    const formatted = results.map((r) => `--- ${r.source}:${r.startLine}-${r.endLine} (score: ${(r.score || 0).toFixed(2)}) ---\n${r.content}`).join('\n\n');
-                    return { output: formatted, isError: false };
+                const vResults = await proxy.memorySearch(query, maxResults);
+                if (vResults && vResults.length > 0) {
+                    vectorizeResults = vResults.map((r) => r.content?.trim()).filter(Boolean);
                 }
             }
             catch (err) {
-                console.warn(`[Memory] Vectorize search failed, falling back to keyword: ${err.message}`);
+                console.warn(`[Memory] Vectorize search failed: ${err.message}`);
             }
-            // Fallback: local keyword search
-            const queryLower = query.toLowerCase();
-            const results = [];
+            // 2. Local keyword search (always fresh — reads files directly)
+            const keywords = extractLocalKeywords(query);
+            const localResults = [];
+            const scoreContent = (text) => {
+                if (keywords.length === 0)
+                    return text.toLowerCase().includes(query.toLowerCase()) ? 1 : 0;
+                const lower = text.toLowerCase();
+                let matched = 0;
+                for (const kw of keywords) {
+                    if (lower.includes(kw))
+                        matched++;
+                }
+                return matched / keywords.length;
+            };
+            // Search MEMORY.md
             try {
                 const mem = await (0, promises_1.readFile)(`${MEMORY_DIR}/MEMORY.md`, 'utf-8');
-                if (mem && mem.toLowerCase().includes(queryLower)) {
-                    results.push(`--- MEMORY.md ---\n${mem.substring(0, 3000)}`);
-                }
+                const score = scoreContent(mem);
+                if (score > 0)
+                    localResults.push({ file: 'MEMORY.md', content: mem.substring(0, 3000), score });
             }
             catch { }
+            // Search last 14 daily logs
             const today = new Date();
             for (let i = 0; i < 14; i++) {
                 const d = new Date(today);
@@ -686,13 +981,13 @@ async function executeToolInner(proxy, taskId, userId, sandboxId, conversationId
                 const dateStr = d.toISOString().split('T')[0];
                 try {
                     const note = await (0, promises_1.readFile)(`${MEMORY_DIR}/${dateStr}.md`, 'utf-8');
-                    if (note && note.toLowerCase().includes(queryLower)) {
-                        results.push(`--- ${dateStr}.md ---\n${note.substring(0, 1500)}`);
-                    }
+                    const score = scoreContent(note);
+                    if (score > 0)
+                        localResults.push({ file: `${dateStr}.md`, content: note.substring(0, 1500), score });
                 }
                 catch { }
             }
-            // Also search topic files locally
+            // Search topic files
             try {
                 const { readdir } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
                 const files = await readdir(MEMORY_DIR);
@@ -701,15 +996,27 @@ async function executeToolInner(proxy, taskId, userId, sandboxId, conversationId
                         continue;
                     try {
                         const fc = await (0, promises_1.readFile)(`${MEMORY_DIR}/${f}`, 'utf-8');
-                        if (fc && fc.toLowerCase().includes(queryLower)) {
-                            results.push(`--- ${f} ---\n${fc.substring(0, 1500)}`);
-                        }
+                        const score = scoreContent(fc);
+                        if (score > 0)
+                            localResults.push({ file: f, content: fc.substring(0, 1500), score });
                     }
                     catch { }
                 }
             }
             catch { }
-            return { output: results.join('\n\n') || 'No results found.', isError: false };
+            // 3. Merge: local results first (always fresh), then Vectorize extras
+            localResults.sort((a, b) => b.score - a.score);
+            const localFormatted = localResults.map(r => `${r.content.trim()}\n\nSource: ${r.file}`);
+            // Deduplicate: skip Vectorize results whose content overlaps with local
+            const localText = localFormatted.join('\n');
+            const vectorizeExtras = vectorizeResults.filter(v => {
+                // Skip if >50% of first 200 chars appear in local results
+                const snippet = v.substring(0, 200);
+                return !localText.includes(snippet);
+            });
+            const merged = [...localFormatted, ...vectorizeExtras.map(v => `${v}\n\nSource: vectorize`)];
+            const output = merged.slice(0, maxResults).join('\n\n---\n\n');
+            return { output: output || 'No results found.', isError: false };
         }
         catch (err) {
             return { output: `Search failed: ${err.message}`, isError: true };
@@ -986,6 +1293,25 @@ async function extractFileFromZip(buffer, targetName) {
     }
     return null;
 }
+// ─── Package Detection ──────────────────────────────────────────
+function detectInstalledPackages(cmd) {
+    const installs = [];
+    const pipMatch = cmd.match(/pip3?\s+install\s+([^\s|&;]+(?:\s+[^\s|&;-][^\s|&;]*)*)/);
+    if (pipMatch)
+        installs.push(`pip: ${pipMatch[1].trim()}`);
+    const npmMatch = cmd.match(/npm\s+(?:install|i)\s+(?:-[gSD]\s+)?([^\s|&;]+(?:\s+[^\s|&;-][^\s|&;]*)*)/);
+    if (npmMatch)
+        installs.push(`npm: ${npmMatch[1].trim()}`);
+    const aptMatch = cmd.match(/apt(?:-get)?\s+install\s+(?:-y\s+)?([^\s|&;]+(?:\s+[^\s|&;-][^\s|&;]*)*)/);
+    if (aptMatch)
+        installs.push(`apt: ${aptMatch[1].trim()}`);
+    const brewMatch = cmd.match(/brew\s+install\s+([^\s|&;]+(?:\s+[^\s|&;-][^\s|&;]*)*)/);
+    if (brewMatch)
+        installs.push(`brew: ${brewMatch[1].trim()}`);
+    if (installs.length === 0)
+        return null;
+    return `Installed packages: ${installs.join(', ')}`;
+}
 // ─── Turn Summary Builder ────────────────────────────────────────
 function buildTurnSummary(messages, _originalMessage) {
     const textParts = [];