@cgh567/agent 2.4.3 → 2.4.5

package/daemon/helios-company-daemon.js

@@ -1053,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
@@ -1108,7 +1148,7 @@ class RoutineEvaluator {
               { runId: followUpRunId, routineId, companyId: this.companyId }
             ).catch(e => log('warn', `RoutineEvaluator: coalesce follow-up failed: ${e.message}`));
           }
-          log('debug', `Coalescing routine ${routine['r.name']} — queued follow-up`);
+          log('info', `[RoutineEvaluator] coalescing — prior run still active for routine ${routineId}`);
           continue;
         }
       }
@@ -1120,42 +1160,44 @@ class RoutineEvaluator {
       }
 
       // P5-04: catchUpCap — enqueue missed windows up to cap
-      // This fires BEFORE the normal single-task creation to batch missed runs first.
+      // 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 cron = new Cron(routine['r.cronExpr'], { timezone: routine['r.timezone'] });
-          // Count missed windows: how many times cron fired between lastRunAt and now
-          // Simple approximation: count backward from now until we hit lastRunAt or cap
-          let missedCount = 0;
-          const prev = cron.previousRun ? cron.previousRun() : null;
-          // Since we don't have a full missed-window iterator here, use a conservative
-          // estimate: check if at least one missed window exists and enqueue up to cap
-          // by repeatedly calling previousRun. Max cap iterations.
-          let checkDate = prev;
           const lastRunStr = routine['r.lastRunAt'];
-          const lastRunMs = lastRunStr ? Date.parse(lastRunStr) : 0;
-          while (checkDate && missedCount < catchUpCap) {
-            if (checkDate.getTime() <= lastRunMs) break;
-            missedCount++;
-            checkDate = cron.previousRun ? cron.previousRun() : null;
-          }
-          cron.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_catchup', t.progressPropagated = false, t.createdAt = datetime()`,
-              { taskId: catchUpTaskId, title: `Routine catch-up: ${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 (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']})`);
           }
-          if (missedCount > 0) log('info', `RoutineEvaluator: catch-up ${missedCount} tasks for ${routine['r.name']}`);
         } catch (catchUpErr) {
           log('warn', `RoutineEvaluator: catchUpCap logic failed for ${routineId}: ${catchUpErr.message}`);
         }
@@ -1996,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,
@@ -2004,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),
@@ -2309,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.
@@ -2343,23 +2420,26 @@ 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.
-      // Use ['ignore', 'ignore', 'pipe'] — stdin/stdout ignored, stderr captured.
+      // Use ['ignore', 'pipe', 'pipe'] — stdin ignored, stdout+stderr both captured for crash log.
+      // Previously used ['ignore', 'ignore', 'pipe'] — pi process may write errors to stdout.
       const transcriptsDir = path.join(__dirname, 'transcripts');
       try { fs.mkdirSync(transcriptsDir, { recursive: true }); } catch (_) {}
 
       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'],
+        stdio: ['ignore', 'pipe', 'pipe'],
         env: spawnEnv,
         windowsHide: true,
+        shell: false,
       });
 
-      // Collect stderr chunks for crash log (64KB cap to prevent OOM from chatty workers)
+      // Collect stderr+stdout chunks for crash log (64KB cap per stream to prevent OOM from chatty workers)
       const stderrChunks = [];
       let _stderrBytes = 0;
       const MAX_STDERR_BYTES = 64 * 1024;
@@ -2374,6 +2454,18 @@ class AgentDispatcher {
         // (child.unref() alone is insufficient when a stderr pipe listener is attached)
         child.stderr.unref();
       }
+      // Also capture stdout (pi process may write errors/traces to stdout)
+      const stdoutChunks = [];
+      let _stdoutBytes = 0;
+      if (child.stdout) {
+        child.stdout.on('data', (chunk) => {
+          if (_stdoutBytes < MAX_STDERR_BYTES) {
+            stdoutChunks.push(chunk);
+            _stdoutBytes += chunk.length;
+          }
+        });
+        child.stdout.unref();
+      }
 
       child.on('error', (err) => {
         if (err.code === 'ENOENT') {
@@ -2386,6 +2478,7 @@ class AgentDispatcher {
         // E-07: Write crash log when worker exits with non-zero code
         if (code !== 0) {
           const stderr = stderrChunks.length > 0 ? Buffer.concat(stderrChunks).toString('utf8') : '(no stderr captured)';
+          const stdout = stdoutChunks.length > 0 ? Buffer.concat(stdoutChunks).toString('utf8') : '(no stdout captured)';
           const crashLogPath = path.join(transcriptsDir, `${taskId.replace(/[^a-zA-Z0-9_-]/g, '_')}.crash.log`);
           const crashContent = [
             `=== CRASH LOG: task ${taskId} ===`,
@@ -2398,6 +2491,8 @@ class AgentDispatcher {
             `HELIOS_COMPANY_ID: ${spawnEnv.HELIOS_COMPANY_ID}`,
             `--- stderr ---`,
             stderr,
+            `--- stdout ---`,
+            stdout,
           ].join('\n');
           try {
             fs.writeFileSync(crashLogPath, crashContent, 'utf8');
@@ -2568,8 +2663,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) {
@@ -2679,7 +2774,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 [];
@@ -3153,7 +3248,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) {
@@ -3162,8 +3257,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}`);
         }
@@ -3210,6 +3305,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)
@@ -3228,11 +3345,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) {
@@ -3294,12 +3413,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; }
 
@@ -3358,6 +3478,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
@@ -4100,6 +4222,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()));
@@ -5642,6 +5767,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 };