create-walle 0.9.13 → 0.9.15

package/template/wall-e/prompts/coding/memory-protocol.md

@@ -1,7 +1,13 @@
 Use Wall-E session memory as part of the coding workflow.
 
 - At session start or before acting on old context, call `walle_memory_status` when available so you know whether memory is connected.
+- If `walle_lookup_context` is available, use it for ambiguous private/work/session recall prompts because it routes the request and gathers memory, entity, and CTM session context in one call.
 - Before answering or changing code based on "last time", "previously", "this branch", "that bug", "my preference", a named project/person, or a remembered decision, search first with `walle_search_sessions` or `search_memories`.
+- For any private, remembered, or work-context question, treat Wall-E memory as the primary source before public web or raw files. This includes prior agent sessions, previous attempts, branch/task history, decisions, preferences, people, teams, projects, tools, Slack/email/calendar context, and prompts like "do you know", "who/what is", "what happened", or "what did we discuss".
+- Use `entity_search` with its `name` argument when graph lookup helps, then `search_memories`; use public web only for public/current facts, after memory misses, or when the user explicitly asks for public information.
+- When memories include private work details, summarize minimally and avoid dumping emails, meeting links, or private document URLs unless the user explicitly needs them.
+- If native `mcp__wall_e__*` tools are not mounted but `codex mcp list` shows `wall-e` enabled, call the MCP endpoint directly with JSON-RPC over `http://localhost:<port>/mcp` before falling back to raw files. Treat file-exists-only status as insufficient; confirm DB retrieval through `walle_search_sessions`, `walle_get_session`, or `walle_context_pack`.
+- If Wall-E MCP reports `ctm_db_schema_read_failed`, say that DB-first memory is unhealthy and use JSONL/direct-file fallback with that caveat. Do not silently call it "tables missing."
 - Batch searches by angle: project/session id, file path, error text, decision keyword. Do not run one narrow query and give up.
 - When you use retrieved memory, cite the source session id, timestamp, file, or diary entry returned by the tool.
 - For long retrieved sessions, use `walle_get_session` to inspect the specific source/session instead of relying on a short snippet.

package/template/wall-e/server.js

@@ -6,6 +6,33 @@ const { getAllowedOrigin, isAuthorizedRequest } = require('./http/auth');
 const PORT = parseInt(process.env.WALL_E_PORT) || 3457;
 const HOST = process.env.WALL_E_HOST || '127.0.0.1';
 
+function isMcpAutoConfigDisabled() {
+  const value = String(process.env.WALLE_MCP_AUTO_CONFIG || '').toLowerCase();
+  return value === '0' || value === 'false' || value === 'off';
+}
+
+function autoConfigureWallEMcp() {
+  if (isMcpAutoConfigDisabled()) return;
+  try {
+    const { ensureMcpIntegrations } = require('./lib/mcp-integration');
+    const results = ensureMcpIntegrations(PORT);
+    const changed = results.filter(r => r.kind === 'mcp_config' && (r.action === 'added' || r.action === 'updated'));
+    const instructionChanged = results.filter(r => r.kind === 'agent_instructions' && (r.action === 'added' || r.action === 'updated'));
+    const errors = results.filter(r => r.action === 'error');
+    if (changed.length) {
+      console.log(`[wall-e] Auto-configured Wall-E MCP for ${changed.length} AI tool(s)`);
+    }
+    if (instructionChanged.length) {
+      console.log(`[wall-e] Updated Wall-E memory-routing instructions for ${instructionChanged.length} AI agent(s)`);
+    }
+    if (errors.length) {
+      console.warn(`[wall-e] Wall-E MCP auto-config skipped ${errors.length} invalid config file(s): ${errors.map(r => r.tool).join(', ')}`);
+    }
+  } catch (err) {
+    console.warn(`[wall-e] Wall-E MCP auto-config failed: ${err.message}`);
+  }
+}
+
 function startServer(options = {}) {
   const server = http.createServer(async (req, res) => {
     const url = new URL(req.url, `http://${req.headers.host}`);
@@ -120,6 +147,8 @@ function startServer(options = {}) {
       if (retryCount > 0) console.log(`[wall-e] Port ${PORT} freed after ${retryCount} retries`);
       console.log(`[wall-e] HTTP server listening on ${HOST}:${PORT}`);
       readyResolve();
+      if (typeof setImmediate === 'function') setImmediate(autoConfigureWallEMcp);
+      else setTimeout(autoConfigureWallEMcp, 0);
     });
   }
 
@@ -147,4 +176,4 @@ function startServer(options = {}) {
   return server;
 }
 
-module.exports = { startServer };
+module.exports = { startServer, autoConfigureWallEMcp };

package/template/wall-e/skills/_bundled/memory-search/SKILL.md

@@ -49,7 +49,14 @@ is being sought. Identify:
 ### 2. Execute Searches
 Use `search_memories` with MULTIPLE queries in the SAME turn:
 
+**For private/work-context queries:**
+- If MCP `walle_lookup_context` is available, call it first to route the request and gather memory/entity/session context together.
+- Treat WALL-E's brain as the primary source for remembered user context before public web search.
+- Search prior conversations, decisions, preferences, project/task names, tool names, Slack/email/calendar terms, and any error text or session id the user provides.
+- Use public web search only for public/current facts, after memory has no useful hits, or when the user explicitly asks for public information.
+
 **For people-related queries:**
+- Use `lookup_person` or `entity_search` first when available; note that MCP `entity_search` takes `name`, not `query`.
 - Search by person's name
 - Search by their common topics or projects
 - Search in Slack specifically (`source: "slack"`)
@@ -87,6 +94,7 @@ Produce a structured summary:
 ## Guidelines
 
 - Always cite sources: include timestamps and channel names
+- For private work/person context, summarize minimally and do not expose emails, meeting links, or private document URLs unless needed
 - Translate Chinese content -- it often contains the most candid opinions
 - Distinguish between what the owner SAID vs what others SAID ABOUT/TO them
 - When evidence is thin, say so explicitly rather than speculating

package/template/wall-e/skills/_bundled/scan-ctm-sessions/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: scan-ctm-sessions
+description: Deterministically ingest Claude Code session JSONL files into Wall-E memory
+version: 1.0.0
+author: wall-e
+execution: script
+entry: run.js
+trigger:
+  type: interval
+  interval_ms: 60000
+retry:
+  backoff_schedule_ms: [5000, 15000, 60000, 300000]
+tags: [ctm, claude-code, sessions, memory]
+permissions:
+  - filesystem:read
+  - brain:write
+---
+# Scan CTM Sessions
+
+Reads Claude Code JSONL files from `~/.claude/projects` and ingests them through Wall-E's deterministic CTM adapter.

package/template/wall-e/skills/_bundled/scan-ctm-sessions/run.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+
+const brain = require(path.resolve(__dirname, '..', '..', '..', 'brain'));
+const CtmAdapter = require(path.resolve(__dirname, '..', '..', '..', 'adapters', 'ctm'));
+const ingest = require(path.resolve(__dirname, '..', '..', '..', 'loops', 'ingest'));
+
+const standalone = require.main === module;
+
+function ensureDb() {
+  try {
+    brain.getDb();
+  } catch {
+    brain.initDb();
+  }
+}
+
+async function main() {
+  ensureDb();
+  const adapter = new CtmAdapter();
+  const result = await ingest.runOnce([adapter]);
+  const checkpoint = brain.getCheckpoint(ingest.checkpointName(adapter));
+  const output = {
+    ok: true,
+    messagesIngested: result.memoriesIngested || 0,
+    memoriesIngested: result.memoriesIngested || 0,
+    checkpoint: checkpoint?.last_memory_at || null,
+  };
+  console.log(JSON.stringify(output));
+  if (standalone) brain.closeDb();
+  return output;
+}
+
+module.exports = { run: main };
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(JSON.stringify({ ok: false, error: err.message }));
+    process.exit(1);
+  });
+}