create-walle 0.9.11 → 0.9.13

package/template/wall-e/coding-orchestrator.js

@@ -48,6 +48,12 @@ const {
   buildPlanningPrompt,
   buildSubtaskPrompt,
 } = require('./coding-prompts');
+const {
+  resolveRuntimeMode,
+  filterToolsForRuntimeMode,
+  shouldUseStreamProcessor,
+} = require('./coding/runtime-mode');
+const { createCodingTranscript } = require('./coding/transcript-writer');
 
 const MAX_CUMULATIVE_CONTEXT = 4000;
 const MAX_DIFF_SIZE = 50 * 1024; // 50KB
@@ -634,9 +640,51 @@ async function runAgentLoop(prompt, opts = {}) {
   const modelId = resolveModelId(model, llm);
   const resolvedCwd = realpathBestEffort(cwd || process.cwd());
   const taskFileHints = extractTaskFileHints(prompt);
-  const requestedTools = Array.isArray(tools) ? tools : CODING_TOOLS;
+  const runtimeMode = resolveRuntimeMode(opts);
+  const requestedTools = filterToolsForRuntimeMode(Array.isArray(tools) ? tools : CODING_TOOLS, runtimeMode);
+  const transcript = createCodingTranscript({
+    transcript: opts.transcript,
+    persistTranscript: opts.persistTranscript,
+    sessionId: sid,
+    cwd: resolvedCwd,
+    chatSessionId: opts.chatSessionId || '',
+    label: String(prompt || '').slice(0, 160),
+    modelId,
+    modelProvider: llm.type || '',
+    runtimeMode: runtimeMode.id,
+    agent: opts.agent || '',
+    mode: opts.mode || '',
+  });
+  if (transcript?.ensureSession) {
+    transcript.ensureSession({
+      sessionId: sid,
+      cwd: resolvedCwd,
+      chatSessionId: opts.chatSessionId || '',
+      label: String(prompt || '').slice(0, 160),
+      modelId,
+      modelProvider: llm.type || '',
+      runtimeMode: runtimeMode.id,
+      agent: opts.agent || '',
+      mode: opts.mode || '',
+    });
+  }
+  if (!opts._resumeMessages && transcript?.appendUserMessage) {
+    transcript.appendUserMessage(prompt, {
+      sessionId: sid,
+      cwd: resolvedCwd,
+      chatSessionId: opts.chatSessionId || '',
+    });
+  }
   if (requestedTools.length > 0 && !providerSupportsToolCalls(llm)) {
     const providerType = llm.type || 'unknown';
+    if (transcript?.appendPart) {
+      transcript.appendPart({
+        sessionId: sid,
+        cwd: resolvedCwd,
+        partType: 'error',
+        data: { message: `Provider ${providerType} does not support tool calls` },
+      });
+    }
     return {
       success: false,
       output: '',
@@ -673,6 +721,7 @@ async function runAgentLoop(prompt, opts = {}) {
     projectInfo: projectInfo && projectInfo.type !== 'unknown' ? projectInfo : null,
     projectSkills,
     taskFileHints,
+    runtimeMode,
   });
 
   // Resume support: use restored messages if resuming from checkpoint
@@ -705,6 +754,58 @@ async function runAgentLoop(prompt, opts = {}) {
     return m;
   })();
   const events = opts.events || new CodingEvents();
+  const { PermissionService } = require('./coding/permission-service');
+  const permissionService = opts.permissionService || new PermissionService({
+    events,
+    timeoutMs: opts.permissionTimeoutMs,
+    headlessPolicy: opts.headlessPolicy || (opts.benchmark ? 'allow' : 'reject'),
+  });
+  const { AgentCatalog } = require('./coding/agent-catalog');
+  const agentCatalog = opts.agentCatalog || new AgentCatalog({ projectRoot: resolvedCwd });
+  const defaultTaskRunner = async ({ prompt: childPrompt, agent, taskId, ctx }) => {
+    const childTools = agentCatalog.toolsForAgent(requestedTools, agent);
+    const childResult = await runAgentLoop(childPrompt, {
+      cwd: ctx.cwd || resolvedCwd,
+      timeoutMs: agent.timeoutMs || agent.timeout_ms || opts.subtaskTimeoutMs || Math.min(timeout, 300000),
+      maxTurns: agent.maxSteps || agent.max_steps || opts.childMaxTurns || Math.min(turns, 10),
+      provider,
+      model: agent.model || model,
+      tools: childTools,
+      mode: agent.mode || opts.mode,
+      onProgress,
+      transcript,
+      events,
+      permissionService,
+      interactive: opts.interactive,
+      headless: opts.headless,
+      benchmark: opts.benchmark,
+      headlessPolicy: opts.headlessPolicy,
+      _resumeSessionId: taskId,
+      enableTaskTool: false,
+    });
+    return {
+      success: childResult.success,
+      output: childResult.output,
+      stderr: childResult.stderr,
+      exitCode: childResult.exitCode,
+      sessionId: childResult.sessionId,
+      usage: childResult.usage,
+    };
+  };
+  const { ToolRegistry } = require('./coding/tool-registry');
+  const toolRegistry = opts.toolRegistry || new ToolRegistry({
+    builtinTools: requestedTools,
+    middleware: mw,
+    localTools: getLocalTools(),
+    mcpClient: opts.mcpClient,
+    skillRunner: opts.skillRunner,
+    agentCatalog,
+    taskRunner: opts.taskRunner || defaultTaskRunner,
+    brain: opts.brain || null,
+    transcript,
+    projectRoot: resolvedCwd,
+    enableTaskTool: runtimeMode.canDelegate && opts.enableTaskTool !== false,
+  });
 
   // ── Interactive Questions (B1) ──
   // Inspired by OpenCode Question service (packages/opencode/src/question/index.ts)
@@ -712,6 +813,161 @@ async function runAgentLoop(prompt, opts = {}) {
 
   // projectInfo already detected above (before system prompt)
 
+  // Stream-native runtime: model deltas, tool states, snapshots, permissions,
+  // and step boundaries are persisted as typed transcript parts while the loop
+  // runs. Set WALLE_CODING_STREAM_PROCESSOR=0 or useStreamProcessor:false to
+  // fall back to the legacy whole-response loop.
+  if (shouldUseStreamProcessor(opts)) {
+    const { StreamProcessor } = require('./coding/stream-processor');
+    const { SnapshotService } = require('./coding/snapshot-service');
+    const processor = new StreamProcessor({
+      provider: llm,
+      model: modelId,
+      transcript,
+      snapshotService: opts.snapshotService || new SnapshotService({ cwd: resolvedCwd }),
+      permissionService,
+      toolExecutor: async (call) => {
+        const input = { ...(call.input || {}) };
+        if (['read_file', 'write_file', 'edit_file'].includes(call.name)) {
+          if (input.file_path && !path.isAbsolute(input.file_path)) input.file_path = path.join(resolvedCwd, input.file_path);
+          if (!input.file_path && input.path) input.file_path = path.isAbsolute(input.path) ? input.path : path.join(resolvedCwd, input.path);
+        }
+        if (call.name === 'list_directory' && input.directory && !path.isAbsolute(input.directory)) {
+          input.directory = path.join(resolvedCwd, input.directory);
+        }
+        input.sessionId = sid;
+        input.projectRoot = resolvedCwd;
+        return toolRegistry.execute(call.name, input, { sessionId: sid, cwd: resolvedCwd, model: modelId, provider: llm.type });
+      },
+    });
+    processor.on('event', (evt) => emitProgress({
+      phase: opts.mode || 'executing',
+      step: 0,
+      message: evt.type,
+      detail: evt,
+    }));
+
+    let streamStatus = 'finished';
+    let streamStopReason = '';
+    let streamModel = modelId;
+    const streamErrors = [];
+    for (let turnIndex = opts._resumeTurn || 0; turnIndex < turns; turnIndex++) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        streamStatus = 'error';
+        streamErrors.push('Timeout reached');
+        finalOutput += '\n[Timeout reached]';
+        break;
+      }
+      emitProgress({
+        phase: opts.mode || 'executing',
+        step: turnIndex,
+        message: `Stream turn ${turnIndex + 1}/${turns}...`,
+      });
+      const perTurnCap = opts.perTurnTimeoutMs || (/ollama|mlx/.test(llm.type || '') ? 600000 : 300000);
+      const ac = new AbortController();
+      const timer = setTimeout(() => ac.abort(), Math.min(remaining, perTurnCap));
+      let turn;
+      try {
+        const toolsForTurn = turnIndex >= turns - 1
+          ? []
+          : await toolRegistry.getDefinitions({
+            provider: llm.type,
+            model: modelId,
+            mode: opts.mode,
+            runtimeMode: runtimeMode.id,
+            cwd: resolvedCwd,
+          });
+        turn = await processor.runTurn({
+          sessionId: sid,
+          cwd: resolvedCwd,
+          system: systemPrompt,
+          messages,
+          tools: toolsForTurn,
+          maxTokens: taskFileHints.length >= 4 ? 8192 : 4096,
+          signal: ac.signal,
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+
+      totalInput += turn.usage?.input || 0;
+      totalOutput += turn.usage?.output || 0;
+      streamStatus = turn.status;
+      streamStopReason = turn.stopReason || streamStopReason;
+      streamModel = turn.model || streamModel;
+      if (turn.errors?.length) streamErrors.push(...turn.errors);
+      if (turn.text) finalOutput += turn.text;
+      const streamToolCalls = (turn.toolCalls || []).map(tc => ({ name: tc.name, input: tc.input }));
+      toolCallHistory.push(...streamToolCalls.map(tc => ({
+        name: tc.name,
+        inputHash: JSON.stringify(tc.input || {}).slice(0, 500),
+      })));
+      log.push({
+        turn: turnIndex,
+        model: turn.model || modelId,
+        provider: turn.provider || llm.type,
+        toolCalls: streamToolCalls,
+        content: turn.text,
+        stopReason: turn.stopReason,
+      });
+
+      if (turn.status === 'error') break;
+      if ((turn.toolCalls || []).length === 0) {
+        const editTools = new Set(['edit_file', 'write_file', 'apply_patch', 'multi_edit']);
+        const madeEdits = toolCallHistory.some(c => editTools.has(c.name));
+        const canFinishWithoutEdit = isLegitimateNoEditResponse(turn.text, toolCallHistory);
+        if (!madeEdits && !canFinishWithoutEdit && turnIndex < turns - 1 && turnIndex > 1 && !log._noEditNudged) {
+          log._noEditNudged = true;
+          const nudge = `[SYSTEM] You have not made any code changes yet. ` +
+            `The task requires you to use edit_file or write_file to modify code. ` +
+            `Do NOT just describe the fix — actually call edit_file with the old_string and new_string to make the change. ` +
+            `Here is the working directory: ${resolvedCwd}`;
+          if (turn.assistantMessage) messages.push(turn.assistantMessage);
+          messages.push({ role: 'user', content: nudge });
+          emitProgress({ phase: opts.mode || 'executing', step: turnIndex, message: 'No-edit guard: nudging agent to make changes' });
+          continue;
+        }
+      }
+      if (turn.assistantMessage) messages.push(turn.assistantMessage);
+      if (turn.toolResultMessage) messages.push(turn.toolResultMessage);
+      if (turn.next !== 'continue') break;
+    }
+
+    if (streamStatus === 'error' && transcript?.appendPart) {
+      transcript.appendPart({
+        sessionId: sid,
+        cwd: resolvedCwd,
+        partType: 'error',
+        data: { errors: streamErrors },
+      });
+    }
+    if (finalOutput && transcript?.appendAssistantMessage) {
+      transcript.appendAssistantMessage(finalOutput, {
+        sessionId: sid,
+        cwd: resolvedCwd,
+        chatSessionId: opts.chatSessionId || '',
+        model: streamModel,
+        provider: llm.type || '',
+        tokens: { input: totalInput, output: totalOutput },
+      });
+    }
+
+    return {
+      success: streamStatus !== 'error',
+      output: finalOutput,
+      stderr: streamErrors.join('\n'),
+      sessionId: sid,
+      exitCode: streamStatus === 'error' ? -1 : 0,
+      log,
+      usage: { input: totalInput, output: totalOutput },
+      provider: llm.type,
+      model: streamModel,
+      next: 'stop',
+      runtimeMode: runtimeMode.id,
+    };
+  }
+
   // ── Bridge: event bus → middleware (A2) ──
   // When the event bus fires, propagate to middleware's onEvent hook so
   // registered middleware can react to file edits, reads, and context overflow.
@@ -818,10 +1074,10 @@ async function runAgentLoop(prompt, opts = {}) {
 
       // Middleware: prepare LLM call
       const llmCtx = { params: { maxTokens: taskFileHints.length >= 4 ? 8192 : 4096 }, system: systemPrompt, cwd: resolvedCwd,
-        provider: llm.type, model: modelId, mode: opts.mode, claudeMd: opts.claudeMd, log: {} };
+        provider: llm.type, model: modelId, mode: opts.mode, runtimeMode: runtimeMode.id, claudeMd: opts.claudeMd, log: {} };
       llmCtxRef.current = llmCtx; // expose to event bridge (A2)
       await mw.run('llm.before', llmCtx);
-      let adaptedTools = await mw.run('tool.definitions', llmCtx, requestedTools);
+      let adaptedTools = await toolRegistry.getDefinitions(llmCtx);
 
       // Context compaction (6b) -- prune old tool results when approaching context limit
       const estimateTokens = (msgs) => {
@@ -1034,26 +1290,24 @@ async function runAgentLoop(prompt, opts = {}) {
           if (tc.name === 'run_shell') {
             input.timeout_ms = input.timeout_ms || 30000;
             input.cwd = input.cwd || resolvedCwd;
+          }
 
-            // Tree-sitter analysis for permission checking
-            const { analyzeShellCommand, initParser: initShellParser } = require('./tools/shell-analyzer');
-            await initShellParser();
-            const analysis = await analyzeShellCommand(input.command, input.cwd || resolvedCwd);
-            const { checkPermission } = require('./tools/permission-checker');
-            const permResult = await checkPermission({
-              tool: 'run_shell',
-              command: input.command,
-              commandTokens: analysis.commandTokens.length > 0 ? analysis.commandTokens[0] : undefined,
-              projectPath: resolvedCwd,
+          if (['run_shell', 'read_file', 'write_file', 'edit_file', 'apply_patch', 'multi_edit', 'applescript', 'claude_code', 'mail_send', 'slack_send_message'].includes(tc.name)) {
+            const permResult = await permissionService.authorize({
               sessionId: sid,
+              tool: tc.name,
+              input,
+              cwd: input.cwd || resolvedCwd,
+              projectRoot: resolvedCwd,
               mode: opts.mode,
+              headless: Boolean(opts.headless || opts.benchmark),
+              metadata: { toolCallId: tc.id || tc.toolCallId || '' },
             });
-            if (permResult.decision === 'deny') {
-              result = { error: `Permission denied: ${permResult.reason}` };
+            if (permResult.decision !== 'allow') {
+              result = { error: `Permission denied: ${permResult.reason || permResult.message || permResult.decision}` };
               turnHadError = true;
               throw new Error('path_blocked');
             }
-            // Note: 'ask' decisions would need CTM approval flow — for now, log and allow
           }
 
           // Middleware: before tool
@@ -1087,8 +1341,13 @@ async function runAgentLoop(prompt, opts = {}) {
               }
             }
           } else {
-            result = await getLocalTools().executeLocalTool(tc.name, finalInput);
-            if (result === null) result = { error: `Unknown tool: ${tc.name}` };
+            result = await toolRegistry.execute(tc.name, finalInput, {
+              sessionId: sid,
+              cwd: resolvedCwd,
+              model: modelId,
+              provider: llm.type,
+              llmCtx,
+            });
           }
 
           // Middleware: after tool
@@ -1204,6 +1463,24 @@ async function runAgentLoop(prompt, opts = {}) {
 
     // Save error checkpoint for crash recovery
     saveCheckpointToBrain(sid, Math.max(0, log.length - 1), messages, opts, totalInput, totalOutput, resolvedCwd, 'error');
+    if (transcript?.appendPart) {
+      transcript.appendPart({
+        sessionId: sid,
+        cwd: resolvedCwd,
+        partType: 'error',
+        data: { message: err.message },
+      });
+    }
+    if (finalOutput && transcript?.appendAssistantMessage) {
+      transcript.appendAssistantMessage(finalOutput, {
+        sessionId: sid,
+        cwd: resolvedCwd,
+        chatSessionId: opts.chatSessionId || '',
+        model: modelId,
+        provider: llm?.type || '',
+        tokens: { input: totalInput, output: totalOutput },
+      });
+    }
 
     // Graceful cleanup (6r)
     const cleanup = {
@@ -1252,6 +1529,7 @@ async function runAgentLoop(prompt, opts = {}) {
       usage: { input: totalInput, output: totalOutput },
       provider: llm?.type,
       model: modelId,
+      runtimeMode: runtimeMode.id,
       turnCosts,
       budgetUsed,
       cleanup,
@@ -1279,6 +1557,16 @@ async function runAgentLoop(prompt, opts = {}) {
 
   // Persist activity completion (Phase 2: Activity History)
   try { getActivityLog().log({ session_id: sid, type: 'coding_complete', title: 'Coding session completed', body: finalOutput.slice(0, 500), detail: JSON.stringify({ turns: log.length, tokens: totalInput + totalOutput }) }); } catch {}
+  if (finalOutput && transcript?.appendAssistantMessage) {
+    transcript.appendAssistantMessage(finalOutput, {
+      sessionId: sid,
+      cwd: resolvedCwd,
+      chatSessionId: opts.chatSessionId || '',
+      model: modelId,
+      provider: llm?.type || '',
+      tokens: { input: totalInput, output: totalOutput },
+    });
+  }
 
   // Save training log
   try {
@@ -1298,6 +1586,7 @@ async function runAgentLoop(prompt, opts = {}) {
     usage: { input: totalInput, output: totalOutput },
     provider: llm?.type,
     model: modelId,
+    runtimeMode: runtimeMode.id,
     turnCosts,
     budgetUsed,
   };

package/template/wall-e/coding-prompts.js

@@ -1,5 +1,9 @@
 'use strict';
 
+const { buildPromptBundle, loadPromptText } = require('./coding/prompt-bundle');
+const { buildPromptEnvelope, renderPromptEnvelope } = require('./coding/prompt-runtime');
+const { runtimeModeInstructions } = require('./coding/runtime-mode');
+
 /**
  * Coding-agent system + subtask prompt builders.
  *
@@ -51,7 +55,17 @@ function extractTaskFileHints(prompt, { limit = 24 } = {}) {
   return [...matches];
 }
 
-function buildAgentSystemPrompt({ resolvedCwd, projectInfo, projectSkills, taskFileHints } = {}) {
+function loadMemoryProtocolBlock({ available = true } = {}) {
+  if (!available) {
+    return `# Session Memory
+
+Wall-E session memory tools are unavailable in this run. Do not claim you searched prior sessions or wrote a diary entry unless a tool result proves it. If past-session context is needed, say what information is missing and continue from the local codebase.`;
+  }
+  const protocol = loadPromptText('memory-protocol.md');
+  return protocol ? `# Session Memory\n\n${protocol}` : '';
+}
+
+function buildAgentSystemPrompt({ resolvedCwd, projectInfo, projectSkills, taskFileHints, mode, provider, model, runtimeMode, extraInstructions, returnEnvelope = false, runtimeContext = {} } = {}) {
   const projectCtx = projectInfo
     ? `\nProject: ${projectInfo.language || 'unknown'}${projectInfo.framework ? ` (${projectInfo.framework})` : ''}${projectInfo.vcs ? `, vcs: ${projectInfo.vcs}` : ''}`
     : '';
@@ -63,12 +77,20 @@ function buildAgentSystemPrompt({ resolvedCwd, projectInfo, projectSkills, taskF
     ? `\nLarge task file hints (${taskFileHints.length}): ${taskFileHints.join(', ')}`
     : '';
 
-  return `You are an expert software engineer executing a coding task. Use the provided tools to actually do the work — describing what to do is not completing the task.${projectCtx}${projectSkillCtx}
+  const runtimeCtx = runtimeModeInstructions(runtimeMode);
+  const memoryToolsAvailable = runtimeContext.memoryToolsAvailable !== false;
+  const memoryProtocolCtx = loadMemoryProtocolBlock({ available: memoryToolsAvailable });
+
+  const body = `You are an expert software engineer executing a coding task. Use the provided tools to actually do the work — describing what to do is not completing the task.${projectCtx}${projectSkillCtx}
 
 Working directory: ${resolvedCwd || '(not set)'}
 ${largeTaskCtx}
 
-# Workflow
+# Runtime role
+
+${runtimeCtx}
+
+${memoryProtocolCtx ? `${memoryProtocolCtx}\n\n` : ''}# Workflow
 
 1. Explore first. Use read_file / list_directory / lsp_symbols to learn the relevant code BEFORE editing it. Reading three files cheaply beats one wrong edit.
 2. When acting on a non-trivial change, call update_todos to lay out steps, then mark each completed as you go. This keeps long sessions on track.
@@ -104,6 +126,22 @@ ${largeTaskCtx}
 - If the task is ambiguous, make a best-guess interpretation and note it explicitly: "I interpreted X as Y; tell me if you meant Z." Don't refuse and ask — answer + clarify.
 - If you genuinely cannot complete the task, say what you tried, what you ruled out, and the narrowed-down problem. That's a useful failure; "I couldn't" alone is not.
 - Use ask_user only when the answer is genuinely undeterminable from the codebase + reasonable defaults. Most "ambiguous" tasks aren't — pick the obvious interpretation and proceed.`;
+
+  const bundle = buildPromptBundle({ body, mode, provider, model, extraInstructions, returnEnvelope: true });
+  const envelope = buildPromptEnvelope({
+    stablePolicy: bundle.sections.find(section => section.id === 'stable-policy')?.content || '',
+    toolPolicy: bundle.sections.find(section => section.id === 'tool-policy')?.content || '',
+    providerContribution: runtimeContext.providerContribution || '',
+    channelContext: runtimeContext.channelContext || '',
+    parentRunContext: runtimeContext.parentRunContext || '',
+    childScope: runtimeContext.childScope || '',
+    runtimeOnlyContext: runtimeContext.runtimeOnlyContext || '',
+    nextTurnContext: runtimeContext.nextTurnContext || '',
+    userTask: runtimeContext.userTask || '',
+    sections: bundle.sections.filter(section => !['stable-policy', 'tool-policy'].includes(section.id)),
+    metadata: { mode, provider, model, resolvedCwd, memoryToolsAvailable },
+  });
+  return returnEnvelope ? envelope : renderPromptEnvelope(envelope);
 }
 
 /**
@@ -217,7 +255,10 @@ ${subtask.prompt}`);
 
 module.exports = {
   extractTaskFileHints,
+  loadMemoryProtocolBlock,
   buildAgentSystemPrompt,
   buildPlanningPrompt,
   buildSubtaskPrompt,
+  buildPromptEnvelope,
+  renderPromptEnvelope,
 };

package/template/wall-e/context/context-builder.js

@@ -515,7 +515,31 @@ function expandWithNeighbors(memory, radius = 1) {
     } catch {}
   }
 
-  // Strategy 2: Non-chunked memories — fetch time-adjacent from same source
+  // Strategy 2: Source-adapter sessions — fetch adjacent records with the
+  // same stable source/session id. This keeps long coding-session snippets
+  // coherent even when individual memory rows are message-sized.
+  const stableSourceId = sourceIdForMemory(memory);
+  if (stableSourceId) {
+    try {
+      const db = brain.getDb();
+      const siblings = db.prepare(`
+        SELECT id, source_id, content, timestamp FROM memories
+        WHERE source = ? AND (source_id = ? OR source_id LIKE ?)
+        ORDER BY timestamp ASC, source_id ASC
+        LIMIT 200
+      `).all(memory.source, stableSourceId, `${stableSourceId}:%`);
+      if (siblings.length > 1) {
+        const idx = siblings.findIndex(s => s.id === memory.id);
+        if (idx >= 0) {
+          const start = Math.max(0, idx - radius);
+          const end = Math.min(siblings.length, idx + radius + 1);
+          return capNeighborContent(siblings.slice(start, end).map(s => s.content).join('\n---\n'));
+        }
+      }
+    } catch {}
+  }
+
+  // Strategy 3: Non-chunked memories — fetch time-adjacent from same source
   if (memory.source && memory.timestamp) {
     try {
       const db = brain.getDb();
@@ -535,6 +559,24 @@ function expandWithNeighbors(memory, radius = 1) {
   return memory.content;
 }
 
+function sourceIdForMemory(memory) {
+  try {
+    const metadata = JSON.parse(memory.metadata || '{}');
+    if (metadata?.sourceId) return metadata.sourceId;
+  } catch {}
+  const sourceId = String(memory.source_id || '');
+  const parts = sourceId.split(':');
+  if (parts.length >= 3 && /-jsonl$/.test(memory.source || '')) {
+    return parts.slice(0, 2).join(':');
+  }
+  return '';
+}
+
+function capNeighborContent(content, max = 5000) {
+  const text = String(content || '');
+  return text.length > max ? `${text.slice(0, max - 30)}\n[neighbor context truncated]` : text;
+}
+
 /** G3: Essential Story — top high-confidence knowledge always loaded in core layer.
  * Gives the AI "who you are" context from the first message. */
 function buildEssentialStory(maxEntries = 15) {

package/template/wall-e/context/topic-matcher.js

@@ -25,7 +25,7 @@ const TOPIC_PATTERNS = {
   },
   technical: {
     keywords: ['code', 'bug', 'deploy', 'api', 'database', 'server', 'git', 'pr', 'test'],
-    regex: /\b(code|code\s+review|review\s+(?:diff|patch|changes?|pr|pull\s+request)|bug|deploy|api|database|server|git|pr|pull\s+request|test|build|pipeline|docker|kubernetes|aws|gcp)\b/i,
+    regex: /\b(code|code\s+review|review\s+(?:(?:local|uncommitted|unstaged|staged|working\s+tree|workspace)\s+)?(?:diff|patch|changes?|pr|pull\s+request)|(?:check|show|run)\s+git\s+status|bug|deploy|api|database|server|git|pr|pull\s+request|test|build|pipeline|docker|kubernetes|aws|gcp)\b/i,
   },
   tools: {
     keywords: ['tool', 'mcp', 'skill', 'fetch', 'execute', 'automation', 'disk', 'storage'],