create-walle 0.9.21 → 0.9.23

package/template/wall-e/agent.js

@@ -1,3 +1,22 @@
+process.env.WALL_E_PROCESS_ROLE = process.env.WALL_E_PROCESS_ROLE || 'walle-daemon';
+// Refuse to boot under a Node major that mismatches the pinned one BEFORE brain
+// (and its native better-sqlite3) loads. No-op in shipped installs.
+require('../claude-task-manager/lib/node-pin-guard').assertPinnedNode();
+try {
+  if (process.env.WALL_E_STORAGE_MIGRATION_BYPASS !== '1' && process.env.CTM_STORAGE_MIGRATION_BYPASS !== '1') {
+    const guard = require('../claude-task-manager/lib/storage-migration').startupGuard('Wall-E', process.env);
+    if (!guard.ok) {
+      console.error('[storage-migration] Wall-E startup paused while storage migration is active.');
+      process.exit(75);
+    } else if (guard.stale) {
+      console.warn('[storage-migration] Ignoring stale storage migration lock.');
+    }
+  }
+} catch (e) {
+  console.warn('[storage-migration] Startup guard failed open:', e.message);
+}
+const { processTitle: formatProcessTitle } = require('../claude-task-manager/lib/process-title');
+
 const brain = require('./brain'); // brain.js loads .env from project root
 const ingest = require('./loops/ingest');
 const think = require('./loops/think');
@@ -29,8 +48,8 @@ function _writeCrashLog(label, err) {
     fs.appendFileSync(CRASH_LOG, line);
   } catch {}
 }
-// Process tagging (discoverable via pgrep -f 'walle-dev-4500')
-process.title = `walle-${process.env.WALLE_INSTANCE_TAG || 'primary'}`;
+// Process tagging (discoverable via pgrep -f 'Wall-E dev-4500')
+process.title = formatProcessTitle('walle', process.env.WALLE_INSTANCE_TAG || 'primary');
 
 let _epipeSeen = false; // prevent EPIPE cascade: console.error in handler throws EPIPE → retriggers handler
 process.on('uncaughtException', (err) => {
@@ -262,14 +281,32 @@ async function checkForUpdates() {
 async function main() {
   console.log('[wall-e] Starting WALL-E agent daemon...');
 
+  // Boot profiler — per-phase wall-clock timing so we can SEE where startup time goes
+  // (logged below + surfaced at GET /api/wall-e/boot-profile). brain.initDb() records
+  // its own initDb.* sub-phases into the same profile.
+  const _bootp = require('./lib/boot-profile');
+  const { performance: _perf } = require('perf_hooks');
+  _bootp.reset();
+  let _phaseLast = _perf.now();
+  const _phase = (label) => { const n = _perf.now(); _bootp.mark(label, n - _phaseLast); _phaseLast = n; };
+
   const providerType = (process.env.WALLE_PROVIDER || 'anthropic').toLowerCase();
   console.log(`[wall-e] Provider: ${providerType}, Model: ${process.env.WALLE_MODEL || 'default'}`);
 
   const config = loadOrCreateConfig();
+  _phase('loadConfig');
+
+  // Start the event-loop delay monitor early so a synchronous DB query that wedges the
+  // loop is surfaced in the logs (and on the health endpoint) instead of silently making
+  // the daemon look alive while every HTTP request times out.
+  try { require('./lib/event-loop-monitor').start(); } catch (e) { console.warn('[wall-e] event-loop monitor unavailable:', e.message); }
 
   // Init database (auto-creates data directory if needed)
   brain.initDb();
-  brain.backfillTemporalValidity();
+  _phase('brain.initDb');
+  // backfillTemporalValidity is a ONE-TIME migration (new knowledge rows already set
+  // valid_from on insert). On a large legacy brain it took ~16s on the boot path; it is
+  // deferred off the readiness path below (after startServer) so it never blocks port bind.
 
   // Load API keys from brain DB into env if not already set
   // (setup page stores keys in DB; env var may not be present when spawned by CTM)
@@ -299,19 +336,19 @@ async function main() {
   } else if (providerType === 'google' && !process.env.GOOGLE_API_KEY && !process.env.GEMINI_API_KEY) {
     console.warn('[wall-e] WARNING: GOOGLE_API_KEY not set for Google provider.');
   }
+  _phase('loadApiKeys');
   brain.setDaemonOwned(); // Prevent bundled skills from closing the shared DB connection
-  brain.startDailyBackup();
+  // NOTE: the daily backup is registered as a scheduler job below (name: 'daily-backup'),
+  // NOT run here — it must never block boot / port bind / MCP readiness.
 
-  // Init embedding subsystem (optional, degrades gracefully)
-  try {
-    const embeddings = require('./embeddings');
-    embeddings.init();
-  } catch (e) {
-    console.log('[wall-e] Embeddings not available:', e.message);
-  }
+  // Embedding subsystem init is DEFERRED off the readiness path (see after startServer).
+  // It's optional + degrades gracefully (boot-time memory inserts queue for the backfill
+  // job to embed later), and on the live brain it cost ~15s — which must not block port
+  // bind / MCP readiness.
   bootstrapSkills();
   syncBundledSkills();
   bootstrapTasks();
+  _phase('bootstrap(skills+tasks)');
 
   // Item C (multi-agent deep-dive): ensure the default auth profile exists.
   // Idempotent — safe to call every boot. Existing skills with NULL
@@ -327,17 +364,11 @@ async function main() {
   // Version check (async, non-blocking) — alert if a newer version is on npm
   checkForUpdates().catch(() => {});
 
-  // Sync skill references for Learn+Reference system
-  try {
-    const { syncSkillReferences, checkImportedSkillUpdates } = require('./skills/claude-code-reader');
-    const refResult = syncSkillReferences();
-    if (refResult.synced > 0) console.log(`[wall-e] Synced ${refResult.synced} skill references to brain`);
-    // Check for updates to imported skills
-    const updates = checkImportedSkillUpdates();
-    if (updates.length > 0) console.log(`[wall-e] Imported skill updates: ${updates.map(u => u.name + '(' + u.action + ')').join(', ')}`);
-  } catch (e) {
-    console.warn('[wall-e] Skill reference sync error:', e.message);
-  }
+  // Skill-reference sync (Learn+Reference system) does per-skill filesystem reads + a
+  // skill_reference scan of the memories table — hundreds of ms to seconds on a large
+  // brain. It is NOT needed for the daemon to serve requests, so it runs deferred off the
+  // readiness path (after startServer) rather than blocking port bind. See below.
+  _phase('skillRefSync+authProfile');
 
   // Set owner from config
   if (config.owner) {
@@ -370,6 +401,7 @@ async function main() {
     }
   }
   console.log(`[wall-e] ${adapters.length} adapter(s) active`);
+  _phase('adapters');
 
   // Initialize messaging channels via the plugin registry.
   // Each channel manifest declares its configKey + required config paths;
@@ -426,18 +458,56 @@ async function main() {
   if (channels.length > 0) {
     console.log(`[wall-e] ${channels.length} channel(s) started`);
   }
+  _phase('channels');
 
   // Always start HTTP server — WALL-E API should be independently reachable
   const { startServer } = require('./server');
   let httpServer;
   try {
+    const _serverT0 = _perf.now();
     httpServer = startServer();
     if (httpServer && httpServer.ready) await httpServer.ready;
+    _bootp.mark('startServer(portBind)', _perf.now() - _serverT0);
+    _phaseLast = _perf.now();
+    _bootp.done();
+    console.log(_bootp.summary());
   } catch (e) {
     console.error('[wall-e] HTTP server failed to start:', e.message);
     process.exit(e && e.code === 'EADDRINUSE' ? 98 : 1);
   }
 
+  // Deferred, off the readiness path: heavy/optional init that must not delay port bind +
+  // MCP readiness. Runs a few seconds after the server is up (the readiness probe completes
+  // first). unref'd so it never holds the process. Sub-phase timings are still captured in
+  // the boot profile (the marks append after startServer), so /api/wall-e/boot-profile shows
+  // exactly which embeddings sub-step is slow on the live brain.
+  setTimeout(() => {
+    // 1) Embedding subsystem (optional; degrades gracefully — inserts queue for the backfill job)
+    try {
+      require('./embeddings').init();
+    } catch (e) {
+      console.log('[wall-e] Embeddings not available:', e.message);
+    }
+    // 2) One-time temporal-validity backfill (no-op on an already-migrated brain)
+    try {
+      const n = brain.backfillTemporalValidity();
+      if (n > 0) console.log(`[wall-e] Temporal-validity backfill completed (${n} rows, deferred off boot)`);
+    } catch (err) {
+      console.warn('[wall-e] Deferred temporal-validity backfill failed (non-fatal):', err.message);
+    }
+    // 3) Skill-reference sync — deferred off the readiness path (was on the boot path,
+    //    where its filesystem reads + skill_reference scan delayed HTTP port bind).
+    try {
+      const { syncSkillReferences, checkImportedSkillUpdates } = require('./skills/claude-code-reader');
+      const refResult = syncSkillReferences();
+      if (refResult.synced > 0) console.log(`[wall-e] Synced ${refResult.synced} skill references to brain (deferred off boot)`);
+      const updates = checkImportedSkillUpdates();
+      if (updates.length > 0) console.log(`[wall-e] Imported skill updates: ${updates.map(u => u.name + '(' + u.action + ')').join(', ')}`);
+    } catch (e) {
+      console.warn('[wall-e] Skill reference sync error:', e.message);
+    }
+  }, 2000).unref?.();
+
   // Slack Socket Mode is optional and event-driven. It only starts when an
   // app-level xapp token is configured, so the existing polling path remains
   // unchanged for workspaces that have not registered a Wall-E Slack app.
@@ -456,6 +526,7 @@ async function main() {
     channels: channels.map(c => c.name),
     adapters: adapters.map(a => a.constructor?.name || 'unknown'),
   });
+  try { require('./embeddings').trackEmbeddingStatus('boot'); } catch {}
   telemetry.trackFunnelStep('boot');
 
   // Recover tasks that were interrupted by previous shutdown
@@ -749,6 +820,17 @@ async function main() {
     },
   });
 
+  scheduler.register({
+    name: 'brain-optimize',
+    run: async () => require('./loops/brain-optimize').runOnce(),
+    intervalMs: 3600000,    // hourly; self-gates to a one-shot via kv (brain:optimize:v1)
+    pool: 'io',
+    priority: 4,
+    startDelayMs: 180000,   // 3 min after boot — well past the boot storm
+    timeoutMs: 120000,
+    onError: (err) => console.error('[brain-optimize] Loop error:', err.message),
+  });
+
   scheduler.register({
     name: 'dedup',
     run: async () => {
@@ -765,6 +847,62 @@ async function main() {
     onError: (err) => console.error('[dedup] Error:', err.message),
   });
 
+  // Daily brain backup. Registered as a scheduler job (NOT run at boot) so the heavy
+  // backup never blocks port bind / MCP readiness; the scheduler owns "once a day +
+  // replay if a day was missed during downtime" (persistJobState). ensureDailyBackup()
+  // is idempotent (skips if today's already exists) and createBackup is now non-blocking.
+  scheduler.register({
+    name: 'daily-backup',
+    run: async () => {
+      const r = await brain.ensureDailyBackup();
+      if (r && r.created) console.log(`[wall-e] Daily backup: ${r.backupName}`);
+      return r;
+    },
+    intervalMs: 24 * 60 * 60 * 1000, // daily
+    pool: 'io',
+    priority: 11,
+    startDelayMs: 180000, // 3min after startup — well off the boot/readiness path
+    onError: (err) => {
+      console.error('[wall-e] Daily backup error:', err.message);
+      telemetry.trackError('daily-backup', err);
+    },
+  });
+
+  // Brain retention: prune unbounded tables + orphan embeddings. Hourly check; each prune
+  // is internally age-gated + batched (lock-friendly). See the 2026-05-31 audit.
+  scheduler.register({
+    name: 'brain-retention',
+    run: async () => brain.runBrainRetention(),
+    intervalMs: 60 * 60 * 1000,
+    pool: 'io',
+    priority: 11,
+    startDelayMs: 90000,
+    onResult: (r) => {
+      const nonZero = Object.entries(r || {}).filter(([, v]) => typeof v === 'number' && v > 0);
+      if (nonZero.length) console.log('[wall-e] Retention pruned: ' + nonZero.map(([k, v]) => `${k}=${v}`).join(', '));
+    },
+    onError: (err) => console.error('[brain-retention] Error:', err.message),
+  });
+
+  // Daily question digest: push the day's questions to opt-in channels (Slack/email). The
+  // CTM Wall-E tab always shows pending questions, so it needs no push. runDigestJob is
+  // self-gated to once/day at/after WALL_E_DIGEST_HOUR; we just tick it hourly.
+  scheduler.register({
+    name: 'question-digest',
+    run: async () => {
+      const { runDigestJob } = require('./loops/question-digest');
+      return runDigestJob();
+    },
+    intervalMs: 60 * 60 * 1000,
+    pool: 'io',
+    priority: 11,
+    startDelayMs: 100000,
+    onResult: (r) => {
+      if (r && r.sent) console.log(`[wall-e] Question digest sent (${r.count}): ${JSON.stringify(r.results)}`);
+    },
+    onError: (err) => console.error('[question-digest] Error:', err.message),
+  });
+
   // Listening: Calendar sync (every 5 minutes)
   scheduler.register({
     name: 'listening:calendar-sync',
@@ -1027,6 +1165,12 @@ async function main() {
       telemetry.track('shutdown', { uptime: process.uptime() });
       telemetry.stop();
       try { require('./skills/mcp-client').disconnectAll(); } catch {}
+      try {
+        const drained = await brain.drainOwnerWrites({ timeoutMs: 1500 });
+        if (drained?.timedOut) {
+          console.error(`[wall-e] Timed out waiting for brain write queue; active=${drained.active || 'none'} pending=${drained.pending || 0}`);
+        }
+      } catch {}
       if (httpServer) httpServer.close();
       brain.closeDb(true); // force=true bypasses daemon guard
     } catch (e) {