@cgh567/agent 2.4.2 → 2.4.4

package/daemon/helios-company-daemon.js

@@ -20,12 +20,14 @@ if (!process.env.TZ) { process.env.TZ = 'UTC'; }
  */
 
 const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const { performance } = require('perf_hooks');
-const { randomUUID } = require('crypto');
-const { buildContextBrief } = require('./context-enrichment');
-const hboStore = require('../lib/hbo-core-store');
+const fs = require('fs');
+const os = require('os');
+const { execFile } = require('child_process');
+const { performance } = require('perf_hooks');
+const { randomUUID } = require('crypto');
+const { buildContextBrief } = require('./context-enrichment');
+const hboStore = require('../lib/hbo-core-store');
+const graphWal = require('../lib/graph-wal');
 const { runMigrations } = require('./schema-migrations');
 const { runHBOMigrations } = require('./schema-migrations-hbo');
 const { runHaradaMigrations } = require('./schema-migrations-harada');
@@ -727,7 +729,7 @@ async function executeQueueAction(item) {
       const cid = (item.payload && item.payload.companyId) || 'default';
 
       // SQLite-first write (P2-2)
-      hboStore.createTask({
+      try { hboStore.createTask({
         id: taskId,
         companyId: cid,
         title,
@@ -739,7 +741,7 @@ async function executeQueueAction(item) {
         sourceChannel: item.channel,
         progressPropagated: false,
         createdAt: Date.now(),
-      });
+      }); } catch (_storeErr) { /* non-fatal: SQLite store unavailable */ }
       // Non-blocking Memgraph projection (fire-and-forget)
       setImmediate(() => mg.safeWrite(`
         CREATE (t:Task {
@@ -1051,6 +1053,46 @@ class RoutineEvaluator {
   }
 
   async evaluate() {
+    // HIGH-1 fix: promote any queued_coalesced RoutineRun nodes whose active run has now
+    // completed. This runs BEFORE the due-routines query so promoted runs are visible immediately.
+    try {
+      const coalescedResult = await this.mg(
+        `MATCH (rr:RoutineRun {companyId: $cid, status: 'queued_coalesced'})
+         WHERE NOT EXISTS {
+           MATCH (active:RoutineRun {routineId: rr.routineId, companyId: $cid})
+           WHERE active.status IN ['queued', 'running']
+             AND active.id <> rr.id
+         }
+         RETURN rr.id AS runId, rr.routineId AS routineId`,
+        { cid: this.companyId }
+      );
+      const coalescedRows = coalescedResult?.rows ?? [];
+      for (const row of coalescedRows) {
+        const coalescedRunId = row[0] ?? row['runId'];
+        const coalescedRoutineId = row[1] ?? row['routineId'];
+        if (!coalescedRunId || !coalescedRoutineId) continue;
+        // Fetch routine details to create the task
+        const routineResult = await this.mg(
+          `MATCH (r:Routine {id: $rid, companyId: $cid}) RETURN r.name, r.agentId`,
+          { rid: coalescedRoutineId, cid: this.companyId }
+        );
+        const routineRows = routineResult?.rows ?? [];
+        if (routineRows.length === 0) continue;
+        const routineName = routineRows[0][0] ?? routineRows[0]['r.name'] ?? coalescedRoutineId;
+        const routineAgentId = routineRows[0][1] ?? routineRows[0]['r.agentId'];
+        if (!routineAgentId) continue;
+        const promotedTaskId = `task:routine:${coalescedRoutineId}:coalesced:${randomUUID()}`;
+        await this.mg(
+          `MERGE (t:Task {id: $taskId}) SET t.title = $title, t.status = 'todo', t.assigneeAgentId = $agentId, t.companyId = $companyId, t.originKind = 'routine', t.progressPropagated = false, t.createdAt = datetime()
+           WITH t MATCH (rr:RoutineRun {id: $runId}) SET rr.status = 'queued', rr.linkedTaskId = $taskId`,
+          { taskId: promotedTaskId, title: `Routine: ${routineName}`, agentId: routineAgentId, companyId: this.companyId, runId: coalescedRunId }
+        ).catch(e => log('warn', `RoutineEvaluator: coalesced promotion failed for ${coalescedRoutineId}: ${e.message}`));
+        log('info', `RoutineEvaluator: promoted coalesced run ${coalescedRunId} → Task ${promotedTaskId}`);
+      }
+    } catch (coalescedErr) {
+      log('warn', `RoutineEvaluator: coalesced promotion check failed: ${coalescedErr.message}`);
+    }
+
     let dueRoutines;
     try {
       // SC-26: ISO timestamp format is correct — converts .000Z suffix to +00:00 for
@@ -1058,7 +1100,7 @@ class RoutineEvaluator {
       // milliseconds-and-Z suffix produced by toISOString(). No change needed.
       const now = new Date().toISOString().replace(/\.\d{3}Z$/, '+00:00');
       dueRoutines = await this.mg(
-        `MATCH (r:Routine {companyId: $companyId}) WHERE r.status = 'active' AND r.nextRunAt <= datetime($now) RETURN r.id, r.name, r.cronExpr, r.agentId, r.companyId, r.concurrencyPolicy, r.timezone`,
+        `MATCH (r:Routine {companyId: $companyId}) WHERE r.status = 'active' AND r.nextRunAt <= datetime($now) RETURN r.id, r.name, r.cronExpr, r.agentId, r.companyId, r.concurrencyPolicy, r.timezone, r.catchUpCap, r.catchUpPolicy`,
         { now, companyId: this.companyId }
       );
     } catch (err) {
@@ -1086,11 +1128,81 @@ class RoutineEvaluator {
         }
       }
 
+      // P5-03: coalesce_if_active — skip creating a full run but queue one follow-up RoutineRun
+      if (routine['r.concurrencyPolicy'] === 'coalesce_if_active') {
+        const active = await this.mg(
+          `MATCH (rr:RoutineRun {routineId: $rid}) WHERE rr.status IN ['queued', 'running'] RETURN count(rr) as cnt`,
+          { rid: routineId }
+        );
+        const activeCount = active?.rows?.[0]?.[0] ?? 0;
+        if (activeCount > 0) {
+          // Check if a coalesced follow-up already exists (prevent duplicate queuing)
+          const queuedFollowUp = await this.mg(
+            `MATCH (rr:RoutineRun {routineId: $rid, status: 'queued_coalesced'}) RETURN count(rr) as cnt`,
+            { rid: routineId }
+          );
+          if ((queuedFollowUp?.rows?.[0]?.[0] ?? 0) === 0) {
+            const followUpRunId = requireRunId(`run:${routineId}:coalesced:${randomUUID()}`, 'RoutineEvaluator.coalesce');
+            await this.mg(
+              `MERGE (rr:RoutineRun {id: $runId}) SET rr.routineId = $routineId, rr.status = 'queued_coalesced', rr.companyId = $companyId, rr.queuedAt = datetime()`,
+              { runId: followUpRunId, routineId, companyId: this.companyId }
+            ).catch(e => log('warn', `RoutineEvaluator: coalesce follow-up failed: ${e.message}`));
+          }
+          log('info', `[RoutineEvaluator] coalescing — prior run still active for routine ${routineId}`);
+          continue;
+        }
+      }
+
       const routineAgentId = routine['r.agentId'];
       if (!routineAgentId) {
         log('warn', `RoutineEvaluator: routine ${routineId} has no agentId — skipping task creation`);
         continue;
       }
+
+      // P5-04: catchUpCap — enqueue missed windows up to cap
+      // CRIT-1 fix: previousRun() on a fresh Cron instance always returns null because
+      // _states.previousRun is only set when the callback fires. Use forward iteration
+      // from lastRunAt instead: call nextRun() repeatedly from lastRunAt until we reach now.
+      const catchUpPolicy = routine['r.catchUpPolicy'];
+      const catchUpCap = parseInt(routine['r.catchUpCap'] ?? '0', 10) || 0;
+      if (catchUpPolicy === 'enqueue_missed_with_cap' && catchUpCap > 0) {
+        try {
+          const { Cron } = require('croner');
+          const lastRunStr = routine['r.lastRunAt'];
+          if (lastRunStr) {
+            const lastRunMs = Date.parse(lastRunStr);
+            const nowMs = Date.now();
+            let missedCount = 0;
+            // Walk forward from lastRunAt, counting how many scheduled windows occurred before now
+            let probe = new Cron(routine['r.cronExpr'], { timezone: routine['r.timezone'], startAt: new Date(lastRunMs) });
+            let next = probe.nextRun();
+            probe.stop();
+            while (next && next.getTime() < nowMs && missedCount < catchUpCap) {
+              missedCount++;
+              // Advance probe to count next window after this one
+              probe = new Cron(routine['r.cronExpr'], { timezone: routine['r.timezone'], startAt: next });
+              next = probe.nextRun();
+              probe.stop();
+            }
+            for (let i = 0; i < missedCount; i++) {
+              const catchUpTaskId = `task:routine:${routineId}:catchup:${i}:${randomUUID()}`;
+              const catchUpRunId = requireRunId(`run:${routineId}:catchup:${i}:${randomUUID()}`, 'RoutineEvaluator.catchup');
+              await this.mg(
+                `MERGE (t:Task {id: $taskId}) SET t.title = $title, t.status = 'todo', t.assigneeAgentId = $agentId, t.companyId = $companyId, t.originKind = 'routine', t.progressPropagated = false, t.createdAt = datetime()`,
+                { taskId: catchUpTaskId, title: `Routine: ${routine['r.name']}`, agentId: routineAgentId, companyId: this.companyId }
+              ).catch(e => log('warn', `RoutineEvaluator: catch-up task create failed: ${e.message}`));
+              await this.mg(
+                `MERGE (rr:RoutineRun {id: $runId}) SET rr.routineId = $routineId, rr.status = 'queued', rr.linkedTaskId = $taskId, rr.companyId = $companyId, rr.queuedAt = datetime()`,
+                { runId: catchUpRunId, routineId, taskId: catchUpTaskId, companyId: this.companyId }
+              ).catch(e => log('warn', `RoutineEvaluator: catch-up run create failed: ${e.message}`));
+            }
+            if (missedCount > 0) log('info', `[RoutineEvaluator] enqueue_missed_with_cap: queued ${missedCount} catch-up tasks for routine ${routineId} (${routine['r.name']})`);
+          }
+        } catch (catchUpErr) {
+          log('warn', `RoutineEvaluator: catchUpCap logic failed for ${routineId}: ${catchUpErr.message}`);
+        }
+      }
+
       const taskId = `task:routine:${routineId}:${randomUUID()}`;
       await criticalOp(
         () => this.mg(
@@ -1926,6 +2038,26 @@ class AgentDispatcher {
           log('debug', `[${taskId}] context-brief skipped for adapter path: ${_cbe.message}`);
         }
 
+        // P6-06b: read workspacePath from Task node — desktop sets this after acquiring
+        // a SessionWorktree for isolated execution (workspaceMode='isolated').
+        // Non-fatal: if unavailable, falls back to null (no worktree isolation).
+        // HIGH-2 fix: include companyId in MATCH to enforce multi-tenant isolation
+        // MEDIUM-4 fix: skip the extra Memgraph round-trip for tasks that cannot have a
+        // workspace (only 'workspace' and 'crew' originKinds support isolated worktrees)
+        let _taskWorkspacePath = null;
+        if (originKind === 'workspace' || originKind === 'crew') {
+          try {
+            const _wpResult = await this.mg(
+              `MATCH (t:Task {id: $taskId, companyId: $cid}) RETURN t.workspacePath AS wp`,
+              { taskId, cid: this.companyId }
+            );
+            const _wpRows = _wpResult?.rows ?? [];
+            _taskWorkspacePath = _wpRows[0]?.[0] ?? _wpRows[0]?.['wp'] ?? null;
+          } catch (_wpe) {
+            log('debug', `[${taskId}] workspacePath read skipped: ${_wpe.message}`);
+          }
+        }
+
         const adapterContext = {
           runId: `run:${taskId}:${randomUUID()}`,
           agentId,
@@ -1934,7 +2066,7 @@ class AgentDispatcher {
           instructions: body ? `Execute task: ${title} (ID: ${taskId})\n\n${body}` : `Execute task: ${title} (ID: ${taskId})`,
           skills: [],
           budget: null,
-          workspacePath: null,
+          workspacePath: _taskWorkspacePath,
           envVars: { HELIOS_TASK_ID: taskId, HELIOS_AGENT_ID: agentId },
           onLog: (event) => log('debug', `[${taskId}] ${event.stream}: ${event.chunk}`),
           onMeta: (meta) => log('debug', `[${taskId}] meta: ${meta.type}`, meta.data),
@@ -2239,22 +2371,37 @@ class AgentDispatcher {
       }
 
       // Fallback: direct pi spawn (only when heliosConfig.apiUrl is not set)
+      // Spawns process.execPath (node.exe) + the @cgh567/cli JS entrypoint directly.
+      // This avoids spawning pi.cmd (.cmd shim) which causes Windows to create a
+      // conhost.exe console host, producing the visible terminal window flash.
+      // process.execPath is a native .exe on all platforms — no .cmd wrapper, no conhost.
       if (!heliosConfig?.apiUrl) {
 
       const { spawn } = require('child_process');
       const spawnFn = this._spawnFn ?? spawn;
       const piArgs = ['--skill', skill, '--prompt', `Execute task: ${title} (ID: ${taskId})`];
 
-      // Resolve pi binary: prefer helios-agent local node_modules/.bin/pi to avoid
-      // ENOENT in non-login shells where NVM is not sourced (crash vector confirmed).
-      // On Windows, use pi.cmd wrapper from node_modules/.bin/.
-      // Fallback chain: local node_modules → ~/.local/bin/pi (Unix only) → 'pi' (last resort).
+      // Resolve the actual JS entrypoint of pi from node_modules.
+      // On Windows, pi.cmd is a .cmd shim — spawning it via Node creates a conhost.exe
+      // console host window even with windowsHide:true (CREATE_NO_WINDOW applies to the
+      // spawned process, not the conhost the kernel creates for .cmd files).
+      // Fix: resolve @cgh567/cli/dist/cli.js and spawn via process.execPath (node.exe)
+      // directly. This is cross-platform: process.execPath is the node binary on all OSes.
+      const _piCliJs = path.join(__dirname, '..', 'node_modules', '@cgh567', 'cli', 'dist', 'cli.js');
+      const _piCliExists = fs.existsSync(_piCliJs);
+
+      // Spawn args: if JS entrypoint found, use process.execPath + [cli.js, ...piArgs].
+      // Fallback (cli.js not found): resolve pi binary the old way and pass piArgs directly.
+      // The fallback preserves original behaviour on systems without the expected layout.
       const _piBinName = process.platform === 'win32' ? 'pi.cmd' : 'pi';
-      const localPiBin = path.join(__dirname, '..', 'node_modules', '.bin', _piBinName);
-      const piCmd = fs.existsSync(localPiBin) ? localPiBin
+      const _localPiBin = path.join(__dirname, '..', 'node_modules', '.bin', _piBinName);
+      const _piFallbackCmd = fs.existsSync(_localPiBin) ? _localPiBin
         : (process.platform !== 'win32' && fs.existsSync(`${os.homedir()}/.local/bin/pi`)) ? `${os.homedir()}/.local/bin/pi`
         : 'pi';
 
+      const spawnExe  = _piCliExists ? process.execPath : _piFallbackCmd;
+      const spawnArgs = _piCliExists ? [_piCliJs, ...piArgs] : piArgs;
+
       // E-07: Build complete spawn env — PI_SUBAGENT_DEPTH, PI_AGENT, HELIOS_COMPANY_ID
       // must always be injected so workers know they are subagents and governance
       // gates (H71, STRICT_EDIT_BLOCK) do not block them at startup.
@@ -2273,6 +2420,7 @@ class AgentDispatcher {
         HELIOS_TASK_ID: taskId,
         HELIOS_AGENT_ID: agentId,
         HELIOS_COMPANY_ID: String(this.companyId),
+        HELIOS_HEADLESS: '1', // Enable browser auto-run mode for research agents (safety.ts:55)
       };
 
       // E-07: Capture stderr to crash log so silent failures become visible.
@@ -2282,11 +2430,12 @@ class AgentDispatcher {
 
       log('info', `Dispatching task ${taskId} to agent ${agentId} with skill ${skill}`, { taskId, agentId, skill });
 
-      const child = spawnFn(piCmd, piArgs, {
+      const child = spawnFn(spawnExe, spawnArgs, {
         detached: true,
         stdio: ['ignore', 'ignore', 'pipe'],
         env: spawnEnv,
         windowsHide: true,
+        shell: false,
       });
 
       // Collect stderr chunks for crash log (64KB cap to prevent OOM from chatty workers)
@@ -2498,8 +2647,8 @@ class ActivityLogger {
     for (const event of batch) {
       try {
         await this.mg(
-          `MERGE (ae:ActivityEvent {id: $id}) SET ae.action = $action, ae.actor = $actor, ae.entityId = $entityId, ae.companyId = $companyId, ae.createdAt = datetime(), ae.meta = $meta`,
-          { id: event.id, action: event.action, actor: event.actor ?? 'daemon', entityId: event.entityId ?? '', companyId: event.companyId ?? this._companyId, meta: JSON.stringify(event.meta ?? {}) }
+          `MERGE (ae:ActivityEvent {id: $id}) SET ae.action = $action, ae.actor = $actor, ae.entityId = $entityId, ae.companyId = $companyId, ae.outcome = $outcome, ae.createdAt = datetime(), ae.meta = $meta`,
+          { id: event.id, action: event.action, actor: event.actor ?? 'daemon', entityId: event.entityId ?? '', companyId: event.companyId ?? this._companyId, outcome: event.outcome ?? null, meta: JSON.stringify(event.meta ?? {}) }
         );
         successCount++;
       } catch (e) {
@@ -2609,7 +2758,7 @@ class CostEventSyncer {
     let db;
     try {
       db = new Database(this._dbPath, { readonly: true });
-      db.pragma('busy_timeout = 100'); // 100ms max wait if DB is locked
+      db.pragma('busy_timeout = 5000'); // 5000ms max wait if DB is locked
     } catch (err) {
       log('warn', `CostEventSyncer: failed to open SQLite DB at ${this._dbPath}: ${err.message}`);
       return [];
@@ -3083,7 +3232,7 @@ class ApprovalWatcher {
         approved = await this.mg(
           `MATCH (a:Approval {companyId: $cid, status: 'approved'})
            WHERE a.followUpTaskCreated IS NULL OR a.followUpTaskCreated = false
-           RETURN a.id, a.title, a.requestedBy, a.type, a.strategyId`,
+           RETURN a.id, a.title, a.requestedBy, a.type, a.strategyId, a.sourceTaskId, a.goalId`,
           { cid: this.companyId }
         );
       } catch (mgErr) {
@@ -3092,8 +3241,8 @@ class ApprovalWatcher {
           const storeApprovals = hboStore.getApprovalsByCompanyStatus(this.companyId, 'approved')
             .filter(a => !a.followUpTaskCreated);
           approved = {
-            rows: storeApprovals.map(a => [a.id, a.title, a.requestedBy, a.type, a.strategyId ?? null]),
-            keys: ['a.id', 'a.title', 'a.requestedBy', 'a.type', 'a.strategyId'],
+            rows: storeApprovals.map(a => [a.id, a.title, a.requestedBy, a.type, a.strategyId ?? null, a.sourceTaskId ?? null, a.goalId ?? null]),
+            keys: ['a.id', 'a.title', 'a.requestedBy', 'a.type', 'a.strategyId', 'a.sourceTaskId', 'a.goalId'],
           };
           log('info', `ApprovalWatcher: using SQLite fallback for approval lookup (Memgraph unavailable): ${mgErr.message}`);
         }
@@ -3140,6 +3289,28 @@ class ApprovalWatcher {
             ).catch(e => log('warn', `ApprovalWatcher: strategy approve projection failed: ${e.message}`)));
             log('info', `ApprovalWatcher: strategy ${strategyId} approved`);
           }
+        }
+
+        // T3-05: harada_strategy_review approved → dispatch L2 research task for this pillar
+        if (approvalType === 'harada_strategy_review') {
+          const pillarId = approval['a.sourceTaskId'];
+          const goalId = approval['a.goalId'];
+          const l2AgentId = approval['a.requestedBy'] || requestedBy;
+          if (pillarId && goalId) {
+            setImmediate(() => {
+              try {
+                const { CascadeResearchDispatcher } = require('./lib/harada/cascade-research-dispatcher');
+                const crd = new CascadeResearchDispatcher(this.mg.bind(this), this.companyId);
+                crd.dispatchL2Research(pillarId, goalId, this.companyId, l2AgentId)
+                  .then(() => log('info', `ApprovalWatcher: L2 research dispatched for pillar ${pillarId}`))
+                  .catch(e => log('warn', `ApprovalWatcher: L2 dispatch failed for pillar ${pillarId}: ${e.message}`));
+              } catch (dispErr) {
+                log('warn', `ApprovalWatcher: CascadeResearchDispatcher load failed: ${dispErr.message}`);
+              }
+            });
+          } else {
+            log('warn', `ApprovalWatcher: harada_strategy_review approved but missing pillarId (${pillarId}) or goalId (${goalId})`);
+          }
         }
 
         // SQLite-first task create (P2-5)
@@ -3158,11 +3329,13 @@ class ApprovalWatcher {
           { taskId, title: `Approval resolved: ${title}. Execute the approved plan.`, agentId: requestedBy, cid: this.companyId, approvalId }
         ).catch(e => log('warn', `[daemon] Memgraph Task projection failed (non-fatal): ${e.message}`)));
         // SQLite-first approval update (P2-5)
-        try { hboStore.updateApproval(approvalId, this.companyId, { followUpTaskCreated: true }); } catch (_) {}
+        // P8D-01: also write followUpTaskId so "View Task →" link in ApprovalCard works
+        try { hboStore.updateApproval(approvalId, this.companyId, { followUpTaskCreated: true, followUpTaskId: taskId }); } catch (_) {}
         // Non-blocking Memgraph projection (fire-and-forget)
+        // P8D-01: SET followUpTaskId so GET /api/approvals returns it for navigation
         setImmediate(() => this.mg(
-          `MATCH (a:Approval {id: $approvalId}) SET a.followUpTaskCreated = true`,
-          { approvalId }
+          `MATCH (a:Approval {id: $approvalId}) SET a.followUpTaskCreated = true, a.followUpTaskId = $taskId`,
+          { approvalId, taskId }
         ).catch(e => log('warn', `[daemon] Memgraph Approval projection failed (non-fatal): ${e.message}`)));
         log('info', `ApprovalWatcher: created follow-up task ${taskId} for approval ${approvalId}`);
       } catch (err) {
@@ -3224,12 +3397,13 @@ function buildForCompany(companyId, mgQueryAsync, opts) {
   try { mods.taskCompletionWatchdog = new TaskCompletionWatchdog(mgQueryAsync, cid, _daemonConfig.taskTimeoutMs ?? 1800000); }
   catch (e) { log('warn', `[module-factory] TaskCompletionWatchdog init failed for ${cid}: ${e.message}`); mods.taskCompletionWatchdog = null; }
 
-  try { mods.runCompletionPoller = new RunCompletionPoller(mgQueryAsync, cid, typeof broadcast === 'function' ? (...args) => broadcast(...args) : null, new TaskCompletionProcessor({ mgQuery: mgQueryAsync })); }
-  catch (e) { log('warn', `[module-factory] RunCompletionPoller init failed for ${cid}: ${e.message}`); mods.runCompletionPoller = null; }
-
   try { mods.activityLogger = new ActivityLogger(mgQueryAsync, cid); }
   catch (e) { log('warn', `[module-factory] ActivityLogger init failed for ${cid}: ${e.message}`); mods.activityLogger = null; }
 
+  // H-01: activityLogger injected so TaskCompletionProcessor can record task.complete events
+  try { mods.runCompletionPoller = new RunCompletionPoller(mgQueryAsync, cid, typeof broadcast === 'function' ? (...args) => broadcast(...args) : null, new TaskCompletionProcessor({ mgQuery: mgQueryAsync, activityLogger: mods.activityLogger })); }
+  catch (e) { log('warn', `[module-factory] RunCompletionPoller init failed for ${cid}: ${e.message}`); mods.runCompletionPoller = null; }
+
   try { mods.approvalWatcher = new ApprovalWatcher(mgQueryAsync, cid); }
   catch (e) { log('warn', `[module-factory] ApprovalWatcher init failed for ${cid}: ${e.message}`); mods.approvalWatcher = null; }
 
@@ -3288,6 +3462,8 @@ function buildForCompany(companyId, mgQueryAsync, opts) {
   mods.cascadeReviewTrigger   = safeNew('CascadeReviewTrigger',   './lib/harada/cascade-review',     'CascadeReviewTrigger',   mgQueryAsync, cid);
   mods.beliefCeilingAssessment = safeNew('BeliefCeilingAssessment', './lib/harada/belief-ceiling',   'BeliefCeilingAssessment', mgQueryAsync, cid);
   mods.sacrificeDeclaration   = safeNew('SacrificeDeclaration',   './lib/harada/sacrifice-declaration', 'SacrificeDeclaration', mgQueryAsync, cid);
+  // T3-04: CascadeJudge auto-reviews L2/L3 submissions — called every 5 ticks
+  mods.cascadeJudge           = safeNew('CascadeJudge',            './lib/harada/cascade-judge',         'CascadeJudge',         mgQueryAsync, cid);
 
   try {
     // MirrorPatternScan runs on a P7D (weekly) wall-clock schedule via WallClockScheduler
@@ -4030,6 +4206,9 @@ class HeliosCompanyDaemon {
     if (this._tickCount % 5 === 1) {
       await this._runModule('hbo_goal_decompose', () => this._forAllCompanies((cid, m) => m.hboBridge?.tickGoalDecompose()));
       await this._runModule('hbo_goal_sync', () => this._forAllCompanies((cid, m) => m.hboBridge?.tickGoalSync()));
+      // T3-04: Auto-review L2/L3 submissions every 5 ticks
+      await this._runModule('CascadeJudgeL2', () => this._forAllCompanies((cid, m) => m.cascadeJudge?.judgeReadyPillars()));
+      await this._runModule('CascadeJudgeL3', () => this._forAllCompanies((cid, m) => m.cascadeJudge?.judgeReadyActionCells()));
       await this._runModule('PDSACompletion', () => this._forAllCompanies((cid, m) => m.pdsaCompletion?.process()));
       await this._runModule('ProgressPropagation', () => this._forAllCompanies((cid, m) => m.progressPropagation?.propagate()));
       await this._runModule('CatchballProcessing', () => this._forAllCompanies((cid, m) => m.catchballProcessing?.process()));
@@ -4330,10 +4509,30 @@ class HeliosCompanyDaemon {
     // CRITICAL-3 fix: wait for Memgraph to be reachable before running migrations.
     // Without this, PM2 can restart the daemon before Memgraph is up post-OOM,
     // and all migrations + MAGE backfill silently fail, leaving the graph in a partial state.
-    await this._waitForMemgraph();
-    await this._connectMemgraph();
-
-    // ── TZ sanity check ─────────────────────────────────────────────────────────
+    await this._waitForMemgraph();
+    await this._connectMemgraph();
+
+    try {
+      const replay = await graphWal.replayPending(this._mgQueryAsync.bind(this));
+      log('info', 'WAL replay complete', replay);
+    } catch (err) {
+      log('error', 'WAL replay failed', { error: err.message });
+    }
+
+    const migrateScript = path.join(DAEMON_DIR, 'db', 'hbo-core-migrate.js');
+    execFile(process.execPath, ['--experimental-sqlite', migrateScript], {
+      cwd: HELIOS_ROOT,
+      timeout: 60_000,
+      env: process.env,
+    }, (err, stdout, stderr) => {
+      if (err) {
+        log('warn', 'hbo-core reconcile failed', { error: err.message, stderr: String(stderr || '').slice(0, 1000) });
+        return;
+      }
+      log('info', 'hbo-core reconcile complete', { stdout: String(stdout || '').slice(0, 1000) });
+    });
+
+    // ── TZ sanity check ─────────────────────────────────────────────────────────
     if (!process.env.TZ || process.env.TZ !== 'UTC') {
       log('warn', `[startup] TZ=${process.env.TZ} — recommend TZ=UTC for consistent datetime comparisons. See AGENTS.md.`);
     }
@@ -5552,6 +5751,7 @@ if (require.main === module) {
         getAgents: () => daemon._agents || [],
         getDaemonHealth: () => ({ pid: process.pid, uptime: process.uptime(), tickCount: daemon._tickCount }),
         daemon,
+        activityLogger: daemon._activityLogger ?? null, // H-01: approval event recording in helios-api.js approve/reject handlers
         broadcast, // Phase 4/5: required for project SSE events (project:understanding:ready etc.)
         companies: _allCompanyConfigs.map(cfg => ({
           id: cfg.company?.id || cfg.companyName || 'unknown',

package/daemon/lib/blast-radius-analyzer.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const execFileAsync = promisify(execFile);
+
+/**
+ * BlastRadiusAnalyzer — measures the impact of a HED operation's execution.
+ * Compares declared target vs actual changes (git diff + Memgraph diff).
+ */
+
+class BlastRadiusAnalyzer {
+  constructor(mg, repoPath) {
+    this._mg = mg;
+    this._repoPath = repoPath || process.cwd();
+  }
+
+  async analyze(opId, operation, executionLockedAt, completedAt) {
+    const [filesChanged, nodesAffected] = await Promise.allSettled([
+      this._getChangedFiles(operation.target),
+      this._getChangedNodes(executionLockedAt, completedAt)
+    ]);
+
+    const changedFiles = filesChanged.status === 'fulfilled' ? filesChanged.value : [];
+    const changedNodes = nodesAffected.status === 'fulfilled' ? nodesAffected.value : [];
+
+    const outsideTarget = changedFiles.filter(f => !f.includes(operation.target || ''));
+    const severity = this._computeSeverity(outsideTarget, changedNodes);
+
+    return {
+      filesChanged: outsideTarget,
+      allFilesChanged: changedFiles,
+      nodesAffected: changedNodes,
+      severity,
+      opId
+    };
+  }
+
+  async _getChangedFiles(declaredTarget) {
+    try {
+      const { stdout } = await execFileAsync('git', ['diff', '--name-only', 'HEAD~1'], {
+        cwd: this._repoPath,
+        windowsHide: true
+      });
+      return stdout.trim().split('\n').filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+
+  async _getChangedNodes(executionLockedAt, completedAt) {
+    if (!executionLockedAt || !completedAt) return [];
+    try {
+      const rows = await this._mg(
+        `MATCH (n) WHERE n.updatedAt >= $from AND n.updatedAt <= $to
+         RETURN DISTINCT labels(n)[0] AS label, count(n) AS count LIMIT 20`,
+        { from: executionLockedAt, to: completedAt }
+      );
+      return (rows || []).map(r => `${r.label}(${r.count})`);
+    } catch {
+      return [];
+    }
+  }
+
+  _computeSeverity(outsideFiles, changedNodes) {
+    const score = outsideFiles.length * 2 + changedNodes.length;
+    if (score === 0) return 'none';
+    if (score <= 2) return 'low';
+    if (score <= 6) return 'medium';
+    if (score <= 12) return 'high';
+    return 'critical';
+  }
+}
+
+module.exports = { BlastRadiusAnalyzer };