create-walle 0.9.11 → 0.9.13

package/template/wall-e/memory/source-indexer.js

@@ -0,0 +1,289 @@
+'use strict';
+
+const { generateMemoryIndex, extractKeyEntities, extractKeyTopics } = require('../extraction/indexer');
+
+const MAX_FIELD = 20;
+
+function createSourceIndexEntry(memory) {
+  if (!memory || !memory.id || !memory.content) return null;
+  const content = String(memory.content || '');
+  if (content.trim().length < 10) return null;
+
+  const metadata = parseMetadata(memory.metadata);
+  const base = generateMemoryIndex(memory) || {
+    memory_id: memory.id,
+    summary: content.slice(0, 200).trim(),
+    key_entities: null,
+    key_topics: null,
+    domain: memory.domain || null,
+    topic: memory.topic || null,
+    timestamp: memory.timestamp,
+  };
+
+  const filesTouched = uniqueStrings([
+    ...arrayOfStrings(metadata.filesEdited),
+    ...arrayOfStrings(metadata.changed_files),
+    ...extractFilesTouched(content),
+  ], MAX_FIELD);
+  const commandsRun = uniqueStrings([
+    ...arrayOfStrings(metadata.commands),
+    ...extractCommandsRun(content),
+  ], MAX_FIELD);
+  const decisions = uniqueStrings(extractDecisions(content), MAX_FIELD);
+  const failuresBlockers = uniqueStrings(extractFailuresBlockers(content), MAX_FIELD);
+  const exactQuotes = extractExactQuotes(content);
+  validateExactQuotes(content, exactQuotes);
+
+  const genericTopics = parseJsonArray(base.key_topics);
+  const sourceId = metadata.sourceId || inferSourceId(memory.source_id);
+  const sourceFacts = {
+    topics: uniqueStrings([
+      ...genericTopics,
+      ...extractKeyTopics(content),
+      ...filesTouched,
+      ...commandsRun.map(commandTopic),
+      ...decisions.map(shortTopic),
+      ...failuresBlockers.map(shortTopic),
+      sourceId,
+    ], 60),
+    filesTouched,
+    commandsRun,
+    decisions,
+    failuresBlockers,
+    exactQuotes,
+    sourceId,
+    cwd: metadata.cwd || memory.source_channel || '',
+    branch: metadata.gitBranch || metadata.branch || '',
+    role: metadata.role || '',
+    memoryType: memory.memory_type || '',
+  };
+
+  return {
+    memory_id: memory.id,
+    summary: buildSummary(base.summary, sourceFacts),
+    key_entities: JSON.stringify(uniqueStrings([
+      ...parseJsonArray(base.key_entities),
+      ...extractKeyEntities(content),
+    ], 30)),
+    key_topics: JSON.stringify(sourceFacts),
+    domain: memory.domain || domainForMemory(memory),
+    topic: memory.topic || topicForMemory(memory, sourceFacts),
+    timestamp: memory.timestamp,
+  };
+}
+
+function indexMemory(memory, { brain = require('../brain') } = {}) {
+  const entry = createSourceIndexEntry(memory);
+  if (!entry) return null;
+  return brain.insertMemoryIndex(entry);
+}
+
+function rebuildSourceIndex({ brain = require('../brain'), sourceId = '', dryRun = false, limit = 10000 } = {}) {
+  const db = brain.getDb();
+  const params = [];
+  const conditions = ['archived_at IS NULL', 'content IS NOT NULL', 'length(content) > 10'];
+  if (sourceId) {
+    conditions.push('(source_id = ? OR source_id LIKE ? OR metadata LIKE ?)');
+    params.push(sourceId, `${sourceId}:%`, `%"sourceId":"${escapeLikeJson(sourceId)}"%`);
+  }
+  params.push(Math.min(Math.max(Number(limit) || 10000, 1), 50000));
+  const memories = db.prepare(`
+    SELECT * FROM memories
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY timestamp ASC
+    LIMIT ?
+  `).all(...params);
+
+  if (dryRun) {
+    return { dry_run: true, source_id: sourceId || null, scanned: memories.length, indexed: 0, skipped: 0 };
+  }
+
+  let indexed = 0;
+  let skipped = 0;
+  const run = db.transaction(() => {
+    for (const memory of memories) {
+      const entry = createSourceIndexEntry(memory);
+      if (!entry) {
+        skipped++;
+        continue;
+      }
+      brain.insertMemoryIndex(entry);
+      indexed++;
+    }
+  });
+  run();
+  return { dry_run: false, source_id: sourceId || null, scanned: memories.length, indexed, skipped };
+}
+
+function extractFilesTouched(content) {
+  const files = [];
+  const re = /(?:^|[\s`'"(])((?:\.?[A-Za-z0-9_.@-]+\/)+[A-Za-z0-9_.@-]+\.[A-Za-z0-9]+|[A-Za-z0-9_.@-]+\.(?:js|ts|tsx|jsx|json|md|py|go|rs|java|rb|css|html|sql|sh|yml|yaml))(?=[\s`'",):;.\]]|$)/g;
+  let match;
+  while ((match = re.exec(content))) {
+    const value = match[1].replace(/^[./]*\/+/, '').replace(/[),.;:]+$/, '');
+    if (value && !value.includes('node_modules/')) files.push(value);
+  }
+  return files;
+}
+
+function extractCommandsRun(content) {
+  const commands = [];
+  const lineRe = /(?:^|\n)\s*(?:\$|>|Command:|Run:|ran)\s+([^\n]{2,220})/gi;
+  let match;
+  while ((match = lineRe.exec(content))) commands.push(cleanCommand(match[1]));
+  const inlineRe = /\b((?:node|npm|pnpm|yarn|git|npx|python|pytest|cargo|go test|ruby|bash|make)\s+[^\n.;]{2,180})/gi;
+  while ((match = inlineRe.exec(content))) commands.push(cleanCommand(match[1]));
+  return commands.filter(Boolean);
+}
+
+function extractDecisions(content) {
+  return extractLabeledLines(content, [
+    /\bdecision\s*:\s*(.+)$/i,
+    /\bdecided\s+(?:to|that)\s+(.+)$/i,
+    /\bwe will\s+(.+)$/i,
+    /\buse\s+(.+?)\s+instead of\s+(.+)$/i,
+  ]);
+}
+
+function extractFailuresBlockers(content) {
+  return extractLabeledLines(content, [
+    /\bblocker\s*:\s*(.+)$/i,
+    /\bblocked by\s+(.+)$/i,
+    /\bfailed because\s+(.+)$/i,
+    /\berror\s*:\s*(.+)$/i,
+  ]);
+}
+
+function extractLabeledLines(content, patterns) {
+  const results = [];
+  for (const rawLine of String(content || '').split('\n')) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match?.[1]) {
+        results.push(match[1].trim());
+        break;
+      }
+    }
+  }
+  return results;
+}
+
+function extractExactQuotes(content) {
+  const text = String(content || '');
+  const lines = text.split('\n').map((line) => line.trim()).filter((line) => line.length >= 18);
+  const scored = lines
+    .map((line) => ({ line, score: quoteScore(line) }))
+    .sort((a, b) => b.score - a.score)
+    .map(({ line }) => line.slice(0, 180));
+  return uniqueStrings(scored, 5);
+}
+
+function validateExactQuotes(content, quotes) {
+  for (const quote of quotes || []) {
+    if (!String(content || '').includes(quote)) {
+      throw new Error(`source index quote is not verbatim: ${quote.slice(0, 40)}`);
+    }
+  }
+}
+
+function quoteScore(line) {
+  let score = Math.min(line.length, 160) / 160;
+  if (/\b(decision|decided|blocker|failed|error|command|test|file|fix)\b/i.test(line)) score += 1;
+  if (/[`$]/.test(line)) score += 0.4;
+  if (/\.[A-Za-z0-9]+/.test(line)) score += 0.3;
+  return score;
+}
+
+function buildSummary(baseSummary, facts) {
+  const parts = [baseSummary || 'Coding session memory'];
+  if (facts.filesTouched.length) parts.push(`Files: ${facts.filesTouched.slice(0, 4).join(', ')}`);
+  if (facts.decisions.length) parts.push(`Decisions: ${facts.decisions.slice(0, 2).join('; ')}`);
+  if (facts.failuresBlockers.length) parts.push(`Blockers: ${facts.failuresBlockers.slice(0, 2).join('; ')}`);
+  return parts.join(' | ').slice(0, 700);
+}
+
+function domainForMemory(memory) {
+  const source = memory.source || '';
+  const type = memory.memory_type || '';
+  return source.endsWith('-jsonl') || type.startsWith('coding_session_') ? 'technical' : null;
+}
+
+function topicForMemory(memory, facts) {
+  if (facts.failuresBlockers.length) return 'bugs';
+  if (facts.decisions.length) return 'decision';
+  if ((memory.memory_type || '').includes('tool')) return 'tools';
+  return facts.filesTouched.length ? 'coding' : null;
+}
+
+function parseMetadata(value) {
+  try {
+    const parsed = JSON.parse(value || '{}');
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function parseJsonArray(value) {
+  try {
+    const parsed = JSON.parse(value || '[]');
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
+  } catch {
+    return [];
+  }
+}
+
+function arrayOfStrings(value) {
+  return Array.isArray(value)
+    ? value.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim())
+    : [];
+}
+
+function uniqueStrings(values, limit = MAX_FIELD) {
+  const seen = new Set();
+  const out = [];
+  for (const value of values || []) {
+    const item = String(value || '').trim();
+    if (!item || seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function inferSourceId(sourceId = '') {
+  const parts = String(sourceId || '').split(':');
+  if (parts.length <= 2) return sourceId || '';
+  return parts.slice(0, 2).join(':');
+}
+
+function cleanCommand(value) {
+  return String(value || '').trim().replace(/^`|`$/g, '').replace(/\s+/g, ' ').slice(0, 220);
+}
+
+function commandTopic(command) {
+  return String(command || '').split(/\s+/).slice(0, 3).join(' ');
+}
+
+function shortTopic(value) {
+  return String(value || '').slice(0, 120);
+}
+
+function escapeLikeJson(value) {
+  return String(value || '').replace(/["\\]/g, '');
+}
+
+module.exports = {
+  createSourceIndexEntry,
+  extractCommandsRun,
+  extractDecisions,
+  extractExactQuotes,
+  extractFailuresBlockers,
+  extractFilesTouched,
+  indexMemory,
+  rebuildSourceIndex,
+  validateExactQuotes,
+};

package/template/wall-e/plugins/discovery.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MAX_PLUGIN_MANIFEST_BYTES = 256 * 1024;
+
+function inspectPluginCandidate(pluginDir, { rootDir = null, maxManifestBytes = MAX_PLUGIN_MANIFEST_BYTES } = {}) {
+  const diagnostics = [];
+  let dirReal;
+  try {
+    dirReal = fs.realpathSync(pluginDir);
+  } catch (err) {
+    return { ok: false, diagnostics: [{ level: 'warn', message: err.message, path: pluginDir }] };
+  }
+  const rootReal = rootDir ? safeRealpath(rootDir) : dirReal;
+  if (rootDir && (!rootReal || !isInside(rootReal, dirReal))) {
+    diagnostics.push({ level: 'error', message: 'plugin directory escapes root', path: pluginDir });
+  }
+  const manifestPath = path.join(dirReal, 'walle.plugin.json');
+  if (!fs.existsSync(manifestPath)) return { ok: false, diagnostics };
+  const stat = fs.statSync(manifestPath);
+  if (stat.size > maxManifestBytes) {
+    diagnostics.push({ level: 'error', message: 'plugin manifest too large', path: manifestPath });
+  }
+  const dirMode = fs.statSync(dirReal).mode;
+  if ((dirMode & 0o002) !== 0) {
+    diagnostics.push({ level: 'error', message: 'plugin directory is world-writable', path: dirReal });
+  }
+  return {
+    ok: diagnostics.filter(d => d.level === 'error').length === 0,
+    realpath: dirReal,
+    manifestPath,
+    diagnostics,
+  };
+}
+
+function discoverPluginCandidates({ roots = [], source = 'user' } = {}) {
+  const candidates = [];
+  const diagnostics = [];
+  for (const root of roots || []) {
+    const rootReal = safeRealpath(root);
+    if (!rootReal) {
+      diagnostics.push({ level: 'warn', message: `cannot read plugin root: ${root}`, source });
+      continue;
+    }
+    let entries = [];
+    try {
+      entries = fs.readdirSync(rootReal, { withFileTypes: true });
+    } catch (err) {
+      diagnostics.push({ level: 'warn', message: `cannot scan plugin root ${root}: ${err.message}`, source });
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name.startsWith('_')) continue;
+      const dir = path.join(rootReal, entry.name);
+      const inspected = inspectPluginCandidate(dir, { rootDir: rootReal });
+      diagnostics.push(...inspected.diagnostics.map(d => ({ ...d, source })));
+      if (inspected.ok) candidates.push({ dir: inspected.realpath, manifestPath: inspected.manifestPath, source });
+    }
+  }
+  return { candidates, diagnostics };
+}
+
+function safeRealpath(target) {
+  try {
+    return fs.realpathSync(target);
+  } catch {
+    return null;
+  }
+}
+
+function isInside(root, target) {
+  const rel = path.relative(root, target);
+  return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+module.exports = {
+  MAX_PLUGIN_MANIFEST_BYTES,
+  discoverPluginCandidates,
+  inspectPluginCandidate,
+  isInside,
+};

package/template/wall-e/plugins/manifest-loader.js

@@ -2,7 +2,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { validateManifest } = require('./manifest-validator');
+const { normalizePluginManifest } = require('./manifest-schema');
+const { MAX_PLUGIN_MANIFEST_BYTES, isInside } = require('./discovery');
 
 const MANIFEST_FILENAME = 'walle.plugin.json';
 
@@ -14,7 +15,7 @@ const MANIFEST_FILENAME = 'walle.plugin.json';
  * @param {string} pluginDir - Directory to look in
  * @param {string} [source]  - Plugin source for diagnostics (bundled/user/...)
  */
-function loadManifestFromDir(pluginDir, source) {
+function loadManifestFromDir(pluginDir, source, options = {}) {
   const manifestPath = path.join(pluginDir, MANIFEST_FILENAME);
   if (!fs.existsSync(manifestPath)) {
     return { manifest: null, diagnostics: [] };
@@ -22,6 +23,32 @@ function loadManifestFromDir(pluginDir, source) {
 
   let raw;
   try {
+    const stat = fs.statSync(manifestPath);
+    if (stat.size > (options.maxManifestBytes || MAX_PLUGIN_MANIFEST_BYTES)) {
+      return {
+        manifest: null,
+        diagnostics: [{
+          level: 'error',
+          message: `Manifest too large: ${manifestPath}`,
+          source: source || 'unknown',
+        }],
+      };
+    }
+    if (options.rootDir) {
+      const rootReal = fs.realpathSync(options.rootDir);
+      const manifestReal = fs.realpathSync(manifestPath);
+      const dirReal = fs.realpathSync(pluginDir);
+      if (!isInside(rootReal, manifestReal) || !isInside(rootReal, dirReal)) {
+        return {
+          manifest: null,
+          diagnostics: [{
+            level: 'error',
+            message: `Manifest escapes plugin root: ${manifestPath}`,
+            source: source || 'unknown',
+          }],
+        };
+      }
+    }
     raw = fs.readFileSync(manifestPath, 'utf8');
   } catch (e) {
     return {
@@ -52,7 +79,7 @@ function loadManifestFromDir(pluginDir, source) {
     };
   }
 
-  const result = validateManifest(parsed, { source });
+  const result = normalizePluginManifest(parsed, { source });
   if (result.valid) {
     return {
       manifest: { ...parsed, dir: pluginDir, manifestPath, source: source || 'unknown' },
@@ -67,10 +94,11 @@ function loadManifestFromDir(pluginDir, source) {
  * Returns { manifests: [...], diagnostics: [...] }.
  *
  * Inspired by OpenClaw's `src/plugins/discovery.ts:discoverOpenClawPlugins`,
- * but simpler: no caching, no boundary-file safety, no ownership UID check
- * (we trust the local filesystem since Wall-E is single-user).
+ * but scoped to Wall-E's local filesystem: manifest size and realpath
+ * containment are enforced here; ownership/world-writable checks live in
+ * plugins/discovery.js for callers that need full candidate hardening.
  */
-function loadManifestsFromDir(rootDir, source) {
+function loadManifestsFromDir(rootDir, source, options = {}) {
   const manifests = [];
   const diagnostics = [];
 
@@ -93,7 +121,7 @@ function loadManifestsFromDir(rootDir, source) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith('_') || entry.name.startsWith('.')) continue;
-    const result = loadManifestFromDir(path.join(rootDir, entry.name), source);
+    const result = loadManifestFromDir(path.join(rootDir, entry.name), source, { ...options, rootDir });
     diagnostics.push(...result.diagnostics);
     if (result.manifest) manifests.push(result.manifest);
   }
@@ -110,7 +138,7 @@ function loadManifestsFromDir(rootDir, source) {
  * @param {string} entryFile - Path to the JS module (sibling .plugin.json is read)
  * @param {string} [source]
  */
-function loadSiblingManifest(entryFile, source) {
+function loadSiblingManifest(entryFile, source, options = {}) {
   const dir = path.dirname(entryFile);
   const base = path.basename(entryFile, path.extname(entryFile));
   const manifestPath = path.join(dir, `${base}.plugin.json`);
@@ -121,6 +149,17 @@ function loadSiblingManifest(entryFile, source) {
 
   let raw;
   try {
+    const stat = fs.statSync(manifestPath);
+    if (stat.size > (options.maxManifestBytes || MAX_PLUGIN_MANIFEST_BYTES)) {
+      return {
+        manifest: null,
+        diagnostics: [{
+          level: 'error',
+          message: `Manifest too large: ${manifestPath}`,
+          source: source || 'unknown',
+        }],
+      };
+    }
     raw = fs.readFileSync(manifestPath, 'utf8');
   } catch (e) {
     return {
@@ -151,7 +190,7 @@ function loadSiblingManifest(entryFile, source) {
     };
   }
 
-  const result = validateManifest(parsed, { source });
+  const result = normalizePluginManifest(parsed, { source });
   if (result.valid) {
     return {
       manifest: {
@@ -198,7 +237,7 @@ function loadSiblingManifestsFromDir(rootDir, source, options = {}) {
     if (exclude.has(entry.name)) continue;
     const stem = entry.name.replace(/\.plugin\.json$/, '');
     const entryFile = path.join(rootDir, `${stem}.js`);
-    const result = loadSiblingManifest(entryFile, source);
+    const result = loadSiblingManifest(entryFile, source, options);
     diagnostics.push(...result.diagnostics);
     if (result.manifest) manifests.push(result.manifest);
   }
@@ -212,4 +251,5 @@ module.exports = {
   loadManifestsFromDir,
   loadSiblingManifest,
   loadSiblingManifestsFromDir,
+  normalizePluginManifest,
 };

package/template/wall-e/plugins/manifest-schema.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const { validateManifest } = require('./manifest-validator');
+
+const ACTIVATION_TRIGGERS = new Set([
+  'startup',
+  'provider',
+  'agentHarness',
+  'command',
+  'channel',
+  'route',
+  'configPath',
+  'capability',
+]);
+
+function normalizePluginManifest(manifest = {}, opts = {}) {
+  const base = validateManifest(manifest, opts);
+  const diagnostics = [...base.diagnostics];
+  const pluginId = typeof manifest.id === 'string' ? manifest.id : undefined;
+  const source = opts.source || 'unknown';
+
+  if (manifest.activation !== undefined) {
+    const activation = Array.isArray(manifest.activation) ? manifest.activation : [];
+    if (!Array.isArray(manifest.activation)) {
+      diagnostics.push({ level: 'error', message: 'activation must be an array', fieldPath: 'activation', pluginId, source });
+    }
+    for (const item of activation) {
+      if (!item || typeof item !== 'object' || !ACTIVATION_TRIGGERS.has(item.type)) {
+        diagnostics.push({ level: 'error', message: `unsupported activation trigger: ${item?.type}`, fieldPath: 'activation', pluginId, source });
+      }
+    }
+  }
+
+  if (manifest.modelSupport !== undefined) {
+    const support = manifest.modelSupport;
+    const valid = support && typeof support === 'object' && (
+      Array.isArray(support.prefixes) || Array.isArray(support.patterns) || Array.isArray(support.models)
+    );
+    if (!valid) diagnostics.push({ level: 'error', message: 'modelSupport must declare prefixes, patterns, or models', fieldPath: 'modelSupport', pluginId, source });
+  }
+
+  if (manifest.modelCatalog !== undefined && !Array.isArray(manifest.modelCatalog)) {
+    diagnostics.push({ level: 'error', message: 'modelCatalog must be an array', fieldPath: 'modelCatalog', pluginId, source });
+  }
+
+  if (manifest.configSchema !== undefined && (!manifest.configSchema || typeof manifest.configSchema !== 'object')) {
+    diagnostics.push({ level: 'error', message: 'configSchema must be an object', fieldPath: 'configSchema', pluginId, source });
+  }
+
+  if (manifest.permissions !== undefined) {
+    for (const [key, value] of Object.entries(manifest.permissions || {})) {
+      if (typeof value !== 'boolean') {
+        diagnostics.push({ level: 'error', message: `permission ${key} must be boolean`, fieldPath: `permissions.${key}`, pluginId, source });
+      }
+    }
+  }
+
+  const errorCount = diagnostics.filter(d => d.level === 'error').length;
+  return {
+    valid: errorCount === 0,
+    manifest: errorCount === 0 ? manifest : undefined,
+    diagnostics,
+  };
+}
+
+module.exports = {
+  ACTIVATION_TRIGGERS,
+  normalizePluginManifest,
+};

package/template/wall-e/plugins/model-catalog.js

@@ -0,0 +1,55 @@
+'use strict';
+
+function normalizeModelId(providerId, modelId) {
+  const provider = String(providerId || '').trim().toLowerCase();
+  const model = String(modelId || '').trim();
+  if (!model) return '';
+  if (model.includes('/')) return model;
+  return provider ? `${provider}/${model}` : model;
+}
+
+function buildModelCatalog(manifests = []) {
+  const models = new Map();
+  const aliases = new Map();
+  for (const manifest of manifests || []) {
+    if (manifest.kind !== 'provider') continue;
+    const providerId = manifest.id;
+    for (const item of manifest.modelCatalog || []) {
+      const normalizedId = normalizeModelId(providerId, item.id || item.model);
+      if (!normalizedId) continue;
+      const record = {
+        id: normalizedId,
+        providerId,
+        model: normalizedId.split('/').slice(1).join('/'),
+        displayName: item.displayName || item.name || normalizedId,
+        contextWindow: item.contextWindow || item.context_window || null,
+        inputCostPer1M: item.inputCostPer1M ?? item.input_cost_per_1m ?? null,
+        outputCostPer1M: item.outputCostPer1M ?? item.output_cost_per_1m ?? null,
+        capabilities: { ...(item.capabilities || {}) },
+      };
+      models.set(normalizedId, record);
+      for (const alias of item.aliases || []) aliases.set(String(alias), normalizedId);
+    }
+    for (const prefix of manifest.modelPrefixes || []) aliases.set(prefix, `${providerId}/${prefix}*`);
+  }
+  return {
+    list: () => [...models.values()],
+    resolve: (id) => {
+      const raw = String(id || '');
+      if (models.has(raw)) return models.get(raw);
+      if (aliases.has(raw) && models.has(aliases.get(raw))) return models.get(aliases.get(raw));
+      for (const [alias, target] of aliases.entries()) {
+        if (target.endsWith('*') && raw.startsWith(alias)) {
+          return { id: normalizeModelId(target.slice(0, target.indexOf('/')), raw), providerId: target.slice(0, target.indexOf('/')), model: raw, inferred: true };
+        }
+      }
+      return null;
+    },
+    aliases: () => new Map(aliases),
+  };
+}
+
+module.exports = {
+  buildModelCatalog,
+  normalizeModelId,
+};

package/template/wall-e/prompts/coding/base.txt

@@ -0,0 +1,2 @@
+Wall-E coding prompt bundle v1.
+Use the selected coding tools to inspect, edit, and verify the repository. Keep tool descriptions in the registry, not in this prompt file.

package/template/wall-e/prompts/coding/deepseek.txt

@@ -0,0 +1 @@
+DeepSeek mode reminder: keep tool-loop turns concise and avoid carrying reasoning blocks back into later tool-result requests.

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

@@ -0,0 +1,9 @@
+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.
+- 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`.
+- 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.
+- At stop, handoff, or before compaction, call `walle_diary_write` with decisions, changed files, commands, blockers, and next steps.
+- Diary entries are operational state, not prose. Keep them concise and specific enough for the next agent to resume.

package/template/wall-e/prompts/coding/plan.txt

@@ -0,0 +1 @@
+Planning mode reminder: edits, writes, patches, and shell mutations are forbidden. Produce analysis and a concrete implementation plan only.