create-walle 0.9.25 → 0.9.26

package/template/wall-e/lib/runtime-health.js

@@ -0,0 +1,206 @@
+'use strict';
+
+const { runtimeDiagnosticsEnabled } = require('./diagnostics-flags');
+
+const DEFAULT_RECENT_LIMIT = 80;
+const DEFAULT_TOP_LIMIT = 20;
+const MAX_ACTIVE_AGE_MS = 60 * 60 * 1000;
+
+const state = {
+  startedAt: Date.now(),
+  sequence: 0,
+  active: new Map(),
+  byName: new Map(),
+  recent: [],
+};
+
+function _now() {
+  return Date.now();
+}
+
+function _durationMs(value, fallback = 0) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.round(n)) : fallback;
+}
+
+function _safeName(name) {
+  const raw = String(name || 'operation').trim() || 'operation';
+  return raw
+    .replace(/\/Users\/[^/\s]+/g, '/Users/<user>')
+    .replace(/[A-Za-z]:\\Users\\[^\\\s]+/g, 'C:\\Users\\<user>')
+    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<uuid>')
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '<email>')
+    .slice(0, 120);
+}
+
+function _safeMeta(meta = {}) {
+  const out = {};
+  for (const [key, value] of Object.entries(meta || {})) {
+    if (value == null) continue;
+    const safeKey = String(key).replace(/[^a-zA-Z0-9_.:-]/g, '').slice(0, 48);
+    if (!safeKey) continue;
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      out[safeKey] = value;
+    } else if (typeof value === 'string') {
+      out[safeKey] = _safeName(value);
+    }
+  }
+  return out;
+}
+
+function beginOperation(name, meta = {}) {
+  if (!runtimeDiagnosticsEnabled()) {
+    return { id: 0, end() { return null; } };
+  }
+  const id = ++state.sequence;
+  const safeName = _safeName(name);
+  const startedAt = _now();
+  state.active.set(id, {
+    id,
+    name: safeName,
+    startedAt,
+    meta: _safeMeta(meta),
+  });
+  return {
+    id,
+    end(extra = {}) {
+      return endOperation(id, extra);
+    },
+  };
+}
+
+function endOperation(id, extra = {}) {
+  const active = state.active.get(id);
+  if (!active) return null;
+  state.active.delete(id);
+  const endedAt = _now();
+  const durationMs = _durationMs(extra.durationMs, endedAt - active.startedAt);
+  const ok = extra.ok !== false;
+  const entry = {
+    name: active.name,
+    durationMs,
+    ok,
+    at: new Date(endedAt).toISOString(),
+    meta: { ...active.meta, ..._safeMeta(extra.meta || {}) },
+  };
+  if (extra.error) entry.error = _safeName(extra.error?.code || extra.error?.name || 'error');
+  recordOperation(entry.name, durationMs, { ok, error: entry.error, meta: entry.meta, atMs: endedAt });
+  return entry;
+}
+
+function recordOperation(name, durationMs, options = {}) {
+  if (!runtimeDiagnosticsEnabled()) return null;
+  const safeName = _safeName(name);
+  const ms = _durationMs(durationMs);
+  let bucket = state.byName.get(safeName);
+  if (!bucket) {
+    bucket = {
+      name: safeName,
+      count: 0,
+      ok: 0,
+      failed: 0,
+      totalMs: 0,
+      maxMs: 0,
+      samples: [],
+      lastAt: null,
+      lastError: null,
+      lastMeta: {},
+    };
+    state.byName.set(safeName, bucket);
+  }
+  const safeMeta = _safeMeta(options.meta || {});
+  bucket.count += 1;
+  bucket.totalMs += ms;
+  bucket.maxMs = Math.max(bucket.maxMs, ms);
+  bucket.lastAt = new Date(options.atMs || _now()).toISOString();
+  bucket.lastMeta = safeMeta;
+  if (options.ok === false) {
+    bucket.failed += 1;
+    bucket.lastError = _safeName(options.error || 'error');
+  } else {
+    bucket.ok += 1;
+  }
+  bucket.samples.push(ms);
+  if (bucket.samples.length > 128) bucket.samples.splice(0, bucket.samples.length - 128);
+
+  state.recent.push({
+    name: safeName,
+    durationMs: ms,
+    ok: options.ok !== false,
+    at: bucket.lastAt,
+    ...(Object.keys(safeMeta).length ? { meta: safeMeta } : {}),
+    ...(options.error ? { error: _safeName(options.error) } : {}),
+  });
+  if (state.recent.length > DEFAULT_RECENT_LIMIT) {
+    state.recent.splice(0, state.recent.length - DEFAULT_RECENT_LIMIT);
+  }
+}
+
+function _percentile(values, p) {
+  if (!values.length) return 0;
+  const sorted = values.slice().sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * p) - 1));
+  return sorted[idx];
+}
+
+function snapshot(options = {}) {
+  if (!runtimeDiagnosticsEnabled()) {
+    state.active.clear();
+    return {
+      enabled: false,
+      uptimeMs: _now() - state.startedAt,
+      active: [],
+      operations: [],
+      recent: [],
+    };
+  }
+  const now = _now();
+  for (const [id, op] of state.active.entries()) {
+    if (now - op.startedAt > MAX_ACTIVE_AGE_MS) state.active.delete(id);
+  }
+  const topLimit = Math.max(1, Math.min(100, Number(options.topLimit) || DEFAULT_TOP_LIMIT));
+  const recentLimit = Math.max(0, Math.min(DEFAULT_RECENT_LIMIT, Number(options.recentLimit) || 10));
+  const operations = Array.from(state.byName.values())
+    .map((bucket) => ({
+      name: bucket.name,
+      count: bucket.count,
+      failed: bucket.failed,
+      avgMs: bucket.count ? Math.round(bucket.totalMs / bucket.count) : 0,
+      maxMs: bucket.maxMs,
+      p95Ms: _percentile(bucket.samples, 0.95),
+      lastAt: bucket.lastAt,
+      lastError: bucket.lastError,
+      lastMeta: bucket.lastMeta || {},
+    }))
+    .sort((a, b) => b.maxMs - a.maxMs || b.count - a.count)
+    .slice(0, topLimit);
+
+  return {
+    enabled: true,
+    uptimeMs: now - state.startedAt,
+    active: Array.from(state.active.values()).map((op) => ({
+      id: op.id,
+      name: op.name,
+      ageMs: now - op.startedAt,
+      meta: op.meta,
+    })),
+    operations,
+    recent: recentLimit > 0 ? state.recent.slice(-recentLimit) : [],
+  };
+}
+
+function resetForTests() {
+  state.startedAt = _now();
+  state.sequence = 0;
+  state.active.clear();
+  state.byName.clear();
+  state.recent.splice(0);
+}
+
+module.exports = {
+  beginOperation,
+  endOperation,
+  recordOperation,
+  snapshot,
+  _resetForTests: resetForTests,
+};

package/template/wall-e/lib/runtime-worker-pool.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const path = require('node:path');
+const { WorkerThreadPool } = require('./worker-thread-pool');
+
+let _pool = null;
+
+function _truthy(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
+}
+
+function _falsey(value) {
+  return ['0', 'false', 'no', 'off'].includes(String(value || '').trim().toLowerCase());
+}
+
+function runtimeWorkerPoolEnabled(env = process.env) {
+  const value = env.WALL_E_RUNTIME_WORKER_POOL ?? env.WALLE_RUNTIME_WORKER_POOL;
+  if (_falsey(value)) return false;
+  if (_truthy(value)) return true;
+  return true;
+}
+
+function runtimeWorkerPoolSize(env = process.env) {
+  const n = Number(env.WALL_E_RUNTIME_WORKER_POOL_SIZE ?? env.WALLE_RUNTIME_WORKER_POOL_SIZE);
+  if (!Number.isFinite(n) || n <= 0) return 2;
+  return Math.min(8, Math.max(1, Math.trunc(n)));
+}
+
+function runtimeWorkerRequestTimeoutMs(env = process.env) {
+  const n = Number(env.WALL_E_RUNTIME_WORKER_TIMEOUT_MS ?? env.WALLE_RUNTIME_WORKER_TIMEOUT_MS);
+  if (!Number.isFinite(n) || n <= 0) return 180 * 1000;
+  return Math.max(1000, Math.trunc(n));
+}
+
+function runtimeWorkerEnv(env = process.env) {
+  const workerEnv = {
+    ...env,
+    WALL_E_PROCESS_ROLE: 'wall-e-runtime-worker',
+  };
+  // Wall-E runtime workers own Wall-E work. They must not inherit CTM's
+  // process role because brain/session DB guards use that role to reject
+  // direct embedded access from the CTM server process.
+  delete workerEnv.CTM_PROCESS_ROLE;
+  return workerEnv;
+}
+
+function getRuntimeWorkerPool(options = {}) {
+  if (!runtimeWorkerPoolEnabled(options.env || process.env)) return null;
+  if (_pool) return _pool;
+  const env = options.env || process.env;
+  _pool = new WorkerThreadPool({
+    name: 'wall-e-runtime',
+    workerPath: options.workerPath || path.resolve(__dirname, '..', 'workers', 'runtime-worker.js'),
+    size: options.size || runtimeWorkerPoolSize(env),
+    requestTimeoutMs: options.requestTimeoutMs || runtimeWorkerRequestTimeoutMs(env),
+    closeTimeoutMs: options.closeTimeoutMs || 5000,
+    env: runtimeWorkerEnv(env),
+    workerData: {
+      role: 'wall-e-runtime-worker',
+      ...(options.workerData || {}),
+    },
+    logger: options.logger || console,
+  });
+  return _pool;
+}
+
+async function closeRuntimeWorkerPool(options = {}) {
+  if (!_pool) return { ok: true, alreadyClosed: true };
+  const pool = _pool;
+  _pool = null;
+  return pool.close(options);
+}
+
+function getRuntimeWorkerPoolStatus() {
+  if (!_pool) return { enabled: runtimeWorkerPoolEnabled(), started: false };
+  return { enabled: true, started: true, ..._pool.getStatus() };
+}
+
+async function requestRuntimeWorker(op, payload = {}, options = {}) {
+  const pool = getRuntimeWorkerPool(options);
+  if (!pool) throw new Error('Wall-E runtime worker pool is disabled');
+  return pool.request(op, payload, options);
+}
+
+async function broadcastRuntimeWorker(op, payload = {}, options = {}) {
+  const pool = getRuntimeWorkerPool(options);
+  if (!pool) return [];
+  return pool.broadcast(op, payload, options);
+}
+
+module.exports = {
+  getRuntimeWorkerPool,
+  closeRuntimeWorkerPool,
+  getRuntimeWorkerPoolStatus,
+  requestRuntimeWorker,
+  broadcastRuntimeWorker,
+  runtimeWorkerPoolEnabled,
+  runtimeWorkerPoolSize,
+  runtimeWorkerRequestTimeoutMs,
+  runtimeWorkerEnv,
+};

package/template/wall-e/lib/scheduler-worker-jobs.js

@@ -0,0 +1,231 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { performance } = require('node:perf_hooks');
+
+const WALL_E_DIR = path.resolve(__dirname, '..');
+const CONFIG_PATH = path.join(WALL_E_DIR, 'wall-e-config.json');
+const LEARNER_INTERVAL_MS = 3600000;
+
+let _brain = null;
+let _lastLearnerRun = 0;
+let _replayCycle = 0;
+
+function _readConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) return {};
+  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')); }
+  catch { return {}; }
+}
+
+function _ensureBrain() {
+  if (_brain) return _brain;
+  const brain = require('../brain');
+  brain.initDb();
+  _brain = brain;
+  return _brain;
+}
+
+function _buildPollAdapters() {
+  const config = _readConfig();
+  const adapterRegistry = require('../adapters/registry');
+  adapterRegistry.ensureBootstrapped();
+  const adapters = [];
+  const adapterCtorOpts = {
+    ctm: () => ({}),
+    slack: () => ({
+      ownerNames: [config.owner?.name, config.owner?.first_name].filter(Boolean),
+    }),
+  };
+  for (const entry of adapterRegistry.list({ mode: 'poll' })) {
+    if (!adapterRegistry.isPollEnabledByConfig(entry.manifest, config)) continue;
+    const optsFn = adapterRegistry.has(entry.id) && adapterCtorOpts[entry.id];
+    const inst = adapterRegistry.instantiate(entry.id, optsFn ? optsFn() : {});
+    if (inst) adapters.push(inst);
+  }
+  return adapters;
+}
+
+function _phase(phases, name, startedAt, extra = {}) {
+  phases.push({ name, duration_ms: Math.round(performance.now() - startedAt), ...extra });
+}
+
+async function _measurePhase(phases, name, fn) {
+  const startedAt = performance.now();
+  try {
+    const result = await fn();
+    _phase(phases, name, startedAt, { ok: true });
+    return result;
+  } catch (err) {
+    _phase(phases, name, startedAt, { ok: false, error: String(err?.message || err).slice(0, 160) });
+    throw err;
+  }
+}
+
+async function runSchedulerJob(jobName, payload = {}) {
+  const phases = [];
+  const trigger = payload.trigger || 'interval';
+  const modelOverride = payload.modelOverride || null;
+  const brain = _ensureBrain();
+  let result;
+
+  switch (jobName) {
+    case 'ingest': {
+      const adapters = await _measurePhase(phases, 'build_adapters', () => _buildPollAdapters());
+      result = await _measurePhase(phases, 'ingest.runOnce', () => require('../loops/ingest').runOnce(adapters));
+      break;
+    }
+    case 'think':
+      result = await _measurePhase(phases, 'think.runOnce', () => require('../loops/think').runOnce());
+      break;
+    case 'tasks':
+      result = await _measurePhase(phases, 'tasks.runDueTasks', () => require('../loops/tasks').runDueTasks());
+      break;
+    case 'skills':
+      result = await _measurePhase(phases, 'skills.runDueSkills', () => require('../skills/skill-planner').runDueSkills({ modelOverride }));
+      break;
+    case 'training': {
+      const { runBatchEval } = require('../eval/evaluator');
+      const { updateAllModelTaskScores } = require('../eval/aggregator');
+      const { checkPromotions } = require('../eval/promoter');
+      const evalResult = await _measurePhase(phases, 'training.runBatchEval', () => runBatchEval(brain, { limit: 50 }));
+      await _measurePhase(phases, 'training.aggregateScores', () => updateAllModelTaskScores(brain));
+      await _measurePhase(phases, 'training.checkPromotions', () => checkPromotions(brain));
+      if (Date.now() - _lastLearnerRun >= LEARNER_INTERVAL_MS) {
+        await _measurePhase(phases, 'training.updateModelPreferences', () => require('../evaluation/learner').updateModelPreferences(brain));
+        _lastLearnerRun = Date.now();
+      }
+      result = evalResult;
+      break;
+    }
+    case 'replay': {
+      const { runReplay, runMultiTurnReplay } = require('../eval/replay');
+      result = _replayCycle % 2 === 0
+        ? await _measurePhase(phases, 'replay.singleTurn', () => runReplay(brain, { limit: 50 }))
+        : await _measurePhase(phases, 'replay.multiTurn', () => runMultiTurnReplay(brain, { sessionLimit: 5, turnsPerSession: 5 }));
+      _replayCycle++;
+      break;
+    }
+    case 'initiative':
+      result = await _measurePhase(phases, 'initiative.runLoop', () => require('../loops/initiative').runInitiativeLoop({ trigger }));
+      break;
+    case 'reflect':
+      result = await _measurePhase(phases, 'reflect.runOnce', () => require('../loops/reflect').runOnce());
+      break;
+    case 'harvest':
+      result = await _measurePhase(phases, 'harvester.runHarvest', () => require('../eval/harvester').runHarvest({ brain }));
+      break;
+    case 'backfill':
+      result = await _measurePhase(phases, 'backfill.runOnce', () => require('../loops/backfill').runOnce());
+      if (result && result.done) result = { ...result, _done: true };
+      break;
+    case 'brain-optimize':
+      result = await _measurePhase(phases, 'brainOptimize.runOnce', () => require('../loops/brain-optimize').runOnce());
+      break;
+    case 'dedup':
+      result = await _measurePhase(phases, 'dedup.runOnce', () => require('../utils/dedup').runOnce({ threshold: 0.85, limit: 500, dryRun: false }));
+      break;
+    case 'daily-backup':
+      result = await _measurePhase(phases, 'brain.ensureDailyBackup', () => brain.ensureDailyBackup());
+      break;
+    case 'brain-retention':
+      result = await _measurePhase(phases, 'brain.runBrainRetention', () => brain.runBrainRetention());
+      break;
+    case 'question-digest':
+      result = await _measurePhase(phases, 'questionDigest.runDigestJob', () => require('../loops/question-digest').runDigestJob());
+      break;
+    case 'listening:calendar-sync':
+      result = await _measurePhase(phases, 'calendar.syncUpcomingMeetings', () => require('../listening/calendar').syncUpcomingMeetings(2));
+      break;
+    case 'listening:cleanup':
+      result = await _measurePhase(phases, 'recording.cleanupOldRecordings', () => ({ cleaned: require('../listening/storage').cleanupOldRecordings(90) }));
+      break;
+    case 'telemetry:cleanup': {
+      const { runTelemetryCleanup } = require('../api-walle');
+      const live = process.env.WALLE_TELEMETRY_CLEANUP_ENABLED === '1';
+      result = await _measurePhase(phases, 'telemetry.runCleanup', () => runTelemetryCleanup({
+        dryRun: !live,
+        confirm: live ? 'delete' : '',
+        source: 'scheduler',
+      }));
+      break;
+    }
+    case 'agent-benchmark': {
+      const { runAgentBenchmarkSuite, resolveModelName } = require('../eval/agent-runner');
+      const { runAgentLoop } = require('../coding-orchestrator');
+      result = await _measurePhase(phases, 'agentBenchmark.runSuite', () => runAgentBenchmarkSuite({
+        brain,
+        runAgentLoop,
+        model: resolveModelName(),
+        timeoutMs: 120000,
+      }));
+      break;
+    }
+    case 'weekly-eval-loop': {
+      const { run: runWeeklyEval } = require('../eval/weekly-eval-loop');
+      const { runAgentLoop } = require('../coding-orchestrator');
+      result = await _measurePhase(phases, 'weeklyEval.run', () => runWeeklyEval(brain, { runAgentLoop }));
+      break;
+    }
+    case 'deferred:embeddings-init':
+      result = await _measurePhase(phases, 'embeddings.init', () => {
+        require('../embeddings').init();
+        return { ok: true };
+      });
+      break;
+    case 'deferred:temporal-backfill':
+      result = await _measurePhase(phases, 'brain.backfillTemporalValidity', () => ({ rows: brain.backfillTemporalValidity() || 0 }));
+      break;
+    case 'deferred:skill-reference-sync':
+      result = await _measurePhase(phases, 'skillReference.sync', () => {
+        const { syncSkillReferences, checkImportedSkillUpdates } = require('../skills/claude-code-reader');
+        const refResult = syncSkillReferences();
+        const updates = checkImportedSkillUpdates();
+        return { synced: refResult.synced || 0, updates: updates.length || 0 };
+      });
+      break;
+    default: {
+      const err = new Error(`Unsupported scheduler worker job: ${jobName}`);
+      err.code = 'WALL_E_UNSUPPORTED_WORKER_JOB';
+      throw err;
+    }
+  }
+
+  if (result && typeof result === 'object' && !Array.isArray(result)) {
+    return { ...result, _worker_phases: phases };
+  }
+  return { value: result, _worker_phases: phases };
+}
+
+function supportedSchedulerWorkerJobs() {
+  return [
+    'ingest',
+    'think',
+    'tasks',
+    'skills',
+    'training',
+    'replay',
+    'initiative',
+    'reflect',
+    'harvest',
+    'backfill',
+    'brain-optimize',
+    'dedup',
+    'daily-backup',
+    'brain-retention',
+    'question-digest',
+    'listening:calendar-sync',
+    'listening:cleanup',
+    'telemetry:cleanup',
+    'agent-benchmark',
+    'weekly-eval-loop',
+    'deferred:embeddings-init',
+    'deferred:temporal-backfill',
+    'deferred:skill-reference-sync',
+  ];
+}
+
+module.exports = {
+  runSchedulerJob,
+  supportedSchedulerWorkerJobs,
+};