create-walle 0.9.13 → 0.9.15

package/template/wall-e/eval/run-agent-benchmarks.js

@@ -28,7 +28,7 @@ const path = require('path');
 const crypto = require('crypto');
 process.chdir(path.join(__dirname, '..'));
 
-const { setupSandbox, cleanupSandbox, runAgentBenchmark, runAgentBenchmarkSuite, resolveModelName } = require('./agent-runner');
+const { setupSandbox, cleanupSandbox, runAgentBenchmark, runAgentBenchmarkSuite, resolveModelName, isTrustedAgentResult } = require('./agent-runner');
 const { decorateBenchmarkResult, DEFAULT_SCORER_VERSION } = require('./manifest');
 const benchmarks = require('./benchmarks/coding-agent.json');
 
@@ -334,6 +334,7 @@ function storeBenchmarkResult({ brain, runId, benchmark, result, provider, model
     const scoringMethod = benchmark.agentExpectations?.testCommand
       ? 'agent-rubric+tests'
       : 'agent-rubric';
+    const trusted = isTrustedBenchmarkResult(result);
     brain.insertBenchmarkResult(decorateBenchmarkResult({
       runId,
       suite: 'coding-agent',
@@ -359,7 +360,7 @@ function storeBenchmarkResult({ brain, runId, benchmark, result, provider, model
       outputTokens: result.outputTokens ?? null,
       scorerVersion: DEFAULT_SCORER_VERSION,
       scoringMethod,
-      trusted: !result.error && result.testsPassed === true,
+      trusted,
       runConfig: { timeoutMs, scoringMethod },
     }, {
       suite: 'coding-agent',
@@ -369,10 +370,17 @@ function storeBenchmarkResult({ brain, runId, benchmark, result, provider, model
       model: resolveModelName(modelId),
       scoringMethod,
       scorerVersion: DEFAULT_SCORER_VERSION,
-      trusted: !result.error && result.testsPassed === true,
+      trusted,
       runConfig: { timeoutMs, scoringMethod },
     }));
   } catch (err) {
     console.warn(`  [WARN] Failed to store benchmark result: ${err.message}`);
   }
 }
+
+function isTrustedBenchmarkResult(result = {}) {
+  return !result.error &&
+    result.testsPassed === true &&
+    (result.score?.composite || 0) > 0 &&
+    result.score?.dimensions?._zeroed !== true;
+}

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/eval/run-model-comparison.js

@@ -29,6 +29,7 @@ async function runWithModel(bench, modelName) {
       timeoutMs: 180000,
       model: modelName,
       mode: 'build',
+      persistTranscript: false,
     });
 
     const latencyMs = Date.now() - start;

package/template/wall-e/eval/swebench-adapter.js

@@ -158,6 +158,7 @@ async function runSWEBenchTask(task, options = {}) {
             provider,
             model,
             maxTurns: 30,
+            persistTranscript: false,
           }),
           new Promise((_, reject) => {
             timeoutHandle = setTimeout(() => reject(new Error('Agent timeout')), timeoutMs);

package/template/wall-e/evaluation/quorum-evaluator.js

@@ -324,7 +324,6 @@ async function runQuorum(options, deps = {}) {
 
   // If no workerResponse, use backward-compat legacy flow
   if (!workerResponse) {
-    try { require('../compat').recordCompatUsage('legacy_quorum_consensus'); } catch {}
     return runLegacyQuorum(options, deps);
   }
 

package/template/wall-e/extraction/knowledge-extractor.js

@@ -81,8 +81,7 @@ function parseExtractionResponse(text) {
       knowledgeEntries = parsed.knowledge;
       classifications = Array.isArray(parsed.classifications) ? parsed.classifications : [];
     } else if (Array.isArray(parsed)) {
-      // Legacy format: plain array of knowledge entries
-      try { require('../compat').recordCompatUsage('legacy_knowledge_format'); } catch {}
+      // Plain array tolerance for older model outputs and tests.
       knowledgeEntries = parsed;
     } else {
       return { knowledge: [], classifications: [] };

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

@@ -0,0 +1,336 @@
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+const WALLE_SERVER_NAME = 'wall-e';
+const AGENT_INSTRUCTIONS_BEGIN = '<!-- wall-e-memory-routing:start -->';
+const AGENT_INSTRUCTIONS_END = '<!-- wall-e-memory-routing:end -->';
+
+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' },
+]);
+
+const AGENT_INSTRUCTION_TARGETS = Object.freeze([
+  {
+    id: 'claude-code-instructions',
+    tool: 'Claude Code Memory Instructions',
+    instructionPath: '.claude/CLAUDE.md',
+    detectPaths: ['.claude', '.claude.json'],
+  },
+  {
+    id: 'codex-instructions',
+    tool: 'Codex Memory Instructions',
+    instructionPath: '.codex/AGENTS.md',
+    detectPaths: ['.codex'],
+  },
+]);
+
+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 _isInstructionTargetDetected(target, homeDir) {
+  const home = _home(homeDir);
+  return target.detectPaths.some(detectPath => fs.existsSync(path.join(home, 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 { kind: 'mcp_config', 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 { kind: 'mcp_config', tool: target.tool, status: 'configured', configPath };
+  }
+  if (entry) return { kind: 'mcp_config', tool: target.tool, status: 'wrong_port', configPath, url: entry.url || '' };
+  return { kind: 'mcp_config', tool: target.tool, status: 'not_configured', configPath };
+}
+
+function _ensureJsonTarget(target, configPath, wallePort) {
+  const loaded = _readJsonConfig(configPath);
+  if (loaded.error) {
+    return { kind: 'mcp_config', 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 { kind: 'mcp_config', tool: target.tool, action: 'already_configured', configPath };
+  }
+  const action = existing ? 'updated' : 'added';
+  config.mcpServers[WALLE_SERVER_NAME] = wallEMcpConfig(wallePort);
+  _writeJsonConfig(configPath, config);
+  return { kind: 'mcp_config', 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 { kind: 'mcp_config', tool: target.tool, status: 'not_configured', configPath };
+  const url = _extractTomlStringValue(block, 'url');
+  if (url === wallEMcpUrl(wallePort)) return { kind: 'mcp_config', tool: target.tool, status: 'configured', configPath };
+  return { kind: 'mcp_config', 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 { kind: 'mcp_config', tool: target.tool, action: 'already_configured', configPath };
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, _upsertCodexWallEBlock(existing, wallePort));
+  return { kind: 'mcp_config', tool: target.tool, action: status.status === 'wrong_port' ? 'updated' : 'added', configPath };
+}
+
+function wallEAgentMemoryInstructions(wallePort) {
+  return `${AGENT_INSTRUCTIONS_BEGIN}
+## Wall-E MCP Memory Routing
+
+Wall-E MCP is the user's private memory, knowledge graph, and CTM coding-session context. It is configured at ${wallEMcpUrl(wallePort)}.
+
+Use Wall-E memory before public web search or guesswork for any private, remembered, or work-context question, including:
+- prior sessions, previous attempts, branch/task history, regressions, decisions, preferences, and "last time" / "remember" / "what did we discuss" prompts;
+- people, teams, projects, tools, documents, Slack/email/calendar/work context, and "do you know" / "who is" / "what is" prompts;
+- requests that explicitly say to use the user's context, Wall-E memory, CTM sessions, or past agent work.
+
+Recommended tools:
+- \`walle_lookup_context\` for one-shot route + private memory/entity/CTM session context lookup.
+- \`walle_route_query\` when you are unsure whether the request should use Wall-E, live source tools, or public web.
+- \`walle_memory_status\` when connection health is uncertain.
+- \`walle_context_pack\`, \`walle_search_sessions\`, and \`walle_get_session\` for prior coding-agent context.
+- \`search_memories\`, \`ask_walle\`, \`entity_search\`, and \`knowledge_query\` for user/work memory and knowledge graph lookup.
+
+Do not use Wall-E as a reflex for every request. Use live host tools for explicit current inbox/calendar/Slack reads or side-effecting actions such as send, post, create, schedule, update, or delete. Use public web search for public/current facts, or after Wall-E returns no useful memory. If Wall-E memory is unavailable, say that explicitly. Keep private details minimal; do not expose private links, emails, or full transcripts unless the user needs them.
+${AGENT_INSTRUCTIONS_END}
+`;
+}
+
+function _upsertMarkedBlock(text, block) {
+  const existing = String(text || '').replace(/\r\n/g, '\n');
+  const nextBlock = String(block || '').trimEnd() + '\n';
+  const start = existing.indexOf(AGENT_INSTRUCTIONS_BEGIN);
+  const end = existing.indexOf(AGENT_INSTRUCTIONS_END);
+  if (start >= 0 && end > start) {
+    const afterEnd = end + AGENT_INSTRUCTIONS_END.length;
+    return `${existing.slice(0, start)}${nextBlock}${existing.slice(afterEnd).replace(/^\n+/, '\n')}`;
+  }
+  const prefix = existing.trimEnd();
+  return prefix ? `${prefix}\n\n${nextBlock}` : nextBlock;
+}
+
+function _instructionStatus(target, instructionPath, wallePort) {
+  if (!fs.existsSync(instructionPath)) {
+    return { kind: 'agent_instructions', tool: target.tool, status: 'not_configured', configPath: instructionPath };
+  }
+  const existing = fs.readFileSync(instructionPath, 'utf8');
+  const expected = wallEAgentMemoryInstructions(wallePort).trimEnd();
+  if (existing.includes(expected)) {
+    return { kind: 'agent_instructions', tool: target.tool, status: 'configured', configPath: instructionPath };
+  }
+  if (existing.includes(AGENT_INSTRUCTIONS_BEGIN) && existing.includes(AGENT_INSTRUCTIONS_END)) {
+    return { kind: 'agent_instructions', tool: target.tool, status: 'stale', configPath: instructionPath };
+  }
+  return { kind: 'agent_instructions', tool: target.tool, status: 'not_configured', configPath: instructionPath };
+}
+
+function _ensureInstructionTarget(target, homeDir, wallePort) {
+  if (!_isInstructionTargetDetected(target, homeDir)) {
+    return { kind: 'agent_instructions', tool: target.tool, action: 'not_installed' };
+  }
+  const instructionPath = path.join(_home(homeDir), target.instructionPath);
+  const status = _instructionStatus(target, instructionPath, wallePort);
+  if (status.status === 'configured') {
+    return { kind: 'agent_instructions', tool: target.tool, action: 'already_configured', configPath: instructionPath };
+  }
+  const existing = fs.existsSync(instructionPath) ? fs.readFileSync(instructionPath, 'utf8') : '';
+  fs.mkdirSync(path.dirname(instructionPath), { recursive: true });
+  fs.writeFileSync(instructionPath, _upsertMarkedBlock(existing, wallEAgentMemoryInstructions(wallePort)));
+  return {
+    kind: 'agent_instructions',
+    tool: target.tool,
+    action: status.status === 'stale' ? 'updated' : 'added',
+    configPath: instructionPath,
+  };
+}
+
+function detectAgentMemoryInstructions(wallePort, opts = {}) {
+  const homeDir = opts.homeDir;
+  return AGENT_INSTRUCTION_TARGETS.map((target) => {
+    if (!_isInstructionTargetDetected(target, homeDir)) {
+      return { kind: 'agent_instructions', tool: target.tool, status: 'not_installed' };
+    }
+    return _instructionStatus(target, path.join(_home(homeDir), target.instructionPath), wallePort);
+  });
+}
+
+function ensureAgentMemoryInstructions(wallePort, opts = {}) {
+  const homeDir = opts.homeDir;
+  return AGENT_INSTRUCTION_TARGETS.map(target => _ensureInstructionTarget(target, homeDir, wallePort));
+}
+
+function detectMcpIntegrations(wallePort, opts = {}) {
+  const homeDir = opts.homeDir;
+  return MCP_TARGETS.map((target) => {
+    const paths = _targetPaths(target, homeDir);
+    if (!_isDetected(target, homeDir)) return { kind: 'mcp_config', 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;
+  const mcpResults = MCP_TARGETS.map((target) => {
+    const paths = _targetPaths(target, homeDir);
+    if (!_isDetected(target, homeDir)) return { kind: 'mcp_config', tool: target.tool, action: 'not_installed' };
+    if (target.kind === 'codex-toml') return _ensureCodexTarget(target, paths.configPath, wallePort);
+    return _ensureJsonTarget(target, paths.configPath, wallePort);
+  });
+  if (opts.includeAgentInstructions === false) return mcpResults;
+  return mcpResults.concat(ensureAgentMemoryInstructions(wallePort, { homeDir }));
+}
+
+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 = {
+  AGENT_INSTRUCTION_TARGETS,
+  AGENT_INSTRUCTIONS_BEGIN,
+  AGENT_INSTRUCTIONS_END,
+  MCP_TARGETS,
+  WALLE_SERVER_NAME,
+  detectAgentMemoryInstructions,
+  detectMcpIntegrations,
+  ensureAgentMemoryInstructions,
+  ensureMcpIntegrations,
+  injectMcpConfigs,
+  testWallEMcpEndpoint,
+  wallEAgentMemoryInstructions,
+  wallEMcpConfig,
+  wallEMcpUrl,
+};