create-walle 0.9.13 → 0.9.14

package/template/wall-e/eval/run-codex-cli-baseline.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+'use strict';
+
+try {
+  const envPath = require('path').resolve(__dirname, '..', '..', '.env');
+  const lines = require('fs').readFileSync(envPath, 'utf8').split('\n');
+  for (const line of lines) {
+    const match = line.match(/^([A-Z_]+)=(.*)$/);
+    if (match && !process.env[match[1]]) process.env[match[1]] = match[2];
+  }
+} catch {}
+
+const crypto = require('crypto');
+const path = require('path');
+process.chdir(path.join(__dirname, '..'));
+
+const benchmarks = require('./benchmarks/coding-agent.json');
+const {
+  DEFAULT_RESULTS_DIR,
+  runCodexCliBaselineBenchmark,
+  storeBaselineResult,
+  summarizeBaselineResults,
+  writeBaselineArtifact,
+} = require('./codex-cli-baseline');
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const selected = selectBenchmarks({
+    id: args.id,
+    limit: args.limit ? Number(args.limit) : null,
+    difficulty: args.difficulty,
+  });
+  if (!selected.length) {
+    console.error('No benchmarks selected');
+    process.exitCode = 1;
+    return;
+  }
+
+  const timeoutMs = args.timeout ? Number(args.timeout) : 600_000;
+  const runId = crypto.randomUUID();
+  const dryRun = !!args['dry-run'];
+  const model = args.model || null;
+  const resultsDir = args['results-dir'] || DEFAULT_RESULTS_DIR;
+  const brain = initBrain();
+
+  console.log('=== Codex CLI Baseline Runner ===');
+  console.log(`Run: ${runId}`);
+  console.log(`Benchmarks: ${selected.length}/${benchmarks.length}`);
+  console.log(`Mode: ${dryRun ? 'dry-run' : 'codex exec baseline'}`);
+  console.log(`Model: ${model || 'codex default'}`);
+  console.log(`Auth: ${args['use-env-openai-key'] ? 'env OPENAI_API_KEY allowed' : 'ChatGPT/Codex auth preferred (OPENAI_API_KEY stripped)'}`);
+  console.log('');
+
+  const results = [];
+  for (const benchmark of selected) {
+    console.log(`--- ${benchmark.id} (${benchmark.difficulty || 'unknown'}) ---`);
+    console.log(`  Prompt: ${String(benchmark.prompt || '').replace(/\s+/g, ' ').slice(0, 120)}`);
+    console.log(`  Fixture: ${benchmark.agentExpectations?.projectFixture || 'express-basic'}`);
+
+    const started = Date.now();
+    const result = await runCodexCliBaselineBenchmark(benchmark, {
+      dryRun,
+      model,
+      timeoutMs,
+      keepFailures: !!args['keep-failures'],
+      useEnvOpenAIKey: !!args['use-env-openai-key'],
+      dangerouslyBypassSandbox: !!args['dangerously-bypass-sandbox'],
+      allowMcp: !!args['allow-mcp'],
+      disableMcpServers: normalizeListArg(args['disable-mcp']),
+    });
+    result.runId = runId;
+    result.timestamp = new Date().toISOString();
+    results.push(result);
+
+    if (args.record) {
+      result.artifactPath = writeBaselineArtifact(result, { resultsDir });
+    }
+    storeBaselineResult({ brain, runId, benchmark, result, model, timeoutMs });
+
+    console.log(`  Success: ${result.success}`);
+    if (result.status) console.log(`  Status: ${result.status}`);
+    if (result.score) console.log(`  Score: ${(result.score.composite || 0).toFixed(3)}`);
+    console.log(`  Files: ${(result.actualFileChanges || []).join(', ') || 'none'}`);
+    console.log(`  Tests: ${result.testsPassed == null ? 'N/A' : result.testsPassed}`);
+    console.log(`  Time: ${((Date.now() - started) / 1000).toFixed(1)}s`);
+    if (result.error) console.log(`  Error: ${String(result.error).split('\n')[0]}`);
+    if (result.sandboxDir) console.log(`  Kept sandbox: ${result.sandboxDir}`);
+    if (result.artifactPath) console.log(`  Artifact: ${result.artifactPath}`);
+    console.log('');
+  }
+
+  const summary = summarizeBaselineResults(results);
+  console.log('=== SUMMARY ===');
+  console.log(`Passed: ${summary.passed}/${summary.total}`);
+  console.log(`Average composite score: ${summary.avgComposite.toFixed(3)}`);
+  console.log(`Failures: ${JSON.stringify(summary.failures)}`);
+  if (!dryRun && summary.failed > 0) process.exitCode = 1;
+}
+
+function initBrain() {
+  try {
+    const brain = require('../brain');
+    brain.initDb();
+    return brain;
+  } catch (err) {
+    console.warn(`Brain not available: ${err.message}`);
+    return null;
+  }
+}
+
+function selectBenchmarks({ id, limit, difficulty } = {}) {
+  let selected = benchmarks;
+  if (id) selected = selected.filter((benchmark) => benchmark.id === id);
+  if (difficulty) selected = selected.filter((benchmark) => benchmark.difficulty === difficulty);
+  if (limit) selected = selected.slice(0, limit);
+  return selected;
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+    const key = arg.slice(2);
+    if (['dry-run', 'record', 'keep-failures', 'use-env-openai-key', 'dangerously-bypass-sandbox', 'allow-mcp', 'help'].includes(key)) {
+      out[key] = true;
+    } else {
+      if (out[key] === undefined) out[key] = argv[i + 1];
+      else if (Array.isArray(out[key])) out[key].push(argv[i + 1]);
+      else out[key] = [out[key], argv[i + 1]];
+      i += 1;
+    }
+  }
+  return out;
+}
+
+function normalizeListArg(value) {
+  if (value == null) return null;
+  const values = Array.isArray(value) ? value : [value];
+  return values
+    .flatMap((entry) => String(entry || '').split(','))
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function printHelp() {
+  console.log(`Usage:
+  node eval/run-codex-cli-baseline.js --id agent-001 --model gpt-5.5
+  node eval/run-codex-cli-baseline.js --limit 5 --model gpt-5-codex --record
+  node eval/run-codex-cli-baseline.js --dry-run --difficulty easy
+
+Options:
+  --id <id>                    Run one benchmark id
+  --limit <n>                  Limit selected benchmarks
+  --difficulty <easy|medium|hard>
+  --model <id>                 Forwarded verbatim to: codex exec -m <id>
+  --timeout <ms>               Per-benchmark timeout (default 600000)
+  --record                     Write result JSON artifacts
+  --results-dir <path>         Artifact directory
+  --keep-failures              Keep failed sandbox directories
+  --use-env-openai-key         Let codex inherit OPENAI_API_KEY instead of preferring ChatGPT auth
+  --allow-mcp                  Let codex load enabled MCP servers from local config
+  --disable-mcp <name[,name]>  Explicit MCP server names to disable; defaults to auto-discover enabled servers
+  --dangerously-bypass-sandbox Pass codex's bypass flag. Use only inside an external sandbox.
+  --dry-run                    Verify fixture setup only; does not invoke codex
+`);
+}
+
+main().catch((err) => {
+  console.error(err.stack || err.message);
+  process.exit(1);
+});

package/template/wall-e/lib/mcp-integration.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+const WALLE_SERVER_NAME = 'wall-e';
+
+const MCP_TARGETS = Object.freeze([
+  { id: 'claude-code', tool: 'Claude Code', configPath: '.claude/mcp.json', detectPath: '.claude', kind: 'json' },
+  { id: 'claude-code-global', tool: 'Claude Code Global', configPath: '.claude.json', detectPath: '.claude.json', kind: 'json' },
+  { id: 'codex', tool: 'Codex', configPath: '.codex/config.toml', detectPath: '.codex', kind: 'codex-toml' },
+  { id: 'cursor', tool: 'Cursor', configPath: '.cursor/mcp.json', detectPath: '.cursor', kind: 'json' },
+  { id: 'windsurf', tool: 'Windsurf', configPath: '.codeium/windsurf/mcp_config.json', detectPath: '.codeium/windsurf', kind: 'json' },
+  { id: 'claude-desktop', tool: 'Claude Desktop', configPath: 'Library/Application Support/Claude/claude_desktop_config.json', detectPath: 'Library/Application Support/Claude', kind: 'json' },
+]);
+
+function wallEMcpUrl(wallePort) {
+  return `http://localhost:${Number(wallePort) || 3457}/mcp`;
+}
+
+function wallEMcpConfig(wallePort) {
+  return { type: 'http', url: wallEMcpUrl(wallePort) };
+}
+
+function _home(homeDir) {
+  return homeDir || process.env.HOME || process.env.USERPROFILE || '';
+}
+
+function _targetPaths(target, homeDir) {
+  const home = _home(homeDir);
+  return {
+    detectPath: path.join(home, target.detectPath),
+    configPath: path.join(home, target.configPath),
+  };
+}
+
+function _isDetected(target, homeDir) {
+  const paths = _targetPaths(target, homeDir);
+  return fs.existsSync(paths.detectPath);
+}
+
+function _readJsonConfig(configPath) {
+  if (!fs.existsSync(configPath)) return { config: {}, exists: false };
+  try {
+    return { config: JSON.parse(fs.readFileSync(configPath, 'utf8')), exists: true };
+  } catch (err) {
+    return { config: null, exists: true, error: err };
+  }
+}
+
+function _writeJsonConfig(configPath, config) {
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+function _jsonStatus(target, configPath, wallePort) {
+  const loaded = _readJsonConfig(configPath);
+  if (loaded.error) {
+    return { tool: target.tool, status: 'invalid_config', configPath, error: loaded.error.message };
+  }
+  const entry = loaded.config?.mcpServers?.[WALLE_SERVER_NAME];
+  if (entry && entry.url === wallEMcpUrl(wallePort)) {
+    return { tool: target.tool, status: 'configured', configPath };
+  }
+  if (entry) return { tool: target.tool, status: 'wrong_port', configPath, url: entry.url || '' };
+  return { tool: target.tool, status: 'not_configured', configPath };
+}
+
+function _ensureJsonTarget(target, configPath, wallePort) {
+  const loaded = _readJsonConfig(configPath);
+  if (loaded.error) {
+    return { tool: target.tool, action: 'error', configPath, error: loaded.error.message };
+  }
+  const config = loaded.config || {};
+  if (!config.mcpServers || typeof config.mcpServers !== 'object' || Array.isArray(config.mcpServers)) {
+    config.mcpServers = {};
+  }
+  const existing = config.mcpServers[WALLE_SERVER_NAME];
+  if (existing && existing.url === wallEMcpUrl(wallePort)) {
+    return { tool: target.tool, action: 'already_configured', configPath };
+  }
+  const action = existing ? 'updated' : 'added';
+  config.mcpServers[WALLE_SERVER_NAME] = wallEMcpConfig(wallePort);
+  _writeJsonConfig(configPath, config);
+  return { tool: target.tool, action, configPath };
+}
+
+function _codexBlockRegex() {
+  return /(^|\n)\[mcp_servers\.(?:"wall-e"|wall-e)\]\n[\s\S]*?(?=\n\[[^\n]+\]|\s*$)/m;
+}
+
+function _extractCodexWallEBlock(text) {
+  const match = String(text || '').match(_codexBlockRegex());
+  return match ? match[0].replace(/^\n/, '') : '';
+}
+
+function _extractTomlStringValue(block, key) {
+  const re = new RegExp(`^\\s*${key}\\s*=\\s*"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"\\s*$`, 'm');
+  const match = String(block || '').match(re);
+  if (!match) return '';
+  return match[1].replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+}
+
+function _codexStatus(target, configPath, wallePort) {
+  const text = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+  const block = _extractCodexWallEBlock(text);
+  if (!block) return { tool: target.tool, status: 'not_configured', configPath };
+  const url = _extractTomlStringValue(block, 'url');
+  if (url === wallEMcpUrl(wallePort)) return { tool: target.tool, status: 'configured', configPath };
+  return { tool: target.tool, status: 'wrong_port', configPath, url };
+}
+
+function _upsertCodexWallEBlock(text, wallePort) {
+  const body = String(text || '').replace(_codexBlockRegex(), '').replace(/\s+$/g, '');
+  const block = `[mcp_servers."wall-e"]\nurl = "${wallEMcpUrl(wallePort)}"\n`;
+  return (body ? `${body}\n\n` : '') + block;
+}
+
+function _ensureCodexTarget(target, configPath, wallePort) {
+  const existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+  const status = _codexStatus(target, configPath, wallePort);
+  if (status.status === 'configured') return { tool: target.tool, action: 'already_configured', configPath };
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, _upsertCodexWallEBlock(existing, wallePort));
+  return { tool: target.tool, action: status.status === 'wrong_port' ? 'updated' : 'added', configPath };
+}
+
+function detectMcpIntegrations(wallePort, opts = {}) {
+  const homeDir = opts.homeDir;
+  return MCP_TARGETS.map((target) => {
+    const paths = _targetPaths(target, homeDir);
+    if (!_isDetected(target, homeDir)) return { tool: target.tool, status: 'not_installed' };
+    if (target.kind === 'codex-toml') return _codexStatus(target, paths.configPath, wallePort);
+    return _jsonStatus(target, paths.configPath, wallePort);
+  });
+}
+
+function ensureMcpIntegrations(wallePort, opts = {}) {
+  const homeDir = opts.homeDir;
+  return MCP_TARGETS.map((target) => {
+    const paths = _targetPaths(target, homeDir);
+    if (!_isDetected(target, homeDir)) return { tool: target.tool, action: 'not_installed' };
+    if (target.kind === 'codex-toml') return _ensureCodexTarget(target, paths.configPath, wallePort);
+    return _ensureJsonTarget(target, paths.configPath, wallePort);
+  });
+}
+
+function injectMcpConfigs(wallePort, homeDir) {
+  return ensureMcpIntegrations(wallePort, { homeDir });
+}
+
+function _postMcp(port, payload, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify(payload);
+    const req = http.request({
+      host: '127.0.0.1',
+      port: Number(port) || 3457,
+      path: '/mcp',
+      method: 'POST',
+      timeout: timeoutMs,
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const raw = Buffer.concat(chunks).toString();
+        let json = null;
+        try { json = raw ? JSON.parse(raw) : null; } catch {}
+        resolve({ status: res.statusCode || 0, json, body: raw });
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('Timed out testing Wall-E MCP')));
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function testWallEMcpEndpoint(wallePort, opts = {}) {
+  const timeoutMs = opts.timeoutMs || 2000;
+  try {
+    const init = await _postMcp(wallePort, {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: { protocolVersion: '2025-03-26', capabilities: {}, clientInfo: { name: 'wall-e-self-test', version: '1.0.0' } },
+    }, timeoutMs);
+    if (init.status !== 200 || !init.json?.result?.serverInfo) {
+      return { ok: false, status: init.status, error: 'initialize failed' };
+    }
+    const tools = await _postMcp(wallePort, {
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'tools/list',
+      params: {},
+    }, timeoutMs);
+    const list = tools.json?.result?.tools;
+    if (tools.status !== 200 || !Array.isArray(list)) {
+      return { ok: false, status: tools.status, error: 'tools/list failed' };
+    }
+    return { ok: true, server: init.json.result.serverInfo, toolCount: list.length };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+module.exports = {
+  MCP_TARGETS,
+  WALLE_SERVER_NAME,
+  detectMcpIntegrations,
+  ensureMcpIntegrations,
+  injectMcpConfigs,
+  testWallEMcpEndpoint,
+  wallEMcpConfig,
+  wallEMcpUrl,
+};

package/template/wall-e/llm/ollama.js

@@ -2,6 +2,37 @@
 
 const { toOpenAI, messagesToOpenAI, responseFromOpenAI } = require('./tool-adapter');
 
+function isGemma4Model(model) {
+  return /^gemma4:/i.test(String(model || ''));
+}
+
+function resolveThinkValue({ model, thinking, reasoningEffort } = {}) {
+  if (thinking === false || thinking === 'disabled' || thinking === 'off') return false;
+  if (thinking === true || thinking === 'enabled' || thinking === 'on') return true;
+  if (['low', 'medium', 'high'].includes(thinking)) return thinking;
+
+  // Ollama's GPT-OSS models accept effort levels. Gemma4's thinking renderer
+  // accepts the boolean form, so keep Gemma4 on true when callers ask for any
+  // non-disabled reasoning effort.
+  if (reasoningEffort && reasoningEffort !== 'disabled') {
+    if (/^gpt-oss/i.test(String(model || '')) && ['low', 'medium', 'high'].includes(reasoningEffort)) {
+      return reasoningEffort;
+    }
+    return true;
+  }
+  return undefined;
+}
+
+function buildOllamaOptions({ model, maxTokens, temperature, options } = {}) {
+  const out = { ...(options || {}) };
+  if (maxTokens != null) out.num_predict = maxTokens;
+  if (temperature != null) out.temperature = temperature;
+  if (isGemma4Model(model) && out.num_ctx == null) {
+    out.num_ctx = 16384;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
 /**
  * Create an Ollama local-model LLM provider.
  * Uses Ollama's OpenAI-compatible API — no npm dependency needed.
@@ -9,11 +40,13 @@ const { toOpenAI, messagesToOpenAI, responseFromOpenAI } = require('./tool-adapt
  */
 function createOllamaProvider(config = {}) {
   const baseUrl = (config.baseUrl || 'http://localhost:11434').replace(/\/+$/, '');
+  const defaultThink = config.think ?? false;
 
   return {
     type: 'ollama',
 
-    async chat({ model, messages, tools, system, maxTokens, temperature, signal } = {}) {
+    async chat({ model, messages, tools, system, maxTokens, temperature, signal, thinking, reasoningEffort, options } = {}) {
+      const modelId = model || 'gemma4:e4b';
       const openaiMessages = [];
 
       // System prompt as first message
@@ -30,13 +63,15 @@ function createOllamaProvider(config = {}) {
       const useNativeApi = !tools || tools.length === 0;
 
       if (useNativeApi) {
+        const resolvedThink = resolveThinkValue({ model: modelId, thinking, reasoningEffort });
         const nativeBody = {
-          model: model || 'gemma4:e4b',
+          model: modelId,
           messages: openaiMessages,
           stream: false,
+          think: resolvedThink !== undefined ? resolvedThink : defaultThink,
         };
-        if (maxTokens != null) nativeBody.options = { ...nativeBody.options, num_predict: maxTokens };
-        if (temperature != null) nativeBody.options = { ...nativeBody.options, temperature };
+        const nativeOptions = buildOllamaOptions({ model: modelId, maxTokens, temperature, options });
+        if (nativeOptions) nativeBody.options = nativeOptions;
 
         const start = Date.now();
         const resp = await fetch(`${baseUrl}/api/chat`, {
@@ -54,6 +89,7 @@ function createOllamaProvider(config = {}) {
         const raw = await resp.json();
         const latencyMs = Date.now() - start;
         const msg = raw.message || {};
+        const reasoningContent = msg.thinking || msg.reasoning || msg.reasoning_content || null;
 
         // Extract accurate timing from native API (durations are in nanoseconds)
         const evalDurationNs = raw.eval_duration || 0;
@@ -65,6 +101,7 @@ function createOllamaProvider(config = {}) {
 
         return {
           content: msg.content || null,
+          reasoningContent,
           toolCalls: [],
           stopReason: 'end_turn',
           usage: {
@@ -76,17 +113,19 @@ function createOllamaProvider(config = {}) {
             promptEvalDurationMs: promptEvalDurationNs / 1e6,
           },
           latencyMs,
-          model: model || 'gemma4:e4b',
+          model: modelId,
           provider: 'ollama',
           raw,
         };
       }
 
       // Fall back to OpenAI-compat API for tool use
+      const resolvedThink = resolveThinkValue({ model: modelId, thinking, reasoningEffort });
       const body = {
-        model: model || 'gemma4:e4b',
+        model: modelId,
         messages: openaiMessages,
         stream: false,
+        think: resolvedThink !== undefined ? resolvedThink : defaultThink,
       };
 
       const openaiTools = toOpenAI(tools);
@@ -132,7 +171,7 @@ function createOllamaProvider(config = {}) {
       if (normalized.stopReason === 'tool_calls') stopReason = 'tool_use';
       else if (normalized.stopReason === 'stop' || !normalized.stopReason) stopReason = 'end_turn';
 
-      return { ...normalized, stopReason, latencyMs: Date.now() - start, model: model || 'gemma4:e4b', provider: 'ollama', raw };
+      return { ...normalized, stopReason, latencyMs: Date.now() - start, model: modelId, provider: 'ollama', raw };
     },
 
     async listModels() {
@@ -169,4 +208,4 @@ function createOllamaProvider(config = {}) {
   };
 }
 
-module.exports = { createOllamaProvider };
+module.exports = { createOllamaProvider, buildOllamaOptions, resolveThinkValue };

package/template/wall-e/llm/ollama.plugin.json

@@ -13,7 +13,7 @@
     "chat": true,
     "tools": true,
     "vision": false,
-    "thinking": false,
+    "thinking": true,
     "streaming": true,
     "local": true
   },

package/template/wall-e/llm/tool-adapter.js

@@ -205,6 +205,7 @@ function responseFromOpenAI(resp) {
 
   return {
     content: msg.content || null,
+    reasoningContent: msg.reasoning_content || msg.reasoning || msg.thinking || null,
     toolCalls: (msg.tool_calls || []).map((tc, index) => ({
       id: tc.id || synthesizeOpenAIToolCallId(index),
       name: tc.function.name,

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

@@ -1,22 +1,39 @@
 const brain = require('../brain');
 const eventBus = require('../events/event-bus');
 
+function checkpointName(adapter) {
+  const name = adapter?.name || adapter?.constructor?.name || 'unknown';
+  return `ingest:${name}`;
+}
+
+function newerTimestamp(a, b) {
+  if (!a) return b || null;
+  if (!b) return a;
+  return b > a ? b : a;
+}
+
 async function runOnce(adapters) {
-  const checkpoint = brain.getCheckpoint('ingest');
-  const since = checkpoint?.last_memory_at || null;
+  const legacyCheckpoint = brain.getCheckpoint('ingest');
   let memoriesIngested = 0;
-  let latestTimestamp = since;
+  let latestTimestamp = legacyCheckpoint?.last_memory_at || null;
+  const adapterResults = {};
 
   for (const adapter of adapters) {
+    const adapterCheckpointName = checkpointName(adapter);
+    const adapterCheckpoint = brain.getCheckpoint(adapterCheckpointName);
+    const since = adapterCheckpoint?.last_memory_at || null;
+    let adapterIngested = 0;
+    let adapterLatestTimestamp = since;
+
     try {
       const memories = await adapter.poll(since);
       for (const mem of memories) {
+        adapterLatestTimestamp = newerTimestamp(adapterLatestTimestamp, mem.timestamp);
+        latestTimestamp = newerTimestamp(latestTimestamp, mem.timestamp);
         const result = brain.insertMemory(mem);
         if (result) {
           memoriesIngested++;
-          if (!latestTimestamp || mem.timestamp > latestTimestamp) {
-            latestTimestamp = mem.timestamp;
-          }
+          adapterIngested++;
           if (mem.importance >= 0.8 || mem.memory_type === 'message_received') {
             eventBus.emitHighImportance(result?.id, (mem.content || '').slice(0, 200));
           }
@@ -59,17 +76,34 @@ async function runOnce(adapters) {
           console.error('[ingest] Exchange chunking failed:', e.message);
         }
       }
+      brain.upsertCheckpoint(adapterCheckpointName, {
+        last_memory_at: adapterLatestTimestamp,
+        metadata: JSON.stringify({
+          adapter: adapter.name || adapter.constructor?.name || 'unknown',
+          memories_ingested: adapterIngested,
+          memories_seen: memories.length,
+        }),
+      });
+      adapterResults[adapter.name || adapter.constructor?.name || 'unknown'] = {
+        memoriesIngested: adapterIngested,
+        memoriesSeen: memories.length,
+        lastMemoryAt: adapterLatestTimestamp,
+      };
     } catch (err) {
       console.error(`[ingest] Adapter ${adapter.name} failed:`, err.message);
+      adapterResults[adapter.name || adapter.constructor?.name || 'unknown'] = {
+        error: err.message,
+        lastMemoryAt: adapterLatestTimestamp,
+      };
     }
   }
 
   brain.upsertCheckpoint('ingest', {
     last_memory_at: latestTimestamp,
-    metadata: JSON.stringify({ memories_ingested: memoriesIngested }),
+    metadata: JSON.stringify({ memories_ingested: memoriesIngested, adapters: adapterResults }),
   });
 
   return { memoriesIngested };
 }
 
-module.exports = { runOnce };
+module.exports = { checkpointName, runOnce };