create-walle 0.9.25 → 0.9.26

package/template/wall-e/llm/supported-models.js

@@ -150,6 +150,11 @@ const SUPPORTED_MODEL_CATALOG = Object.freeze({
     },
   ]),
   ollama: Object.freeze([
+    {
+      id: 'gemma4:e4b-it-qat',
+      name: 'Gemma 4 E4B IT QAT',
+      capabilities: Object.freeze(['chat', 'code', 'tools', 'reasoning']),
+    },
     {
       id: 'gemma4:e4b',
       name: 'Gemma 4 E4B',

package/template/wall-e/loops/tasks.js

@@ -3,6 +3,8 @@ const brain = require('../brain');
 const { spawn } = require('child_process');
 const path = require('path');
 const { findSkill } = require('../skills/skill-loader');
+const runtimeHealth = require('../lib/runtime-health');
+const { retryOnWriteLockBusy } = require('../shared/sqlite-write-lock');
 
 const WALL_E_DIR = path.join(__dirname, '..');
 
@@ -39,6 +41,42 @@ function appendLog(taskId, line) {
   if (entry.lines.length > 500) entry.lines.shift();
 }
 
+async function safeUpdateTask(taskId, updates, options = {}) {
+  const reason = options.reason || 'task-update';
+  const bestEffort = options.bestEffort === true;
+  const op = runtimeHealth.beginOperation('tasks.updateTask', { reason, bestEffort });
+  let retries = 0;
+  try {
+    await retryOnWriteLockBusy(
+      () => brain.updateTask(taskId, updates),
+      {
+        retries: Number.isInteger(options.retries) ? options.retries : 4,
+        backoffMs: Number.isFinite(options.backoffMs) ? options.backoffMs : 75,
+        onRetry: ({ attempt, error }) => {
+          retries = attempt;
+          runtimeHealth.recordOperation('tasks.updateTask.retry', 0, {
+            meta: {
+              reason,
+              attempt,
+              holderPid: error?.lockInfo?.pid || 0,
+              holderLabel: error?.lockInfo?.label || '',
+            },
+          });
+        },
+      },
+    );
+    op.end({ meta: { reason, retries } });
+    return true;
+  } catch (err) {
+    op.end({ ok: false, error: err, meta: { reason, retries, bestEffort } });
+    if (bestEffort) {
+      console.warn(`[tasks] Skipped best-effort task update (${reason}): ${err.message}`);
+      return false;
+    }
+    throw err;
+  }
+}
+
 /**
  * On daemon startup, recover tasks that were interrupted (stuck in 'running').
  * Resets them to 'pending' so they get re-picked up.
@@ -80,11 +118,11 @@ async function tryResumeSlackTasks() {
 
     // Token is valid — un-pause all Slack tasks
     for (const t of pausedSlack) {
-      brain.updateTask(t.id, {
+      await safeUpdateTask(t.id, {
         status: 'pending',
         error: null,
         next_run_at: new Date().toISOString(),
-      });
+      }, { reason: 'slack-auto-resume' });
       console.log(`[tasks] Auto-resumed: ${t.title} (Slack token refreshed)`);
     }
   } catch {}
@@ -106,7 +144,7 @@ async function runDueTasks() {
 
     const now = new Date().toISOString();
     const hasCheckpoint = task.checkpoint ? ' (resuming from checkpoint)' : '';
-    brain.updateTask(task.id, { status: 'running', started_at: now });
+    await safeUpdateTask(task.id, { status: 'running', started_at: now }, { reason: 'task-start' });
     appendLog(task.id, `[${now.slice(11, 19)}] Starting: ${task.title}${hasCheckpoint}`);
 
     try {
@@ -148,7 +186,7 @@ async function runDueTasks() {
         }
       }
 
-      brain.updateTask(task.id, {
+      await safeUpdateTask(task.id, {
         status: slackDeliveryFailed ? 'pending' : (task.type === 'recurring' ? 'pending' : 'completed'),
         completed_at: completedAt,
         last_run_at: completedAt,
@@ -160,7 +198,7 @@ async function runDueTasks() {
           ? new Date(Date.now() + 2 * 60 * 1000).toISOString()  // retry in 2 min
           : (task.type === 'recurring' ? computeNextDue(task.schedule) : null),
         // Keep started_at so duration can be computed as completed_at - started_at
-      });
+      }, { reason: 'task-complete' });
 
       // Consolidate briefing items if present
       try {
@@ -234,7 +272,7 @@ async function runDueTasks() {
           const allTasks = brain.listTasks({});
           for (const t of allTasks) {
             if (t.skill && t.skill.includes('slack') && (t.status === 'pending' || t.status === 'running')) {
-              brain.updateTask(t.id, { status: 'paused' });
+              await safeUpdateTask(t.id, { status: 'paused' }, { bestEffort: true, reason: 'slack-auth-pause-peer' });
               console.log(`[tasks] Auto-paused: ${t.title} (Slack auth expired, refresh failed)`);
             }
           }
@@ -263,7 +301,7 @@ async function runDueTasks() {
         }
       }
 
-      brain.updateTask(task.id, {
+      await safeUpdateTask(task.id, {
         status: task.type === 'recurring' ? 'pending' : 'failed',
         error: isSlackAuth
           ? (slackRefreshSucceeded ? 'Slack token refreshed — retrying.' : 'Slack token expired. Reconnect Slack to retry.')
@@ -272,11 +310,11 @@ async function runDueTasks() {
         last_run_at: new Date().toISOString(),
         run_count: (task.run_count || 0) + 1,
         next_run_at: task.type === 'recurring' ? computeNextDue(task.schedule) : null,
-      });
+      }, { reason: 'task-fail' });
 
       // Only pause recurring tasks if refresh truly failed
       if (isSlackAuth && !slackRefreshSucceeded && task.type === 'recurring') {
-        brain.updateTask(task.id, { status: 'paused' });
+        await safeUpdateTask(task.id, { status: 'paused' }, { bestEffort: true, reason: 'slack-auth-pause-current' });
       }
     }
   }
@@ -296,7 +334,12 @@ async function executeSkill(taskId, task) {
     const { runScriptSkill } = require('../skills/script-skill-runner');
     return runScriptSkill(skill, task, {
       log: line => appendLog(taskId, line),
-      onCheckpoint: checkpoint => brain.updateTask(taskId, { checkpoint }),
+      onCheckpoint: checkpoint => {
+        void safeUpdateTask(taskId, { checkpoint }, {
+          bestEffort: true,
+          reason: 'script-skill-checkpoint',
+        });
+      },
       onProcess: child => taskProcesses.set(taskId, child),
       onClose: child => {
         if (taskProcesses.get(taskId) === child) taskProcesses.delete(taskId);
@@ -345,7 +388,10 @@ function executeScript(taskId, script, checkpoint, extraEnv) {
         appendLog(taskId, line);
         // Lines starting with CHECKPOINT: are saved as resume points
         if (line.startsWith('CHECKPOINT:')) {
-          brain.updateTask(taskId, { checkpoint: line.slice(11).trim() });
+          void safeUpdateTask(taskId, { checkpoint: line.slice(11).trim() }, {
+            bestEffort: true,
+            reason: 'shell-script-checkpoint',
+          });
         }
       });
     });
@@ -438,9 +484,9 @@ async function executeMultiTurnChat(taskId, task) {
     }
 
     // Checkpoint between turns
-    brain.updateTask(taskId, {
+    await safeUpdateTask(taskId, {
       checkpoint: JSON.stringify({ turn: turn + 1, partial: lastReply.slice(0, 2000) }),
-    });
+    }, { bestEffort: true, reason: 'multi-turn-checkpoint' });
   }
 
   return lastReply;
@@ -515,7 +561,7 @@ async function runTaskById(taskId) {
   const task = brain.getTask(taskId);
   if (!task) throw new Error('Task not found');
   if (task.status === 'running') throw new Error('Task is already running');
-  brain.updateTask(taskId, { status: 'pending', next_run_at: new Date().toISOString(), error: null, result: null });
+  await safeUpdateTask(taskId, { status: 'pending', next_run_at: new Date().toISOString(), error: null, result: null }, { reason: 'manual-run' });
   return runDueTasks();
 }
 

package/template/wall-e/loops/think.js

@@ -3,10 +3,49 @@ const { extractKnowledge } = require('../extraction/knowledge-extractor');
 const { detectContradictions } = require('../extraction/contradiction');
 const { linkKnowledgeToEntities, learnEntitiesFromText } = require('../extraction/entity-normalizer');
 const { shouldRunLoop, skipped } = require('./loop-precheck');
+const runtimeHealth = require('../lib/runtime-health');
+const { perfLogsEnabled } = require('../lib/diagnostics-flags');
 let embeddings;
 try { embeddings = require('../embeddings'); } catch { embeddings = null; }
 
 const BATCH_SIZE = 20;
+const THINK_PHASE_LOG_THRESHOLD_MS = Math.max(0, Number(process.env.WALLE_THINK_PHASE_LOG_THRESHOLD_MS || 1000));
+
+function _phaseMeta(meta = {}) {
+  const out = {};
+  for (const [key, value] of Object.entries(meta || {})) {
+    if (value == null) continue;
+    if (typeof value === 'number' || typeof value === 'boolean') out[key] = value;
+    else out[key] = String(value).slice(0, 80);
+  }
+  return out;
+}
+
+async function _measurePhase(name, meta, fn) {
+  const started = Date.now();
+  let ok = false;
+  try {
+    const result = await fn();
+    ok = true;
+    return result;
+  } catch (error) {
+    const durationMs = Date.now() - started;
+    runtimeHealth.recordOperation(`think.phase.${name}`, durationMs, { ok: false, error, meta: _phaseMeta(meta) });
+    if (perfLogsEnabled()) {
+      console.warn(`[think-perf] phase=${name} failed durationMs=${durationMs} error=${error && (error.code || error.name || error.message)}`);
+    }
+    throw error;
+  } finally {
+    if (ok) {
+      const durationMs = Date.now() - started;
+      runtimeHealth.recordOperation(`think.phase.${name}`, durationMs, { ok: true, meta: _phaseMeta(meta) });
+      if (perfLogsEnabled() && durationMs >= THINK_PHASE_LOG_THRESHOLD_MS) {
+        const details = Object.entries(_phaseMeta(meta)).map(([k, v]) => `${k}=${v}`).join(' ');
+        console.log(`[think-perf] phase=${name} durationMs=${durationMs}${details ? ` ${details}` : ''}`);
+      }
+    }
+  }
+}
 
 // Contradiction → question policy. Historically EVERY detected contradiction created a
 // pending_question AND superseded the old knowledge — yielding ~2,000 questions/day that
@@ -63,11 +102,15 @@ async function runOnce(opts = {}) {
 
   try {
     // Step 1: Extract knowledge + classifications (async API call)
-    const entries = await extractFn(pending, ownerName, { model: opts.model });
+    const entries = await _measurePhase('extract', { pending: pending.length }, () => (
+      extractFn(pending, ownerName, { model: opts.model })
+    ));
     const classifications = entries._classifications || [];
 
     // Step 2: Detect contradictions (async API call, outside transaction)
-    const contradictions = await detectContradictions(entries, ownerName, { detectFn: opts.detectFn });
+    const contradictions = await _measurePhase('contradictions', { entries: entries.length }, () => (
+      detectContradictions(entries, ownerName, { detectFn: opts.detectFn })
+    ));
 
     // Step 3: DB transaction: insert knowledge + handle contradictions + classify + mark done
     const db = brain.getDb();
@@ -84,8 +127,6 @@ async function runOnce(opts = {}) {
         });
         insertedIds.push({ ...entry, _id: result.id });
         knowledgeExtracted++;
-        // Link to entities (rule-based, no API cost)
-        try { linkKnowledgeToEntities({ ...entry, id: result.id }, ownerName); } catch {}
       }
 
       // Handle contradictions
@@ -128,47 +169,71 @@ async function runOnce(opts = {}) {
         brain.updateMemoryExtraction(mem.id, 'done');
       }
     });
-    writeResults();
+    await _measurePhase('db_write', {
+      pending: pending.length,
+      entries: entries.length,
+      contradictions: contradictions.length,
+      classifications: classifications.length,
+    }, () => writeResults());
+
+    // Entity links are derived from inserted knowledge, so keep them out of the
+    // extraction-status transaction. This shortens the critical SQLite write lock
+    // while preserving best-effort entity graph enrichment.
+    await _measurePhase('entity_linking', { entries: insertedIds.length }, () => {
+      for (const entry of insertedIds) {
+        try { linkKnowledgeToEntities({ ...entry, id: entry._id }, ownerName); } catch {}
+      }
+    });
   } catch (err) {
     console.error('[think] Extraction failed:', err.message);
-    for (const mem of pending) {
-      try {
-        brain.updateMemoryExtraction(mem.id, 'failed');
-      } catch (updateErr) {
-        console.error('[think] Failed to mark memory as failed:', updateErr.message);
+    await _measurePhase('mark_failed', { pending: pending.length }, () => {
+      for (const mem of pending) {
+        try {
+          brain.updateMemoryExtraction(mem.id, 'failed');
+        } catch (updateErr) {
+          console.error('[think] Failed to mark memory as failed:', updateErr.message);
+        }
       }
-    }
+    });
   }
 
   // Step 4a: Learn entities from memory content (rule-based, no API cost)
-  try {
+  await _measurePhase('entity_learning', { pending: pending.length }, () => {
     for (const mem of pending) {
       if (mem.content && mem.content.length > 50) {
         learnEntitiesFromText(mem.content, ownerName);
       }
     }
-  } catch {}
+  }).catch(() => {});
 
   // Step 4: Compute embeddings for processed memories + new knowledge (async, non-blocking)
   if (embeddings && embeddings.isAvailable()) {
     try {
       const textsToEmbed = pending.map(m => (m.content || '').substring(0, 512));
-      const memEmbeddings = await embeddings.batchComputeEmbeddings(textsToEmbed);
+      const memEmbeddings = await _measurePhase('embeddings.memory', { pending: pending.length }, () => (
+        embeddings.batchComputeEmbeddings(textsToEmbed)
+      ));
       if (memEmbeddings) {
-        for (let i = 0; i < pending.length; i++) {
-          embeddings.storeEmbedding(pending[i].id, 'memory', memEmbeddings[i]);
-        }
+        await _measurePhase('embeddings.memory_store', { pending: pending.length }, () => {
+          for (let i = 0; i < pending.length; i++) {
+            embeddings.storeEmbedding(pending[i].id, 'memory', memEmbeddings[i]);
+          }
+        });
         console.log(`[think] Stored ${pending.length} memory embeddings`);
       }
 
       // Embed new knowledge triples
       if (insertedIds.length > 0) {
         const kTexts = insertedIds.map(k => `${k.subject} ${k.predicate} ${k.object}`);
-        const kEmbeddings = await embeddings.batchComputeEmbeddings(kTexts);
+        const kEmbeddings = await _measurePhase('embeddings.knowledge', { entries: insertedIds.length }, () => (
+          embeddings.batchComputeEmbeddings(kTexts)
+        ));
         if (kEmbeddings) {
-          for (let i = 0; i < insertedIds.length; i++) {
-            embeddings.storeEmbedding(insertedIds[i]._id, 'knowledge', kEmbeddings[i]);
-          }
+          await _measurePhase('embeddings.knowledge_store', { entries: insertedIds.length }, () => {
+            for (let i = 0; i < insertedIds.length; i++) {
+              embeddings.storeEmbedding(insertedIds[i]._id, 'knowledge', kEmbeddings[i]);
+            }
+          });
           console.log(`[think] Stored ${insertedIds.length} knowledge embeddings`);
         }
       }
@@ -177,13 +242,13 @@ async function runOnce(opts = {}) {
     }
   }
 
-  brain.upsertCheckpoint('think', {
+  await _measurePhase('checkpoint', { pending: pending.length, entries: insertedIds.length }, () => brain.upsertCheckpoint('think', {
     last_memory_at: pending[pending.length - 1].timestamp,
     metadata: JSON.stringify({ memories_processed: pending.length, knowledge_extracted: knowledgeExtracted }),
-  });
+  }));
 
   // Task 5: Self-resolve pending questions
-  await selfResolveQuestions(ownerName, opts);
+  await _measurePhase('self_resolve', {}, () => selfResolveQuestions(ownerName, opts));
 
   return { memoriesProcessed: pending.length, knowledgeExtracted };
 }

package/template/wall-e/mcp-server.js

@@ -17,6 +17,10 @@ let _embeddings;
 try { _embeddings = require('./embeddings'); } catch { _embeddings = null; }
 
 const PROTOCOL_VERSION = '2025-03-26';
+const DEFAULT_MCP_LOOKUP_SOURCE_TIMEOUT_MS = 2000;
+const DEFAULT_MCP_LOOKUP_CONTEXT_PACK_TIMEOUT_MS = 1200;
+const DEFAULT_MCP_LOOKUP_EMBEDDING_TIMEOUT_MS = 700;
+const MAX_MCP_LOOKUP_TIMEOUT_MS = 10_000;
 
 const MCP_RESOURCES = [
   {
@@ -718,6 +722,20 @@ async function executeTool(name, args) {
       return routeWallEQuery(args.query, { context: args.context });
     }
     case 'walle_lookup_context': {
+      const canOffload =
+        process.env.WALL_E_PROCESS_ROLE !== 'wall-e-runtime-worker' &&
+        (process.env.NODE_ENV !== 'test' || process.env.WALL_E_RUNTIME_WORKER_POOL_TEST === '1');
+      if (canOffload) {
+        try {
+          return await require('./lib/runtime-worker-pool').requestRuntimeWorker(
+            'mcp.lookupWallEContext',
+            { args },
+            { heavy: true, timeoutMs: Number(args?.timeout_ms) || 45000 }
+          );
+        } catch (err) {
+          console.warn(`[mcp] walle_lookup_context worker failed; falling back local: ${err.message}`);
+        }
+      }
       return lookupWallEContext(args);
     }
     case 'walle_context_hint': {
@@ -1215,6 +1233,7 @@ async function lookupWallEContext(args = {}) {
   if (!query) throw new Error('query is required');
   const route = routeWallEQuery(query, { context: args.context });
   const limit = clampLimit(args.limit, 5, 20);
+  const timeouts = lookupSourceTimeouts(args);
   const shouldUseWallE = Boolean(route.should_use_walle || args.force_memory);
   const isProfileLookup = route.matched?.some(match => match.name === 'self_profile');
   const includeMemories = args.include_memories === true || (args.include_memories !== false && shouldUseWallE);
@@ -1243,18 +1262,36 @@ async function lookupWallEContext(args = {}) {
   };
 
   if (includeCtmOperational) {
-    const operational = await ctmOperationalContext.lookupCtmOperationalContext({
-      query,
-      context: args.context,
-      limit,
-      force: true,
-    });
+    const operational = await withMcpDeadline(
+      () => ctmOperationalContext.lookupCtmOperationalContext({
+        query,
+        context: args.context,
+        limit,
+        force: true,
+      }),
+      timeouts.source,
+      ({ duration_ms, timeout_ms }) => ({
+        ok: false,
+        required: true,
+        session_results: [],
+        sources: {},
+        timed_out: true,
+        duration_ms,
+        timeout_ms,
+        reason: 'ctm_operational_context_timeout',
+        error: `CTM operational context lookup exceeded ${timeout_ms}ms`,
+      })
+    );
     result.ctm_operational_context = operational;
     result.sources.ctm_operational = {
       searched: true,
       ok: Boolean(operational.ok),
       required: Boolean(operational.required),
-      reason: operational.ok ? '' : 'ctm_operational_context_unavailable',
+      reason: operational.ok ? '' : (operational.reason || 'ctm_operational_context_unavailable'),
+      error: operational.error || '',
+      timed_out: Boolean(operational.timed_out),
+      duration_ms: operational.duration_ms,
+      timeout_ms: operational.timeout_ms,
       remote_access: operational.sources?.remote_access || null,
       ctm_sessions: operational.sources?.ctm_sessions || null,
       count: (operational.session_results || []).length,
@@ -1263,27 +1300,71 @@ async function lookupWallEContext(args = {}) {
 
   if (includeSessions) {
     const sessionQuery = isProfileLookup ? 'thorough review fix issues commit high-agency' : query;
-    const sessionSearch = await safeCtmSearchSessions({
-      query: sessionQuery,
-      limit,
-      prefer_db: args.prefer_db !== false,
-    });
+    const sessionSearchPromise = withMcpDeadline(
+      () => safeCtmSearchSessions({
+        query: sessionQuery,
+        limit,
+        prefer_db: args.prefer_db !== false,
+      }),
+      timeouts.source,
+      ({ duration_ms, timeout_ms }) => ({
+        ok: false,
+        source: 'ctm-db',
+        results: [],
+        reason: 'ctm_session_search_timeout',
+        error: `CTM session search exceeded ${timeout_ms}ms`,
+        timed_out: true,
+        duration_ms,
+        timeout_ms,
+      })
+    );
+    const contextPackPromise = withMcpDeadline(
+      () => safeCtmContextPack({
+        task: query,
+        query: sessionQuery,
+        limit: Math.min(limit, 5),
+        token_budget: 6000,
+        mode: 'compact',
+        include_raw: false,
+      }),
+      timeouts.context_pack,
+      ({ duration_ms, timeout_ms }) => ({
+        ok: false,
+        source: 'ctm-db',
+        sessions: [],
+        messages: [],
+        reason: 'ctm_context_pack_timeout',
+        error: `CTM context pack lookup exceeded ${timeout_ms}ms`,
+        timed_out: true,
+        duration_ms,
+        timeout_ms,
+      })
+    );
+    const [sessionSearch, contextPack] = await Promise.all([sessionSearchPromise, contextPackPromise]);
     result.session_results = (sessionSearch.results || []).slice(0, limit).map(stripRank);
     result.sources.ctm_sessions = {
       searched: true,
       ok: Boolean(sessionSearch.ok),
       source: sessionSearch.source || '',
       reason: sessionSearch.reason || '',
+      error: sessionSearch.error || '',
+      timed_out: Boolean(sessionSearch.timed_out),
+      duration_ms: sessionSearch.duration_ms,
+      timeout_ms: sessionSearch.timeout_ms,
       count: result.session_results.length,
     };
-    result.context_pack = await safeCtmContextPack({
-      task: query,
-      query: sessionQuery,
-      limit: Math.min(limit, 5),
-      token_budget: 6000,
-      mode: 'compact',
-      include_raw: false,
-    });
+    result.context_pack = contextPack;
+    result.sources.ctm_context_pack = {
+      searched: true,
+      ok: contextPack?.ok !== false,
+      source: contextPack?.source || 'ctm-db',
+      reason: contextPack?.reason || '',
+      error: contextPack?.error || '',
+      timed_out: Boolean(contextPack?.timed_out),
+      duration_ms: contextPack?.duration_ms,
+      timeout_ms: contextPack?.timeout_ms,
+      count: (contextPack?.messages || []).length,
+    };
   }
 
   if (includeMemories) {
@@ -1293,12 +1374,28 @@ async function lookupWallEContext(args = {}) {
       since: args.since,
       until: args.until,
     };
-    const memorySearch = await searchWallEMemories({
-      query: memoryQuery,
-      limit,
-      filters,
-      hybrid: !Object.values(filters).some(Boolean),
-    });
+    const memorySearch = await withMcpDeadline(
+      () => searchWallEMemories({
+        query: memoryQuery,
+        limit,
+        filters,
+        hybrid: !Object.values(filters).some(Boolean),
+        embeddingTimeoutMs: timeouts.embedding,
+      }),
+      timeouts.source,
+      ({ duration_ms, timeout_ms }) => ({
+        results: [],
+        vector_search_used: false,
+        source: sourceStatus('wall-e-memory', {
+          ok: false,
+          reason: 'wall_e_memory_search_timeout',
+          error: `Wall-E memory search exceeded ${timeout_ms}ms`,
+          timed_out: true,
+          duration_ms,
+          timeout_ms,
+        }),
+      })
+    );
     result.memory_results = memorySearch.results.map(formatMemoryResult);
     result.sources.memories = {
       searched: true,
@@ -1308,7 +1405,11 @@ async function lookupWallEContext(args = {}) {
       source: memorySearch.source.source,
       reason: memorySearch.source.reason || '',
       error: memorySearch.source.error || '',
+      timed_out: Boolean(memorySearch.source.timed_out),
+      duration_ms: memorySearch.source.duration_ms,
+      timeout_ms: memorySearch.source.timeout_ms,
       vector_search_used: memorySearch.vector_search_used,
+      vector: memorySearch.source.vector || null,
       count: result.memory_results.length,
     };
   }
@@ -1416,7 +1517,7 @@ function safeBrainSearchMemories(args = {}) {
   }
 }
 
-async function searchWallEMemories({ query, limit, filters = {}, hybrid = true, terms } = {}) {
+async function searchWallEMemories({ query, limit, filters = {}, hybrid = true, terms, embeddingTimeoutMs } = {}) {
   const base = safeBrainSearchMemories({ query, limit, terms, ...filters });
   let results = base.results;
   let vectorSearchUsed = false;
@@ -1425,7 +1526,19 @@ async function searchWallEMemories({ query, limit, filters = {}, hybrid = true,
   if (base.source.ok && hybrid && _embeddings && _embeddings.isAvailable()) {
     vectorStatus.attempted = true;
     try {
-      const queryEmb = await _embeddings.computeEmbedding(query);
+      const queryEmb = await withMcpDeadline(
+        () => _embeddings.computeEmbedding(query),
+        clampMilliseconds(embeddingTimeoutMs, DEFAULT_MCP_LOOKUP_EMBEDDING_TIMEOUT_MS, MAX_MCP_LOOKUP_TIMEOUT_MS),
+        ({ duration_ms, timeout_ms }) => {
+          vectorStatus.ok = false;
+          vectorStatus.reason = 'wall_e_vector_search_timeout';
+          vectorStatus.error = `Embedding search exceeded ${timeout_ms}ms`;
+          vectorStatus.timed_out = true;
+          vectorStatus.duration_ms = duration_ms;
+          vectorStatus.timeout_ms = timeout_ms;
+          return null;
+        }
+      );
       if (queryEmb) {
         const vectorResults = _embeddings.searchSimilarMemories(queryEmb, limit);
         if (vectorResults.length > 0) {
@@ -1800,6 +1913,57 @@ function clampLimit(value, fallback, max) {
   return Math.min(Math.max(Math.trunc(n), 1), max);
 }
 
+function clampMilliseconds(value, fallback, max = MAX_MCP_LOOKUP_TIMEOUT_MS) {
+  const n = Number(value || fallback);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(Math.max(Math.trunc(n), 25), max);
+}
+
+function lookupSourceTimeouts(args = {}) {
+  const source = clampMilliseconds(
+    args.source_timeout_ms || process.env.WALLE_MCP_LOOKUP_SOURCE_TIMEOUT_MS,
+    DEFAULT_MCP_LOOKUP_SOURCE_TIMEOUT_MS
+  );
+  return {
+    source,
+    context_pack: Math.min(source, clampMilliseconds(
+      args.context_pack_timeout_ms || process.env.WALLE_MCP_LOOKUP_CONTEXT_PACK_TIMEOUT_MS,
+      DEFAULT_MCP_LOOKUP_CONTEXT_PACK_TIMEOUT_MS
+    )),
+    embedding: Math.min(source, clampMilliseconds(
+      args.embedding_timeout_ms || process.env.WALLE_MCP_LOOKUP_EMBEDDING_TIMEOUT_MS,
+      DEFAULT_MCP_LOOKUP_EMBEDDING_TIMEOUT_MS
+    )),
+  };
+}
+
+async function withMcpDeadline(factory, timeoutMs, fallbackFactory) {
+  const startedAt = Date.now();
+  const timeout = clampMilliseconds(timeoutMs, DEFAULT_MCP_LOOKUP_SOURCE_TIMEOUT_MS);
+  let timer;
+  const timedOut = Symbol('mcp_deadline_timeout');
+  const task = Promise.resolve().then(factory);
+  task.catch(() => {});
+  let raced;
+  try {
+    raced = await Promise.race([
+      task,
+      new Promise(resolve => {
+        timer = setTimeout(() => resolve(timedOut), timeout);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  if (raced !== timedOut) {
+    return raced;
+  }
+  return fallbackFactory({
+    duration_ms: Date.now() - startedAt,
+    timeout_ms: timeout,
+  });
+}
+
 function formatMemoryResult(memory) {
   return {
     id: memory.id,