create-walle 0.9.11 → 0.9.13

package/template/wall-e/evaluation/agent-router.js

@@ -1,5 +1,11 @@
 'use strict';
 
+const {
+  normalizeHarness,
+  scoreHarness,
+  selectAgentHarness,
+} = require('../agent-runtime/harness');
+
 function normalizeCandidate(candidate = {}) {
   const runnerId = candidate.runnerId || candidate.id;
   return {
@@ -34,6 +40,14 @@ function scoreAgentRunner(stats = {}, candidate = {}) {
   ));
 }
 
+function applyQuorumRiskScore(baseScore, stats = {}) {
+  const passRate = numberOr(stats.pass_rate ?? stats.review_pass_rate, null);
+  if (passRate == null) return baseScore;
+  if (passRate < 0.4) return Math.max(0, baseScore - 0.20);
+  if (passRate >= 0.85) return Math.min(1, baseScore + 0.05);
+  return baseScore;
+}
+
 function selectBestAgentRunners(taskType, candidates = [], brain = null, opts = {}) {
   const count = Math.max(1, opts.count || 1);
   const days = opts.days || 30;
@@ -48,7 +62,7 @@ function selectBestAgentRunners(taskType, candidates = [], brain = null, opts =
     } catch {
       stats = null;
     }
-    const score = scoreAgentRunner(stats || {}, candidate);
+    const score = applyQuorumRiskScore(scoreAgentRunner(stats || {}, candidate), stats || {});
     return { candidate, stats, score, index };
   });
 
@@ -68,9 +82,47 @@ function selectBestAgentRunner(taskType, candidates = [], brain = null, opts = {
   return selectBestAgentRunners(taskType, candidates, brain, { ...opts, count: 1 })[0] || null;
 }
 
+function selectBestAgentHarness(request = {}, candidates = [], brain = null, opts = {}) {
+  const taskType = request.taskType || opts.taskType || 'coding:general';
+  const normalized = candidates.map((candidate) => {
+    const harness = normalizeHarness(candidate);
+    let stats = null;
+    try {
+      stats = brain?.getAgentRunnerScorecard
+        ? brain.getAgentRunnerScorecard(harness.runnerId, taskType, opts.days || 30)
+        : null;
+    } catch {
+      stats = null;
+    }
+    const qualityScore = scoreAgentRunner(stats || {}, harness);
+    return {
+      ...harness,
+      qualityScore,
+      stats,
+    };
+  });
+  const selection = selectAgentHarness(request, normalized, {
+    ...opts,
+    qualityScore: undefined,
+    providerAvailability: opts.providerAvailability,
+  });
+  if (!selection.selected) return null;
+  return {
+    ...selection.selected,
+    score: scoreHarness(selection.selected, request, {
+      ...opts,
+      providerAvailability: opts.providerAvailability,
+      qualityScore: selection.selected.qualityScore,
+    }),
+    selection,
+  };
+}
+
 module.exports = {
+  applyQuorumRiskScore,
   normalizeCandidate,
   scoreAgentRunner,
   selectBestAgentRunner,
   selectBestAgentRunners,
+  selectBestAgentHarness,
 };

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

@@ -2,6 +2,7 @@
 
 const { randomUUID } = require('node:crypto');
 const codingReview = require('../coding-review');
+const { recordReview } = require('../runtime/execution-trace');
 
 const SCORE_KEYS = ['correctness', 'completeness', 'tests', 'maintainability', 'security'];
 const VERDICTS = new Set(['pass', 'revise', 'block']);
@@ -252,6 +253,42 @@ function aggregateCodingReviews(reviews = []) {
   };
 }
 
+function qualityFromCodingAggregate(aggregate = {}) {
+  const scoreValues = Object.values(aggregate.scores || {}).filter(Number.isFinite);
+  const scoreAverage = scoreValues.length > 0
+    ? scoreValues.reduce((sum, value) => sum + value, 0) / scoreValues.length / 5
+    : 0.7;
+  const verdictPenalty = aggregate.verdict === 'block' ? 0.55 : aggregate.verdict === 'revise' ? 0.20 : 0;
+  const confidence = Number.isFinite(aggregate.confidence) ? aggregate.confidence : 0.7;
+  const blended = scoreAverage * 0.75 + confidence * 0.25 - verdictPenalty;
+  return Math.max(0, Math.min(1, Math.round(blended * 1000) / 1000));
+}
+
+function recordCodingQuorumLearning(result = {}, options = {}, brain = null) {
+  if (!brain?.insertAgentRunnerEvaluation) return null;
+  const builder = options.builder || {};
+  const runnerId = builder.runnerId || options.workerRunnerId || options.runnerId;
+  if (!runnerId) return null;
+  const trace = options.trace || null;
+  const changedFiles = Array.isArray(options.changedFiles) ? options.changedFiles : [];
+  const aggregate = result.aggregate || {};
+  return brain.insertAgentRunnerEvaluation({
+    runnerId,
+    providerType: builder.providerType || options.workerProvider || null,
+    modelId: builder.modelId || options.workerModel || null,
+    taskType: options.taskType || 'coding:subtask',
+    phase: options.phase || 'coding:review-gated',
+    qualityScore: qualityFromCodingAggregate(aggregate),
+    latencyMs: options.latencyMs ?? trace?.latencyMs ?? null,
+    testsPassed: options.testsPassed ?? (result.requiredTests?.length === 0 ? true : null),
+    reviewVerdict: result.verdict || aggregate.verdict || null,
+    retries: Math.max(0, (trace?.attempts?.length || 1) - 1),
+    filesChanged: changedFiles.length,
+    costEstimate: options.costEstimate ?? null,
+    wasSelected: true,
+  });
+}
+
 function selectCodingReviewers(options = {}) {
   const quorumSize = Math.max(1, options.quorumSize || options.reviewQuorumSize || 2);
   const reviewers = Array.isArray(options.reviewers) ? options.reviewers.filter(Boolean) : [];
@@ -290,7 +327,7 @@ async function runCodingQuorum(options = {}, deps = {}) {
   });
   const aggregate = aggregateCodingReviews(reviews);
 
-  return {
+  const result = {
     quorumId,
     prompt,
     reviewers,
@@ -314,12 +351,22 @@ async function runCodingQuorum(options = {}, deps = {}) {
       requiredTestCount: aggregate.requiredTests.length,
     },
   };
+  recordReview(options.trace, result);
+  const persistedEvaluationId = recordCodingQuorumLearning(result, options, options.brain || deps.brain);
+  if (persistedEvaluationId) {
+    result.learningSignals.persistedEvaluationId = persistedEvaluationId;
+    result.learningSignals.builderRunnerId = options.builder?.runnerId || options.workerRunnerId || options.runnerId || null;
+    result.learningSignals.qualityScore = qualityFromCodingAggregate(aggregate);
+  }
+  return result;
 }
 
 module.exports = {
   buildCodingReviewPrompt,
   parseCodingReview,
   aggregateCodingReviews,
+  qualityFromCodingAggregate,
+  recordCodingQuorumLearning,
   selectCodingReviewers,
   runCodingQuorum,
 };

package/template/wall-e/evaluation/router.js

@@ -251,7 +251,9 @@ async function routeRequest(options, deps = {}) {
     if (brain && brain.getBenchmarkLeaderboard) {
       const benchLb = brain.getBenchmarkLeaderboard({ days: 30 });
       for (const entry of benchLb) {
-        if (entry.avg_score >= 0.7 && entry.total_evals >= 10) {
+        const trustedEvals = Number(entry.trusted_evals) || 0;
+        const qualityScore = entry.trusted_avg_score != null ? Number(entry.trusted_avg_score) : null;
+        if (qualityScore != null && qualityScore >= 0.7 && trustedEvals >= 10) {
           const modelId = entry.model;
           if (candidates.some(c => c.modelId === modelId)) continue;
           candidates.push({
@@ -261,7 +263,7 @@ async function routeRequest(options, deps = {}) {
             modelId,
             speed_tier: 2,
             cost_per_1m_input: 0,
-            _benchScore: entry,
+            _benchScore: { ...entry, quality_score: qualityScore },
           });
         }
       }

package/template/wall-e/evaluation/tier-selector.js

@@ -51,7 +51,7 @@ function isCritical(complexityTier) {
 function selectModelForTier(modelTier, providerType, opts = {}) {
   // 1. Check env var override
   const envVar = TIER_ENV_VARS[modelTier];
-  if (envVar && process.env[envVar]) {
+  if (envVar && process.env[envVar] && _modelMatchesProvider(process.env[envVar], providerType)) {
     return process.env[envVar];
   }
 
@@ -75,6 +75,16 @@ function selectModelForTier(modelTier, providerType, opts = {}) {
   return DEFAULT_TIER_MODELS.anthropic[modelTier];
 }
 
+function _modelMatchesProvider(model, providerType) {
+  try {
+    const registry = require('../llm/registry');
+    registry.ensureBootstrapped();
+    return registry.modelMatchesProvider(model, providerType);
+  } catch {
+    return true;
+  }
+}
+
 /**
  * Select the best worker model given complexity assessment and available providers.
  * @param {object} complexityResult - Output from assessComplexity() with .tier

package/template/wall-e/extraction/contradiction.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const brain = require('../brain.js');
-const { getDefaultClient } = require('../llm/client');
+const { getDefaultClient, getDefaultModel, resolveCompatibleModel } = require('../llm/client');
 
 const MAX_CONTENT_LENGTH = 2000;
 
@@ -197,8 +197,8 @@ async function detectContradictions(newEntries, ownerName, opts = {}) {
       contradictions = opts.detectFn(existing, entries, ownerName);
     } else {
       // Call Claude API
-      const model = opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
       const provider = opts.client || getDefaultClient();
+      const model = resolveCompatibleModel(opts.model || process.env.WALLE_MODEL || getDefaultModel(), provider.type);
       const prompt = buildContradictionPrompt(existing, entries, ownerName);
 
       const controller = new AbortController();

package/template/wall-e/extraction/indexer.js

@@ -138,8 +138,9 @@ RULES:
 - quotes: 2-5 entries. EXACT verbatim from content (15-150 chars each).
 - Output valid JSON only. No code fences. No commentary.`;
 
+    const { getDefaultModel, resolveCompatibleModel } = require('../llm/client');
     const response = await opts.client.chat({
-      model: opts.model || 'claude-haiku-4-5-20251001',
+      model: resolveCompatibleModel(opts.model || process.env.WALLE_MODEL || getDefaultModel(), opts.client.type),
       maxTokens: 1024,
       messages: [{ role: 'user', content: prompt }],
     });

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

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getDefaultClient } = require('../llm/client');
+const { getDefaultClient, getDefaultModel, resolveCompatibleModel } = require('../llm/client');
 const { buildClientOptsFromEnv } = require('../llm/anthropic');
 
 const VALID_CATEGORIES = ['technical', 'preference', 'relationship', 'work', 'personal', 'world'];
@@ -131,8 +131,8 @@ async function extractKnowledge(memories, ownerName, opts = {}) {
     return empty;
   }
 
-  const model = opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
   const provider = opts.client || getDefaultClient();
+  const model = resolveCompatibleModel(opts.model || process.env.WALLE_MODEL || getDefaultModel(), provider.type);
 
   const prompt = buildExtractionPrompt(memories, ownerName);
 

package/template/wall-e/hooks/cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+  handlePrecompact,
+  handleSessionStart,
+  handleStop,
+  runLockedIngest,
+} = require('./session-memory');
+
+async function main(argv = process.argv.slice(2), stdin = process.stdin) {
+  const command = argv[0] || '';
+  const opts = parseArgs(argv.slice(1));
+
+  if (command === 'ingest-file') {
+    const result = await runLockedIngest({
+      adapterId: opts.adapter,
+      uri: opts.file,
+      sourceFile: opts.file,
+      sourceId: opts.sourceId || undefined,
+      cwd: opts.cwd || '',
+    });
+    writeJson(result);
+    return result;
+  }
+
+  const data = await readStdinJson(stdin);
+  const harness = opts.harness || 'walle';
+  let result;
+  if (command === 'session-start') {
+    result = await handleSessionStart(data, { harness });
+  } else if (command === 'stop') {
+    result = await handleStop(data, { harness, background: opts.background !== 'false' });
+  } else if (command === 'precompact') {
+    result = await handlePrecompact(data, { harness });
+  } else {
+    throw new Error(`Unknown hook command: ${command}`);
+  }
+  writeJson(result);
+  return result;
+}
+
+function parseArgs(argv) {
+  const opts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+    const key = arg.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const next = argv[i + 1];
+    if (!next || next.startsWith('--')) {
+      opts[key] = 'true';
+    } else {
+      opts[key] = next;
+      i += 1;
+    }
+  }
+  return opts;
+}
+
+function readStdinJson(stdin) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stdin.on('data', (chunk) => chunks.push(chunk));
+    stdin.on('error', reject);
+    stdin.on('end', () => {
+      const text = Buffer.concat(chunks).toString('utf8').trim();
+      if (!text) return resolve({});
+      try {
+        resolve(JSON.parse(text));
+      } catch (err) {
+        reject(new Error(`Invalid hook JSON: ${err.message}`));
+      }
+    });
+  });
+}
+
+function writeJson(result) {
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    process.stderr.write(`[wall-e-hook] ${err.message}\n`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  main,
+  parseArgs,
+  readStdinJson,
+};

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

@@ -0,0 +1,119 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  HOOK_MANIFEST,
+  MAX_HOOK_MANIFEST_BYTES,
+  validateHookManifest,
+} = require('./manifest');
+
+function discoverHookPackages({ roots = [], enabled = null } = {}) {
+  const packages = [];
+  const diagnostics = [];
+  const enabledSet = enabled ? new Set(enabled) : null;
+
+  for (const root of roots || []) {
+    const rootResult = safeRealpath(root);
+    if (!rootResult.ok) {
+      diagnostics.push({ level: 'warn', root, reason: rootResult.reason });
+      continue;
+    }
+    const rootReal = rootResult.realpath;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(rootReal, { withFileTypes: true });
+    } catch (err) {
+      diagnostics.push({ level: 'warn', root: rootReal, reason: err.message });
+      continue;
+    }
+    const candidateDirs = [
+      { name: '.', dir: rootReal },
+      ...entries.filter(entry => entry.isDirectory()).map(entry => ({ name: entry.name, dir: path.join(rootReal, entry.name) })),
+    ];
+    for (const candidate of candidateDirs) {
+      const manifestPath = path.join(candidate.dir, HOOK_MANIFEST);
+      if (!fs.existsSync(manifestPath)) continue;
+      const loaded = loadHookManifest(manifestPath, { rootReal, packageDir: candidate.dir });
+      diagnostics.push(...loaded.diagnostics);
+      if (!loaded.ok) continue;
+      if (enabledSet && !enabledSet.has(loaded.package.manifest.id)) {
+        diagnostics.push({ level: 'info', id: loaded.package.manifest.id, reason: 'not enabled' });
+        continue;
+      }
+      packages.push(loaded.package);
+    }
+  }
+  return { packages, diagnostics };
+}
+
+function loadHookManifest(manifestPath, { rootReal, packageDir }) {
+  const diagnostics = [];
+  let manifestReal;
+  let packageReal;
+  try {
+    manifestReal = fs.realpathSync(manifestPath);
+    packageReal = fs.realpathSync(packageDir);
+  } catch (err) {
+    return { ok: false, diagnostics: [{ level: 'warn', path: manifestPath, reason: err.message }] };
+  }
+  if (!isInside(rootReal, manifestReal) || !isInside(rootReal, packageReal)) {
+    return { ok: false, diagnostics: [{ level: 'error', path: manifestPath, reason: 'hook package escapes root' }] };
+  }
+  const stat = fs.statSync(manifestReal);
+  if (stat.size > MAX_HOOK_MANIFEST_BYTES) {
+    return { ok: false, diagnostics: [{ level: 'error', path: manifestPath, reason: 'manifest too large' }] };
+  }
+  if ((fs.statSync(packageReal).mode & 0o002) !== 0) {
+    return { ok: false, diagnostics: [{ level: 'error', path: packageReal, reason: 'hook package is world-writable' }] };
+  }
+
+  let raw;
+  let parsed;
+  try {
+    raw = fs.readFileSync(manifestReal, 'utf8');
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    return { ok: false, diagnostics: [{ level: 'error', path: manifestPath, reason: err.message }] };
+  }
+  const validation = validateHookManifest(parsed, { packageDir: packageReal });
+  if (!validation.ok) {
+    return {
+      ok: false,
+      diagnostics: validation.errors.map(reason => ({ level: 'error', path: manifestPath, reason })),
+    };
+  }
+  const entryPath = path.resolve(packageReal, validation.manifest.entry);
+  const entryRealResult = safeRealpath(entryPath);
+  if (!entryRealResult.ok || !isInside(packageReal, entryRealResult.realpath)) {
+    return { ok: false, diagnostics: [{ level: 'error', path: entryPath, reason: 'entry escapes hook package' }] };
+  }
+  return {
+    ok: true,
+    package: {
+      manifest: validation.manifest,
+      manifestPath: manifestReal,
+      entryPath: entryRealResult.realpath,
+    },
+    diagnostics,
+  };
+}
+
+function safeRealpath(target) {
+  try {
+    return { ok: true, realpath: fs.realpathSync(target) };
+  } catch (err) {
+    return { ok: false, reason: err.message };
+  }
+}
+
+function isInside(root, target) {
+  const rel = path.relative(root, target);
+  return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+module.exports = {
+  discoverHookPackages,
+  isInside,
+  loadHookManifest,
+};

package/template/wall-e/hooks/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = {
+  ...require('./discovery'),
+  ...require('./manifest'),
+  ...require('./runtime'),
+};

package/template/wall-e/hooks/manifest.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const HOOK_MANIFEST = 'walle-hook.json';
+const MAX_HOOK_MANIFEST_BYTES = 128 * 1024;
+
+const HOOK_EVENTS = Object.freeze([
+  'before_prompt_build',
+  'llm_input',
+  'llm_output',
+  'agent_end',
+  'tool_result',
+  'session_patch',
+  'message_received',
+  'message_sent',
+]);
+
+function validateHookManifest(manifest = {}, { packageDir = '' } = {}) {
+  const errors = [];
+  if (!manifest.id || typeof manifest.id !== 'string') errors.push('id is required');
+  if (manifest.id && !/^[a-z0-9][a-z0-9._-]*$/i.test(manifest.id)) errors.push('id has invalid characters');
+  if (!manifest.entry || typeof manifest.entry !== 'string') errors.push('entry is required');
+  if (manifest.entry && (manifest.entry.includes('..') || manifest.entry.startsWith('/') || manifest.entry.includes('\\'))) {
+    errors.push('entry must be a relative path inside the hook package');
+  }
+  const events = Array.isArray(manifest.events) ? manifest.events : [];
+  if (events.length === 0) errors.push('events must include at least one supported event');
+  for (const event of events) {
+    if (!HOOK_EVENTS.includes(event)) errors.push(`unsupported event: ${event}`);
+  }
+  const permissions = manifest.permissions || {};
+  for (const key of Object.keys(permissions)) {
+    if (typeof permissions[key] !== 'boolean') errors.push(`permission ${key} must be boolean`);
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    manifest: {
+      id: manifest.id || '',
+      version: manifest.version || '0.0.0',
+      events,
+      entry: manifest.entry || '',
+      permissions,
+      packageDir,
+      metadata: { ...(manifest.metadata || {}) },
+    },
+  };
+}
+
+module.exports = {
+  HOOK_EVENTS,
+  HOOK_MANIFEST,
+  MAX_HOOK_MANIFEST_BYTES,
+  validateHookManifest,
+};

package/template/wall-e/hooks/runtime.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { HOOK_EVENTS } = require('./manifest');
+
+class HookRuntime {
+  constructor({ logger = console } = {}) {
+    this.logger = logger;
+    this.handlers = new Map();
+    this.packages = new Map();
+    this.diagnostics = [];
+  }
+
+  registerPackage(hookPackage) {
+    const manifest = hookPackage?.manifest;
+    if (!manifest?.id) throw new Error('Hook package manifest id is required');
+    if (this.packages.has(manifest.id)) throw new Error(`Duplicate hook package: ${manifest.id}`);
+    const moduleExports = hookPackage.module || require(hookPackage.entryPath);
+    const registered = {
+      ...hookPackage,
+      module: moduleExports,
+    };
+    this.packages.set(manifest.id, registered);
+    for (const event of manifest.events || []) {
+      if (!HOOK_EVENTS.includes(event)) continue;
+      const list = this.handlers.get(event) || [];
+      list.push({ id: manifest.id, event, module: moduleExports, permissions: manifest.permissions || {} });
+      this.handlers.set(event, list);
+    }
+    return registered;
+  }
+
+  registerDiscovered(discoveryResult = {}) {
+    for (const diagnostic of discoveryResult.diagnostics || []) this.diagnostics.push(diagnostic);
+    for (const hookPackage of discoveryResult.packages || []) {
+      try {
+        this.registerPackage(hookPackage);
+      } catch (err) {
+        this.diagnostics.push({ level: 'error', id: hookPackage.manifest?.id, reason: err.message });
+      }
+    }
+  }
+
+  async trigger(event, payload = {}, context = {}) {
+    if (!HOOK_EVENTS.includes(event)) throw new Error(`Unsupported hook event: ${event}`);
+    let current = payload;
+    const handlers = this.handlers.get(event) || [];
+    for (const handler of handlers) {
+      try {
+        const next = await callHandler(handler, event, current, context);
+        if (next !== undefined) current = next;
+      } catch (err) {
+        const diagnostic = { level: 'error', hook: handler.id, event, reason: err.message };
+        this.diagnostics.push(diagnostic);
+        if (this.logger?.error) this.logger.error(`[hook-runtime] ${handler.id}:${event}: ${err.message}`);
+      }
+    }
+    return current;
+  }
+
+  listHooks() {
+    return [...this.packages.values()].map(pkg => ({
+      id: pkg.manifest.id,
+      version: pkg.manifest.version,
+      events: pkg.manifest.events,
+      permissions: pkg.manifest.permissions,
+    }));
+  }
+
+  getDiagnostics() {
+    return [...this.diagnostics];
+  }
+}
+
+async function callHandler(handler, event, payload, context) {
+  const exported = handler.module;
+  if (typeof exported === 'function') return exported(event, payload, context);
+  if (typeof exported?.handle === 'function') return exported.handle(event, payload, context);
+  if (typeof exported?.[event] === 'function') return exported[event](payload, context);
+  return undefined;
+}
+
+module.exports = {
+  HookRuntime,
+};