@cgh567/agent 2.4.1 → 2.4.2

package/daemon/helios-company-daemon.js

@@ -25,6 +25,7 @@ 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 { runMigrations } = require('./schema-migrations');
 const { runHBOMigrations } = require('./schema-migrations-hbo');
 const { runHaradaMigrations } = require('./schema-migrations-harada');
@@ -179,6 +180,14 @@ try {
       process.stderr.write('[daemon] Generated API token at ' + tokenPath + '\n');
     }
     process.env.HELIOS_API_TOKEN = fs.readFileSync(tokenPath, 'utf-8').trim();
+    // Mirror token to data/api-token.txt so harbor tests can find it without
+    // knowing the platform-specific HELIOS_DATA path.
+    // Primary path: harbor test fixture reads HELIOS_ROOT/data/api-token.txt → sends Bearer token.
+    try {
+      const _repoTokenDir = path.join(HELIOS_ROOT, 'data');
+      if (!fs.existsSync(_repoTokenDir)) fs.mkdirSync(_repoTokenDir, { recursive: true });
+      fs.writeFileSync(path.join(_repoTokenDir, 'api-token.txt'), process.env.HELIOS_API_TOKEN, { mode: 0o600 });
+    } catch (_) { /* non-fatal: env var HELIOS_AGENT_TOKEN is the fallback */ }
   } catch(e) {
     process.stderr.write('[daemon] Warning: could not create/read API token: ' + e.message + '\n');
     // Fallback: generate in-memory token (not persisted)
@@ -717,7 +726,22 @@ async function executeQueueAction(item) {
       const assignee = (item.payload && item.payload.assigneeAgentId) || 'agent:default';
       const cid = (item.payload && item.payload.companyId) || 'default';
 
-      await mg.safeWrite(`
+      // SQLite-first write (P2-2)
+      hboStore.createTask({
+        id: taskId,
+        companyId: cid,
+        title,
+        status: 'todo',
+        priority: 2,
+        assigneeAgentId: assignee,
+        body: (item.payload && item.payload.body) || '',
+        sourceItemId: item.target_id,
+        sourceChannel: item.channel,
+        progressPropagated: false,
+        createdAt: Date.now(),
+      });
+      // Non-blocking Memgraph projection (fire-and-forget)
+      setImmediate(() => mg.safeWrite(`
         CREATE (t:Task {
           id: $taskId,
           companyId: $cid,
@@ -739,7 +763,7 @@ async function executeQueueAction(item) {
         body: (item.payload && item.payload.body) || '',
         sourceId: item.target_id,
         channel: item.channel,
-      });
+      }).catch(e => console.warn('[daemon] Memgraph Task projection failed (non-fatal):', e.message)));
       return;
     }
 
@@ -1223,12 +1247,26 @@ class BudgetEnforcer {
 
     let inProgress;
     try {
-      // Retry up to 5 times (500ms apart) in case Memgraph snapshot isolation
-      // hasn't propagated a recently-committed write yet.
-      for (let attempt = 0; attempt < 5; attempt++) {
-        inProgress = await this.mg(query, params);
-        if (inProgress?.rows?.length > 0) break;
-        if (attempt < 4) await new Promise(r => setTimeout(r, 500));
+      // Memgraph primary — SQLite fallback on unavailability
+      try {
+        // Retry up to 5 times (500ms apart) in case Memgraph snapshot isolation
+        // hasn't propagated a recently-committed write yet.
+        for (let attempt = 0; attempt < 5; attempt++) {
+          inProgress = await this.mg(query, params);
+          if (inProgress?.rows?.length > 0) break;
+          if (attempt < 4) await new Promise(r => setTimeout(r, 500));
+        }
+      } catch (mgErr) {
+        // Memgraph unavailable — fall back to SQLite
+        if (hboStore.getTasksByCompanyStatus) {
+          const storeRows = hboStore.getTasksByCompanyStatus(this.companyId, 'in_progress');
+          const filtered = agentId ? storeRows.filter(t => t.assigneeAgentId === agentId) : storeRows;
+          inProgress = {
+            rows: filtered.map(t => [t.id, t.heliosRunId ?? null, t.dispatchedViaTUI ?? null, t.assigneeAgentId ?? null]),
+            keys: ['t.id', 't.heliosRunId', 't.dispatchedViaTUI', 't.assigneeAgentId'],
+          };
+          log('info', `CancelInFlight: using SQLite fallback for in-progress task lookup (Memgraph unavailable): ${mgErr.message}`);
+        }
       }
     } catch (e) {
       log('error', `BudgetEnforcer: failed to query in-flight tasks: ${e.message}`);
@@ -1260,10 +1298,13 @@ class BudgetEnforcer {
           log('error', `BudgetEnforcer: failed to cancel TUI run ${heliosRunId} for task ${taskId} after 3 retries (H3 watchdog will clean up)`);
         }
       }
-      await this.mg(
+      // SQLite-first update (P2-4)
+      try { hboStore.updateTask(taskRow[0], this.companyId, { status: 'todo', executionLockedAt: null, executionAgentId: null, dispatchedViaTUI: null, heliosRunId: null }); } catch (_) {}
+      // Non-blocking Memgraph projection (fire-and-forget)
+      setImmediate(() => this.mg(
         `MATCH (t:Task {id: $taskId}) SET t.status = 'todo', t.executionLockedAt = null, t.executionAgentId = null, t.dispatchedViaTUI = null, t.heliosRunId = null`,
         { taskId: taskRow[0] }
-      ).catch(e => log('error', `BudgetEnforcer: failed to reset task ${taskRow[0]} after cancellation: ${e.message}`));
+      ).catch(e => log('error', `BudgetEnforcer: failed to reset task ${taskRow[0]} after cancellation: ${e.message}`)));
     });
 
     await Promise.race([
@@ -1273,14 +1314,30 @@ class BudgetEnforcer {
   }
 
   async enforce() {
-    // Query 1: Get all policies (instant — small node count)
-    const policiesResult = await this.mg(
-      `MATCH (bp:BudgetPolicy {companyId: $cid})
-       RETURN bp.id, bp.scope, bp.agentId, bp.limitCents, bp.warnPercent, bp.hardStopEnabled`,
-      { cid: this.companyId }
-    );
-
-    const policyRows = policiesResult?.rows ?? [];
+    // Query 1: Get all policies — Memgraph primary, SQLite fallback on unavailability
+    let policyRows = [];
+    try {
+      const policiesResult = await this.mg(
+        `MATCH (bp:BudgetPolicy {companyId: $cid})
+         RETURN bp.id, bp.scope, bp.agentId, bp.limitCents, bp.warnPercent, bp.hardStopEnabled`,
+        { cid: this.companyId }
+      );
+      policyRows = policiesResult?.rows ?? [];
+    } catch (mgErr) {
+      // Memgraph unavailable — fall back to SQLite budget policies
+      if (hboStore.getBudgetPoliciesByCompany) {
+        const storePolicies = hboStore.getBudgetPoliciesByCompany(this.companyId);
+        policyRows = storePolicies.map(bp => [
+          bp.id,
+          bp.scope,
+          bp.agent_id ?? bp.agentId,
+          bp.limit_cents ?? bp.limitCents,
+          bp.warn_percent ?? bp.warnPercent,
+          bp.hard_stop_enabled ?? bp.hardStopEnabled,
+        ]);
+        log('info', `BudgetEnforcer: using SQLite fallback for policy lookup (Memgraph unavailable): ${mgErr.message}`);
+      }
+    }
 
     let blocked = false;
     let warningActive = false;
@@ -1309,12 +1366,21 @@ class BudgetEnforcer {
     const end = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1)).toISOString();
 
     // Query 2: Spend per agent THIS MONTH (fast — time-bounded, indexed)
-    const spendRows = await this.mg(
-      `MATCH (ce:CostEvent {companyId: $cid})
-       WHERE ce.createdAt >= datetime($start) AND ce.createdAt < datetime($end)
-       RETURN ce.agentId, sum(ce.costCents) as total`,
-      { cid: this.companyId, start: start.replace(/\.\d{3}Z$/, '+00:00'), end: end.replace(/\.\d{3}Z$/, '+00:00') }
-    );
+    // Memgraph primary — SQLite has no CostEvent fallback so default to empty spend on unavailability
+    let spendRows = { rows: [] };
+    try {
+      spendRows = await this.mg(
+        `MATCH (ce:CostEvent {companyId: $cid})
+         WHERE ce.createdAt >= datetime($start) AND ce.createdAt < datetime($end)
+         RETURN ce.agentId, sum(ce.costCents) as total`,
+        { cid: this.companyId, start: start.replace(/\.\d{3}Z$/, '+00:00'), end: end.replace(/\.\d{3}Z$/, '+00:00') }
+      );
+    } catch (mgSpendErr) {
+      log('info', `BudgetEnforcer: Memgraph unavailable for spend query — using zero spend (${mgSpendErr.message})`);
+      // spendRows stays { rows: [] } — enforcement proceeds with zero observed spend,
+      // which means soft/hard thresholds will not trigger. This is the safe fallback:
+      // better to not block agents than to falsely block them on a stale DB state.
+    }
 
     // JS join (microseconds — no cartesian product)
     const neo4j = require('neo4j-driver');
@@ -1334,29 +1400,39 @@ class BudgetEnforcer {
       const pct = limit > 0 ? (spent * 100 / limit) : 0;
       const warnThreshold = toNum(warnPercent) || 80;
 
-      // Update policy in Memgraph
-      await this.mg(
+      // Update policy spend in Memgraph — fire-and-forget so Memgraph downtime
+      // does not abort the loop. SQLite hbo-core-store is the authoritative store.
+      setImmediate(() => this.mg(
         `MATCH (bp:BudgetPolicy {id: $id}) SET bp.spentCents = $spent, bp.percentUsed = $pct`,
         { id, spent, pct }
-      );
+      ).catch(e => log('info', `BudgetEnforcer: spend update projection failed (non-fatal): ${e.message}`)));
 
       policies.push({ id, scope, agentId, limitCents: limit, spentCents: spent, percentUsed: pct, status: 'active' });
 
       // Soft incident at warnPercent (idempotent)
       if (pct >= warnThreshold && pct < 100) {
         warningActive = true;
-        const existing = await this.mg(
-          `MATCH (bi:BudgetIncident {policyId: $pid, companyId: $cid, thresholdType: 'soft', status: 'open'}) RETURN bi.id LIMIT 1`,
-          { pid: id, cid: this.companyId }
-        );
-        if (!existing?.rows?.length) {
-          const incidentId = `bi:soft:${id}:${Date.now()}`;
-          await this.mg(
-            `CREATE (bi:BudgetIncident {id: $id, companyId: $cid, policyId: $pid, scopeType: $scopeType, scopeId: $scopeId, thresholdType: 'soft', amountLimit: $limit, amountObserved: $spent, status: 'open', createdAt: datetime()})`,
-            { id: incidentId, cid: this.companyId, pid: id, scopeType: scope, scopeId: agentId ?? scope, limit, spent }
-          );
-          log('info', `BudgetEnforcer: Soft budget incident created for ${agentId ?? 'global'}`, { pct, warnThreshold });
-        }
+        // Use fire-and-forget for incident creation so Memgraph downtime does not abort enforce()
+        const _mgThis = this.mg.bind(this);
+        const _cid = this.companyId;
+        setImmediate(async () => {
+          try {
+            const existing = await _mgThis(
+              `MATCH (bi:BudgetIncident {policyId: $pid, companyId: $cid, thresholdType: 'soft', status: 'open'}) RETURN bi.id LIMIT 1`,
+              { pid: id, cid: _cid }
+            );
+            if (!existing?.rows?.length) {
+              const incidentId = `bi:soft:${id}:${Date.now()}`;
+              await _mgThis(
+                `CREATE (bi:BudgetIncident {id: $id, companyId: $cid, policyId: $pid, scopeType: $scopeType, scopeId: $scopeId, thresholdType: 'soft', amountLimit: $limit, amountObserved: $spent, status: 'open', createdAt: datetime()})`,
+                { id: incidentId, cid: _cid, pid: id, scopeType: scope, scopeId: agentId ?? scope, limit, spent }
+              );
+              log('info', `BudgetEnforcer: Soft budget incident created for ${agentId ?? 'global'}`, { pct, warnThreshold });
+            }
+          } catch (e) {
+            log('info', `BudgetEnforcer: soft incident projection failed (non-fatal): ${e.message}`);
+          }
+        });
         if (scope === 'global') {
           log('info', `BudgetEnforcer: Global budget warning active (>${warnThreshold}%)`, { percentUsed: pct });
         }
@@ -1368,18 +1444,31 @@ class BudgetEnforcer {
         const existingHard = await this.mg(
           `MATCH (bi:BudgetIncident {policyId: $pid, companyId: $cid, thresholdType: 'hard', status: 'open'}) RETURN bi.id LIMIT 1`,
           { pid: id, cid: this.companyId }
-        );
+        ).catch(() => ({ rows: [] }));  // treat Memgraph unavailability as "no existing incident"
         if (!existingHard?.rows?.length) {
           const incidentId = `bi:hard:${id}:${Date.now()}`;
           const approvalId = `approval:budget:${id}:${Date.now()}`;
-          await this.mg(
+          // SQLite-first: write Approval to SQLite before Memgraph so if Memgraph
+          // is down the approval still exists and budget enforcement still functions (F7).
+          try {
+            hboStore.createApproval({
+              id: approvalId, companyId: this.companyId, type: 'budget_exceeded',
+              title: `Budget exceeded for ${agentId ?? 'global'} — raise limit to resume`,
+              requestedBy: agentId ?? 'agent:ceo', status: 'pending', followUpTaskCreated: false, createdAt: Date.now(),
+            });
+          } catch (storeErr) {
+            log('warn', `BudgetEnforcer: SQLite approval write failed (non-fatal): ${storeErr.message}`);
+          }
+          // Memgraph projections — fire-and-forget so Memgraph downtime does not crash enforce()
+          const _mgThis = this.mg.bind(this);
+          setImmediate(() => _mgThis(
             `CREATE (bi:BudgetIncident {id: $incId, companyId: $cid, policyId: $pid, scopeType: $scopeType, scopeId: $scopeId, thresholdType: 'hard', amountLimit: $limit, amountObserved: $spent, status: 'open', approvalId: $apId, createdAt: datetime()})`,
             { incId: incidentId, cid: this.companyId, pid: id, scopeType: scope, scopeId: agentId ?? scope, limit, spent, apId: approvalId }
-          );
-          await this.mg(
+          ).catch(e => log('warn', `BudgetEnforcer: BudgetIncident Memgraph projection failed: ${e.message}`)));
+          setImmediate(() => _mgThis(
             `CREATE (a:Approval {id: $id, companyId: $cid, type: 'budget_exceeded', title: $title, requestedBy: $agentId, status: 'pending', followUpTaskCreated: false, createdAt: datetime()})`,
             { id: approvalId, cid: this.companyId, title: `Budget exceeded for ${agentId ?? 'global'} — raise limit to resume`, agentId: agentId ?? 'agent:ceo' }
-          );
+          ).catch(e => log('warn', `BudgetEnforcer: Approval Memgraph projection failed: ${e.message}`)));
           // Day 5: Emit BUDGET_EXCEEDED P0 AnomalySignal.
           // OPTIONAL MATCH dedup guard — Tournament winner: Candidate C.
           // P0 because a hard budget stop halts all agent work immediately.
@@ -1463,12 +1552,15 @@ class AgentDispatcher {
    * @param {Function} spawnFn     - optional spawn override (for testing)
    * @param {object}   _testConfig - optional config override (for testing only, replaces _daemonConfig)
    * @param {object}   registry    - optional AdapterRegistry instance
+   * @param {Function} broadcastFn - optional closure for SSE broadcast; use (...args) => daemon._broadcast?.(...args)
+   *                                 so the live broadcast reference is resolved at call time, not construction time.
    */
-  constructor(mgQuery, companyId, spawnFn = null, _testConfig = null, registry = null) {
+  constructor(mgQuery, companyId, spawnFn = null, _testConfig = null, registry = null, broadcastFn = null) {
     if (!companyId) throw new Error('AgentDispatcher: companyId required');
     this.mg = mgQuery;
     this.companyId = companyId;
     this._spawnFn = spawnFn;
+    this._daemonBroadcast = typeof broadcastFn === 'function' ? broadcastFn : null;
     this._config = _testConfig !== null ? _testConfig : _daemonConfig;
     // M-11: Use per-company config agents, not the module-level first-company alias
     const _perCompanyCfg = _allCompanyConfigs.find(c =>
@@ -1488,13 +1580,18 @@ class AgentDispatcher {
     const agentHelios = heliosConfig.agents?.[agentId] ?? {};
     if (!agentHelios.apiKey) return null;
 
-    // Check if issue already exists on task node
+    // Check if issue already exists on task node — SQLite-first (P2-4)
     try {
-      const existing = await this.mg(
-        `MATCH (t:Task {id: $taskId}) WHERE t.heliosIssueId IS NOT NULL RETURN t.heliosIssueId`,
-        { taskId }
-      );
-      if (existing?.rows?.length) return existing.rows[0][0];
+      const _storeTask = hboStore.getTask ? hboStore.getTask(taskId, this.companyId) : null;
+      if (_storeTask && _storeTask.heliosIssueId) return _storeTask.heliosIssueId;
+      if (!_storeTask) {
+        // Fallback to Memgraph
+        const existing = await this.mg(
+          `MATCH (t:Task {id: $taskId}) WHERE t.heliosIssueId IS NOT NULL RETURN t.heliosIssueId`,
+          { taskId }
+        );
+        if (existing?.rows?.length) return existing.rows[0][0];
+      }
     } catch (e) { /* ignore */ }
 
     // Create new issue in Helios TUI
@@ -1511,11 +1608,13 @@ class AgentDispatcher {
       if (!resp.ok) return null;
       const issue = await resp.json();
       const issueId = issue.id;
-      // Store on task node
-      await this.mg(
+      // SQLite-first update (P2-4)
+      try { hboStore.updateTask(taskId, this.companyId, { heliosIssueId: issueId }); } catch (_) {}
+      // Non-blocking Memgraph projection (fire-and-forget)
+      setImmediate(() => this.mg(
         `MATCH (t:Task {id: $taskId}) SET t.heliosIssueId = $issueId`,
         { taskId, issueId }
-      ).catch(e => log('warn', `Failed to store heliosIssueId on task ${taskId}: ${e.message}`));
+      ).catch(e => log('warn', `Failed to store heliosIssueId on task ${taskId}: ${e.message}`)));
       return issueId;
     } catch (e) {
       log('warn', `_ensureHeliosIssue failed for task ${taskId}: ${e.message}`);
@@ -1647,28 +1746,55 @@ class AgentDispatcher {
       const signalId = sigRow[0] ?? sigRow['signalId'];
       const agentId  = sigRow[1] ?? sigRow['agentId'];
       let taskResult;
+      // Hoist taskRow before try so it remains in scope at the outer if (!taskRow) check (T20-B)
+      let taskRow = null;
       try {
-        // CONFLICT 004: CEO inbox priority — P0 first, then P1, then OKRFeedback-origin, then by priority/createdAt
-        taskResult = await this.mg(
-          `MATCH (t:Task {status: 'todo', companyId: $companyId, assigneeAgentId: $agentId})
-           WHERE t.title IS NOT NULL
-           WITH t,
-                CASE
-                  WHEN toInteger(coalesce(t.priority, 3)) = 0 THEN 0
-                  WHEN toInteger(coalesce(t.priority, 3)) = 1 THEN 1
-                  WHEN t.originKind = 'okr_feedback' THEN 2
-                  ELSE toInteger(coalesce(t.priority, 3)) + 2
-                END AS sortPriority
-           RETURN t.id AS taskId, t.title AS title, t.originKind AS originKind, t.body AS body, t.priority AS priority
-           ORDER BY sortPriority ASC, t.createdAt ASC
-           LIMIT 1`,
-          { companyId: this.companyId, agentId }
-        );
+        // Memgraph primary — SQLite is the fallback when Memgraph throws (e.g. unavailable)
+        try {
+          // CONFLICT 004: CEO inbox priority — P0 first, then P1, then OKRFeedback-origin, then by priority/createdAt
+          taskResult = await this.mg(
+            `MATCH (t:Task {status: 'todo', companyId: $companyId, assigneeAgentId: $agentId})
+             WHERE t.title IS NOT NULL
+             WITH t,
+                  CASE
+                    WHEN toInteger(coalesce(t.priority, 3)) = 0 THEN 0
+                    WHEN toInteger(coalesce(t.priority, 3)) = 1 THEN 1
+                    WHEN t.originKind = 'okr_feedback' THEN 2
+                    ELSE toInteger(coalesce(t.priority, 3)) + 2
+                  END AS sortPriority
+             RETURN t.id AS taskId, t.title AS title, t.originKind AS originKind, t.body AS body, t.priority AS priority
+             ORDER BY sortPriority ASC, t.createdAt ASC
+             LIMIT 1`,
+            { companyId: this.companyId, agentId }
+          );
+          taskRow = taskResult?.rows?.[0];
+        } catch (mgErr) {
+          // Memgraph unavailable — fall back to SQLite
+          if (hboStore.getTasksByCompanyStatus) {
+            const storeTodos = hboStore.getTasksByCompanyStatus(this.companyId, 'todo')
+              .filter(t => t.assigneeAgentId === agentId && t.title);
+            storeTodos.sort((a, b) => {
+              const _sortPri = t => {
+                const p = parseInt(t.priority ?? 3, 10);
+                if (p === 0) return 0;
+                if (p === 1) return 1;
+                if (t.originKind === 'okr_feedback') return 2;
+                return (isNaN(p) ? 3 : p) + 2;
+              };
+              const diff = _sortPri(a) - _sortPri(b);
+              return diff !== 0 ? diff : (a.createdAt ?? 0) - (b.createdAt ?? 0);
+            });
+            const best = storeTodos.find(t => !claimedTaskIds.has(t.id));
+            if (best) {
+              taskRow = [best.id, best.title, best.originKind ?? null, best.body ?? null, best.priority ?? 3];
+              log('info', `AgentDispatcher: using SQLite fallback for task lookup (Memgraph unavailable): ${mgErr.message}`);
+            }
+          }
+        }
       } catch (err) {
         log('warn', `AgentDispatcher: task lookup failed for agent ${agentId}: ${err.message}`);
         continue;
       }
-      const taskRow = taskResult?.rows?.[0];
       if (!taskRow) continue;
       const taskId     = taskRow[0] ?? taskRow['taskId'];
       const title      = taskRow[1] ?? taskRow['title'];
@@ -1816,9 +1942,10 @@ class AgentDispatcher {
 
         try {
           // Non-blocking dispatch: run task in background so tick doesn't stall.
-          // TaskCompletionWatchdog handles timeouts (reverts after taskTimeoutMs).
-          // This prevents a single long-running pi session from blocking all ticks.
-          const TASK_DISPATCH_TIMEOUT_MS = (_daemonConfig.taskTimeoutMs ?? 300000) + 60000; // taskTimeout + 60s grace
+          // TaskCompletionWatchdog reverts non-TUI tasks after taskTimeoutMs (default 30min).
+          // TUI tasks are reverted after 30min (hardcoded in watchdog).
+          // This Promise.race adds 60s grace above the configured timeout.
+          const TASK_DISPATCH_TIMEOUT_MS = (_daemonConfig.taskTimeoutMs ?? 1800000) + 60000; // taskTimeout + 60s grace
           // TUI-09: pass pre-built contextBrief so TuiWakeupAdapter.execute() skips its own
           // buildContextBrief() call — prevents the expensive double-query on this path.
           const taskPromise = adapter.execute(adapterContext, _adapterContextBrief);
@@ -2245,6 +2372,10 @@ class AgentDispatcher {
           ).catch(err => log('warn', `Failed to clear currentTaskId for ${agentId}: ${err.message}`));
           // Pull-dispatch: agent is free — emit AgentReadySignal so next task can be dispatched.
           await this._emitAgentReadySignal(agentId);
+          // DSP-01: push task.updated SSE event for the direct-spawn completion path.
+          // Uses this._daemonBroadcast (closure passed at construction) — NOT daemon._broadcast
+          // which is not in scope inside AgentDispatcher.
+          this._daemonBroadcast?.({ type: 'task.updated', taskId, status: newStatus, companyId: this.companyId });
           log('info', `Task ${taskId} ${newStatus} (exit code: ${code})`);
         } catch (err) {
           log('warn', `Failed to update task ${taskId} completion: ${err.message}`);
@@ -2604,10 +2735,15 @@ class CostEventSyncer {
 }
 
 class TaskCompletionWatchdog {
-  constructor(mgQuery, companyId) {
+  constructor(mgQuery, companyId, taskTimeoutMs = 1800000) {
     if (!companyId) throw new Error('TaskCompletionWatchdog: companyId required');
     this.mg = mgQuery;
     this.companyId = companyId;
+    // Build ISO 8601 duration string for Cypher — passed as a parameter to avoid
+    // hardcoded duration literals. 1800000ms → "PT1800S" (30 minutes default).
+    // This is the non-TUI task timeout; TUI tasks always use the hardcoded PT30M path.
+    this._nonTuiTimeoutDuration = `PT${Math.floor(taskTimeoutMs / 1000)}S`;
+    this._nonTuiTimeoutMins = Math.round(taskTimeoutMs / 60000);
   }
 
   /**
@@ -2615,7 +2751,11 @@ class TaskCompletionWatchdog {
    * Tournament winner: Candidate C — consistent with andon-tier1.js pattern,
    * Memgraph-safe, no MERGE key uniqueness dependency.
    */
-  async _emitTaskTimeoutSignal(taskId, agentId) {
+   async _emitTaskTimeoutSignal(taskId, agentId) {
+    // Build message in JavaScript before the Cypher call — avoids nested backtick
+    // template literals (the outer Cypher string is a backtick; inner backtick would
+    // close it prematurely). Passing as $message param is cleaner and correct.
+    const _timeoutMsg = `Task exceeded ${this._nonTuiTimeoutMins}-minute completion timeout — reverted to todo`;
     try {
       await this.mg(
         `OPTIONAL MATCH (existing:AnomalySignal {taskId: $taskId, signalType: 'TASK_TIMEOUT', status: 'open'})
@@ -2630,12 +2770,12 @@ class TaskCompletionWatchdog {
            source:     'watchdog',
            signalType: 'TASK_TIMEOUT',
            severity:   'P1',
-           message:    'Task exceeded 5-minute completion timeout — reverted to todo',
+            message:    $message,
            detectedAt: datetime(),
            status:     'open'
          })`,
-        { taskId, agentId: agentId ?? 'unknown', cid: this.companyId }
-      );
+        { taskId, agentId: agentId ?? 'unknown', cid: this.companyId, message: _timeoutMsg }
+      );
     } catch (err) {
       // Log at warn — a silent failure here leaves the Andon board stale.
       const msg = JSON.stringify({ ts: new Date().toISOString(), level: 'warn', module: 'TaskCompletionWatchdog', msg: `TASK_TIMEOUT AnomalySignal write failed for ${taskId}: ${err.message}` });
@@ -2648,10 +2788,10 @@ class TaskCompletionWatchdog {
     // TUI tasks can take >5 min (model probe + execution). Reverting them causes infinite cycling.
     const stale = await this.mg(
       `MATCH (t:Task {status: 'in_progress', companyId: $cid})
-       WHERE t.executionLockedAt < datetime() - duration("PT5M")
+       WHERE t.executionLockedAt < datetime() - duration($timeout)
          AND (t.dispatchedViaTUI IS NULL OR t.dispatchedViaTUI = false)
        RETURN t.id, t.title, t.executionAgentId`,
-      { cid: this.companyId }
+      { cid: this.companyId, timeout: this._nonTuiTimeoutDuration }
     );
 
     const rows = stale?.rows ?? [];
@@ -2669,10 +2809,14 @@ class TaskCompletionWatchdog {
         { taskId }
       );
 
+      // Sync SQLite fallback store — keeps hbo-core.db consistent when Memgraph is unavailable.
+      // Memgraph is primary; SQLite is the fallback path only (AgentDispatcher line 1724).
+      try { hboStore.updateTask(taskId, this.companyId, { status: 'todo', executionLockedAt: null, executionAgentId: null }); } catch (_) {}
+
       // Preserve PDSACycle with abandon decision — losing the PDSA context on
       // revert would break the learning loop. Mark as abandoned so PDSACompletion
       // doesn't re-process it and KnowledgeAsset extraction is skipped correctly.
-      await this._mgQueryAsync(
+      await this.mg(
         `MATCH (p:PDSACycle {taskId: $taskId})
          WHERE p.actDecision = 'iterate' OR p.actDecision IS NULL
          SET p.actDecision        = 'abandon',
@@ -2691,7 +2835,28 @@ class TaskCompletionWatchdog {
       // OPTIONAL MATCH dedup guard prevents duplicate signals for the same task.
       await this._emitTaskTimeoutSignal(taskId, agentId);
 
-      log('warn', `Task ${taskId} timed out after 5min — reverting to todo`);
+      log('warn', `Task ${taskId} timed out after ${this._nonTuiTimeoutMins}min — reverting to todo`);
+
+      // Re-emit AgentReadySignal so the agent can be dispatched again on the next tick.
+      // Without this, the agent stays idle forever after a timeout event.
+      // Uses the same idempotent OPTIONAL MATCH pattern as AgentDispatcher._emitAgentReadySignal.
+      if (agentId) {
+        await this.mg(
+          `MATCH (a:BusinessAgent {id: $agentId, companyId: $cid, status: 'active'})
+           OPTIONAL MATCH (existing:AgentReadySignal {agentId: $agentId, companyId: $cid, status: 'pending'})
+           WITH a, existing
+           WHERE existing IS NULL
+           CREATE (s:AgentReadySignal {
+             id:        randomUUID(),
+             agentId:   $agentId,
+             companyId: $cid,
+             status:    'pending',
+             claimedBy: null,
+             createdAt: datetime()
+           })`,
+          { agentId, cid: this.companyId }
+        ).catch(() => {});
+      }
     }
 
     // Timeout TUI-dispatched tasks stuck >30min
@@ -2710,8 +2875,11 @@ class TaskCompletionWatchdog {
         `MATCH (t:Task {id: $taskId}) SET t.status = 'todo', t.executionLockedAt = null, t.executionAgentId = null, t.dispatchedViaTUI = null, t.heliosRunId = null, t.timedOutAt = datetime() RETURN t.id`,
         { taskId }
       );
+
+      // Sync SQLite fallback store — also null dispatchedViaTUI and heliosRunId for TUI tasks.
+      try { hboStore.updateTask(taskId, this.companyId, { status: 'todo', executionLockedAt: null, executionAgentId: null, dispatchedViaTUI: null, heliosRunId: null }); } catch (_) {}
       // Preserve PDSACycle with abandon decision for TUI-timed-out tasks.
-      await this._mgQueryAsync(
+      await this.mg(
         `MATCH (p:PDSACycle {taskId: $taskId})
          WHERE p.actDecision = 'iterate' OR p.actDecision IS NULL
          SET p.actDecision        = 'abandon',
@@ -2723,6 +2891,25 @@ class TaskCompletionWatchdog {
       // Also emit for TUI-timed-out tasks (30-min threshold variant).
       await this._emitTaskTimeoutSignal(taskId, agentId);
       log('warn', `TaskCompletionWatchdog: TUI task ${taskId} timed out after 30min — reverting to todo`);
+
+      // Re-emit AgentReadySignal so the agent can be dispatched again on the next tick.
+      if (agentId) {
+        await this.mg(
+          `MATCH (a:BusinessAgent {id: $agentId, companyId: $cid, status: 'active'})
+           OPTIONAL MATCH (existing:AgentReadySignal {agentId: $agentId, companyId: $cid, status: 'pending'})
+           WITH a, existing
+           WHERE existing IS NULL
+           CREATE (s:AgentReadySignal {
+             id:        randomUUID(),
+             agentId:   $agentId,
+             companyId: $cid,
+             status:    'pending',
+             claimedBy: null,
+             createdAt: datetime()
+           })`,
+          { agentId, cid: this.companyId }
+        ).catch(() => {});
+      }
     }
   }
 }
@@ -2733,10 +2920,15 @@ class TaskCompletionWatchdog {
 // Reverted twice (418b606f, 1bf902d0) — protected by __tests__/tui-integration.test.js
 // See: .sisyphus/plans/talisman-daemon-wave8.md (EC-03)
 class RunCompletionPoller {
-  constructor(mgQuery, companyId) {
+  // broadcastFn: optional closure — use (...args) => daemon._broadcast?.(...args) so the
+  //   live SSE function is resolved at call time (not at construction time, when it is still null).
+  // completionProcessor: optional TaskCompletionProcessor instance for post-completion pipeline.
+  constructor(mgQuery, companyId, broadcastFn, completionProcessor) {
     if (!companyId) throw new Error('RunCompletionPoller: companyId required');
     this.mg = mgQuery;
     this.companyId = companyId;
+    this._broadcastFn = typeof broadcastFn === 'function' ? broadcastFn : null;
+    this._cp = completionProcessor ?? null;
   }
 
   async poll() {
@@ -2789,6 +2981,8 @@ class RunCompletionPoller {
         const newStatus = (run.status === 'completed' || run.status === 'succeeded') ? 'done' : 'failed';
         // FINDING-2 fix: criticalOp wrapper — revert to todo if markDone write fails,
         // then re-emit AgentReadySignal so the agent is not permanently locked.
+        // markDoneOk tracks success so downstream pipeline and broadcast are skipped on revert.
+        let markDoneOk = true;
         await criticalOp(
           () => this.mg(
             `MATCH (t:Task {id: $taskId})
@@ -2798,6 +2992,7 @@ class RunCompletionPoller {
           ),
           { module: 'RunCompletionPoller', operation: 'markDone', taskId, companyId: this.companyId }
         ).catch(async (markDoneErr) => {
+          markDoneOk = false;
           log('warn', `RunCompletionPoller: markDone failed for ${taskId} — reverting to todo: ${markDoneErr.message}`);
           await this.mg(
             `MATCH (t:Task {id: $taskId}) SET t.status = 'todo', t.executionLockedAt = null, t.executionAgentId = null, t.dispatchedViaTUI = null, t.heliosRunId = null`,
@@ -2805,11 +3000,26 @@ class RunCompletionPoller {
           ).catch(revertErr => log('warn', `RunCompletionPoller: failed reverting to todo for ${taskId}: ${revertErr.message}`));
           await this._emitAgentReadySignal(agentId).catch(() => {});
         });
+        // If markDone was reverted, skip completion pipeline and broadcast — task is back in todo.
+        if (!markDoneOk) continue;
         await this.mg(
           `MATCH (a:BusinessAgent {id: $agentId, companyId: $cid}) SET a.lastHeartbeatAt = toInteger(timestamp() / 1000)`,
           { agentId, cid: this.companyId }
         ).catch(err => log('warn', `RunCompletionPoller: failed to update heartbeat for ${agentId}: ${err.message}`));
         log('info', `Task ${taskId} ${newStatus} (TUI run ${runId} → ${run.status})`);
+        // RCP-01: run completion pipeline (TaskResult, OKR progress, CRM, PDSA) for TUI-completed tasks.
+        if (newStatus === 'done' && this._cp) {
+          this._cp.process(taskId, run.summary ?? '', {
+            agentId,
+            companyId: this.companyId,
+            originKind: run.originKind ?? 'tui_wakeup',
+            exitCode: 0,
+          }).catch(e => log('warn', `RunCompletionPoller: completionProcessor failed for ${taskId}: ${e.message}`));
+        }
+        // RCP-02: push task.updated SSE event so the desktop UI updates reactively without polling.
+        // _broadcastFn is a closure ((...args) => this._broadcast?.(...args)) set at start() time,
+        // so it correctly resolves the live broadcast reference even if SSE server started after construction.
+        this._broadcastFn?.({ type: 'task.updated', taskId, status: newStatus, companyId: this.companyId });
         // TUI-01: emit AgentReadySignal so the agent picks up the next task immediately.
         await this._emitAgentReadySignal(agentId).catch(() => {});
       } catch (e) {
@@ -2868,12 +3078,26 @@ class ApprovalWatcher {
   async check() {
     let approved;
     try {
-      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`,
-        { cid: this.companyId }
-      );
+      // Memgraph primary — SQLite fallback on unavailability
+      try {
+        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`,
+          { cid: this.companyId }
+        );
+      } catch (mgErr) {
+        // Memgraph unavailable — fall back to SQLite approvals
+        if (hboStore.getApprovalsByCompanyStatus) {
+          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'],
+          };
+          log('info', `ApprovalWatcher: using SQLite fallback for approval lookup (Memgraph unavailable): ${mgErr.message}`);
+        }
+      }
     } catch (err) {
       log('warn', `ApprovalWatcher: query failed: ${err.message}`);
       return;
@@ -2891,41 +3115,55 @@ class ApprovalWatcher {
       const requestedBy = approval['a.requestedBy'] ?? 'agent:ceo';
       const approvalType = approval['a.type'];
       const taskId = `task:approval-followup:${approvalId}:${randomUUID()}`;
-
       try {
         if (approvalType === 'budget_exceeded') {
-          await this.mg(
+          // Non-blocking Memgraph side-effects — fire-and-forget so Memgraph downtime
+          // does not prevent SQLite writes (task creation + approval update) below.
+          const _mgThis = this.mg.bind(this);
+          setImmediate(() => _mgThis(
             `MATCH (bi:BudgetIncident {approvalId: $apId}) SET bi.status = 'resolved', bi.resolvedAt = datetime()`,
             { apId: approvalId }
-          );
-          await this.mg(
+          ).catch(e => log('warn', `ApprovalWatcher: BudgetIncident resolve projection failed: ${e.message}`)));
+          setImmediate(() => _mgThis(
             `MATCH (a:BusinessAgent {id: $agentId, companyId: $cid}) WHERE a.pauseReason IN ['budget_exceeded', 'budget_exceeded_global'] SET a.status = 'active', a.pauseReason = null, a.resumedAt = datetime()`,
             { agentId: requestedBy, cid: this.companyId }
-          );
+          ).catch(e => log('warn', `ApprovalWatcher: agent resume projection failed: ${e.message}`)));
           log('info', `ApprovalWatcher: budget approval resolved — agent ${requestedBy} resumed`);
         }
 
         if (approvalType === 'strategy_proposal') {
           const strategyId = approval['a.strategyId'];
           if (strategyId) {
-            await this.mg(
+            setImmediate(() => this.mg(
               `MATCH (s:Strategy {id: $strategyId}) SET s.status = 'approved', s.approvedAt = datetime()`,
               { strategyId }
-            );
+            ).catch(e => log('warn', `ApprovalWatcher: strategy approve projection failed: ${e.message}`)));
             log('info', `ApprovalWatcher: strategy ${strategyId} approved`);
           }
-        }
+        }
 
-        await this.mg(
+        // SQLite-first task create (P2-5)
+        try {
+          hboStore.createTask({
+            id: taskId, title: `Approval resolved: ${title}. Execute the approved plan.`,
+            status: 'todo', assigneeAgentId: requestedBy, companyId: this.companyId,
+            originKind: 'approval_resolved', approvalId, progressPropagated: false, createdAt: Date.now(),
+          });
+        } catch (_) {}
+        // Non-blocking Memgraph projection (fire-and-forget)
+        setImmediate(() => this.mg(
           `MERGE (t:Task {id: $taskId}) SET t.title = $title, t.status = 'todo',
            t.assigneeAgentId = $agentId, t.companyId = $cid, t.originKind = 'approval_resolved',
            t.approvalId = $approvalId, t.progressPropagated = false, t.createdAt = datetime()`,
           { taskId, title: `Approval resolved: ${title}. Execute the approved plan.`, agentId: requestedBy, cid: this.companyId, approvalId }
-        );
-        await this.mg(
+        ).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 (_) {}
+        // Non-blocking Memgraph projection (fire-and-forget)
+        setImmediate(() => this.mg(
           `MATCH (a:Approval {id: $approvalId}) SET a.followUpTaskCreated = true`,
           { approvalId }
-        );
+        ).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) {
         log('warn', `ApprovalWatcher: failed to create follow-up for ${approvalId}: ${err.message}`);
@@ -2952,7 +3190,7 @@ class ApprovalWatcher {
 function buildForCompany(companyId, mgQueryAsync, opts) {
   if (!companyId) throw new Error('buildForCompany: companyId required');
   if (!mgQueryAsync) throw new Error('buildForCompany: mgQueryAsync required');
-  const { rpcAdapter, companyConfig = null } = opts || {};
+  const { rpcAdapter, companyConfig = null, broadcast = null } = opts || {};
   const cid = companyId;
 
   // Helper: safe require + construct, non-fatal
@@ -2983,10 +3221,10 @@ function buildForCompany(companyId, mgQueryAsync, opts) {
   try { mods.costEventSyncer = new CostEventSyncer(mgQueryAsync, cid); }
   catch (e) { log('warn', `[module-factory] CostEventSyncer init failed for ${cid}: ${e.message}`); mods.costEventSyncer = null; }
 
-  try { mods.taskCompletionWatchdog = new TaskCompletionWatchdog(mgQueryAsync, cid); }
+  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); }
+  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); }
@@ -3052,9 +3290,13 @@ function buildForCompany(companyId, mgQueryAsync, opts) {
   mods.sacrificeDeclaration   = safeNew('SacrificeDeclaration',   './lib/harada/sacrifice-declaration', 'SacrificeDeclaration', mgQueryAsync, cid);
 
   try {
+    // MirrorPatternScan runs on a P7D (weekly) wall-clock schedule via WallClockScheduler
+    // in addition to the per-10-tasks trigger below. Weekly cadence ensures agents who
+    // complete few tasks still receive periodic mirror feedback.
     const { KataSessionPrompt, MasteryCheck, MirrorPatternScan } = require('./lib/harada/sensei');
     mods.kataSessionPrompt = new KataSessionPrompt(mgQueryAsync, cid);
     mods.masteryCheck      = new MasteryCheck(mgQueryAsync, cid);
+    // P7D weekly wall-clock guard: MirrorPatternScan is also scheduled weekly via WallClockScheduler
     mods.mirrorPatternScan = new MirrorPatternScan(mgQueryAsync, cid);
   } catch (e) {
     log('warn', `[module-factory] Harada Sensei init failed for ${cid}: ${e.message}`);
@@ -3210,7 +3452,7 @@ class HeliosCompanyDaemon {
       const cid = cfg.company?.id || cfg.companyName;
       if (!cid) continue;
       try {
-        const mods = buildForCompany(cid, this._mgQueryAsync.bind(this), { rpcAdapter: this._rpcAdapter, companyConfig: cfg });
+        const mods = buildForCompany(cid, this._mgQueryAsync.bind(this), { rpcAdapter: this._rpcAdapter, companyConfig: cfg, broadcast: (...args) => this._broadcast?.(...args) });
         this._modulesByCompany.set(cid, mods);
         log('info', `_initModules: per-company modules built for '${cid}'`);
       } catch (e) {
@@ -3255,9 +3497,62 @@ class HeliosCompanyDaemon {
       const mods = buildForCompany(cid, this._mgQueryAsync.bind(this), {
         rpcAdapter: this._rpcAdapter,
         companyConfig: null,  // not available for runtime-added companies
+        broadcast: (...args) => this._broadcast?.(...args),
       });
       this._modulesByCompany.set(cid, mods);
       log('info', `[registerCompany] per-company modules live for '${cid}'`);
+
+      // Wire the SSE broadcast function into HBOBridge now that the API server is running.
+      // buildForCompany passes companyConfig (null) as the 4th arg to HBOBridge — not the
+      // broadcast function — so _bc is null after construction. setBroadcast() sets it here,
+      // enabling wizard:pillars_ready and other real-time events to reach the desktop.
+      if (mods.hboBridge && typeof mods.hboBridge.setBroadcast === 'function' && typeof this._broadcast === 'function') {
+        mods.hboBridge.setBroadcast(this._broadcast);
+        log('info', `[registerCompany] HBOBridge broadcast wired for '${cid}'`);
+      }
+
+      // Trigger GoalPillar creation immediately after modules are registered.
+      // tickGoalDecompose creates the 8 GoalPillar + 64 ActionCell nodes via MandalaManager.
+      // This must run AFTER _modulesByCompany.set() so mods.hboBridge is available.
+      // This is the correct point to run it — after wizard completes and registerCompany is
+      // called from the desktop, _modulesByCompany is guaranteed to have this company's entry.
+      if (mods.hboBridge && typeof mods.hboBridge.tickGoalDecompose === 'function') {
+        setImmediate(async () => {
+          try {
+            await mods.hboBridge.tickGoalDecompose({ fromWizard: true });
+            log('info', `[registerCompany] tickGoalDecompose complete for '${cid}'`);
+            // Emit wizard:pillars_ready via SSE bridge if broadcast is wired.
+            if (typeof this._broadcast === 'function') {
+              this._broadcast({
+                type: 'wizard:pillars_ready',
+                companyId: cid,
+                pillarCount: 8,
+                ts: Date.now(),
+              });
+            } else {
+              // D1: _broadcast may not yet be wired if API server started after registerCompany
+              // (startup race condition). Retry once after 1s before giving up.
+              log('warn', `[registerCompany] wizard:pillars_ready not broadcast for '${cid}' — _broadcast not yet wired, retrying in 1s`);
+              const self = this;
+              setTimeout(() => {
+                if (typeof self._broadcast === 'function') {
+                  self._broadcast({
+                    type: 'wizard:pillars_ready',
+                    companyId: cid,
+                    pillarCount: 8,
+                    ts: Date.now(),
+                  });
+                  log('info', `[registerCompany] wizard:pillars_ready broadcast on retry for '${cid}'`);
+                } else {
+                  log('warn', `[registerCompany] wizard:pillars_ready not broadcast after retry for '${cid}' — SSE events will be missed`);
+                }
+              }, 1000);
+            }
+          } catch (e) {
+            log('warn', `[registerCompany] tickGoalDecompose failed for '${cid}' (non-fatal): ${e.message}`);
+          }
+        });
+      }
     } catch (e) {
       log('warn', `[registerCompany] buildForCompany failed for '${cid}': ${e.message}`);
       throw e;  // surface to the HTTP handler — caller can retry
@@ -4165,7 +4460,13 @@ class HeliosCompanyDaemon {
     try {
       const { verifyMemgraphConfig } = require('./lib/memgraph-verify');
       const vr = await verifyMemgraphConfig(this._mgQueryAsync.bind(this));
-      log('info', `Memgraph config verified: ${vr.serverTime} (timestamp unit: ${vr.timestampUnit})`);
+      if (vr.timestampUnit === 'microseconds') {
+        log('info', `Memgraph config verified: ${vr.serverTime} (timestamp unit: ${vr.timestampUnit})`);
+      } else {
+        // Non-fatal: zombie-detection uses toInteger(timestamp()/1000) consistently
+        // on both SET and GET, so the unit cancels out and comparisons remain correct.
+        log('warn', `Memgraph config verified with non-standard timestamp unit: ${vr.timestampUnit} (server: ${vr.serverTime}) — zombie-detection unaffected`);
+      }
     } catch (e) {
       const msg = String(e.message || e);
       // Detect connection-level failures — Memgraph is not running yet
@@ -4198,24 +4499,31 @@ class HeliosCompanyDaemon {
       }
     }
 
-    // ── Headroom compression proxy (required service) ─────────────────────────
-    // Starts the local Headroom proxy sidecar that intercepts all LLM traffic and
-    // compresses tool outputs, HEMA recall payloads, and HBO API responses before
-    // they reach the model. This is a required service — if it fails to start,
-    // the daemon exits with a clear error message (same pattern as verifyMemgraphConfig).
+    // ── Helios Compression Server ─────────────────────────────────────────────
+    // Starts the TypeScript compression sidecar (lib/compression/server.ts).
+    // Compresses tool outputs, HEMA recall payloads, and HBO API responses
+    // before they reach the LLM — reducing token cost by 40–85%.
+    //
+    // Non-fatal: if the server fails to start, the daemon continues without
+    // compression. All compression call sites check getBaseUrl() === null and
+    // skip compression gracefully. HBO still works, agents still function.
+    // This matches the principle: compression improves the system but is not
+    // a correctness dependency — every company's data remains accessible.
     //
-    // Auto-restarts on mid-session crash (Option 1) with exponential backoff.
-    // getBaseUrl() is read at call time by all LLM path wrappers — they pick up
-    // the new URL automatically after a proxy restart.
+    // Auto-restarts on mid-session crash with exponential backoff.
     try {
       const { HeadroomProxyManager } = require('./lib/headroom-proxy-manager');
       this._headroomProxy = HeadroomProxyManager.getInstance();
       const hr = await this._headroomProxy.start();
-      log('info', `Headroom compression proxy ready: ${hr.baseUrl}`);
+      log('info', `Helios Compression Server ready: ${hr.baseUrl}`);
     } catch (e) {
-      log('error', `Headroom compression proxy FAILED to start:\n${e.message}`);
-      // Same comment as verifyMemgraphConfig: do NOT remove daemon.lock
-      process.exit(1);
+      log('warn',
+        `Helios Compression Server failed to start — daemon continues without compression.\n` +
+        `Token costs will be higher until the server is fixed and the daemon restarts.\n` +
+        `Error: ${e.message}`
+      );
+      // Do NOT exit — compression is an optimization, not a correctness dependency.
+      // All call sites handle null baseUrl gracefully.
     }
 
     // ── Redis maxmemory verification (warn if unset) ──────────────────────────
@@ -4277,6 +4585,58 @@ class HeliosCompanyDaemon {
       log('warn', `Daemon-online heartbeat reset failed (non-fatal): ${e.message}`);
     }
 
+    // ── Startup AgentReadySignal sweep — all companies ──────────────────────────
+    // Emits a pending AgentReadySignal for every active agent that has neither
+    // a pending signal nor a current in-progress task.
+    //
+    // Primary path: daemon restarts → signals emitted for idle agents → next tick
+    // dispatches tasks to all active agents → no stranded agents after restart.
+    //
+    // Uses OPTIONAL MATCH ... WHERE existing IS NULL (idempotent, same pattern as
+    // _emitAgentReadySignal). NOT EXISTS subqueries are not supported in Memgraph 3.
+    try {
+      let _sweepEmitted = 0;
+      let _sweepAttempted = 0;
+      for (const cfg of _allCompanyConfigs) {
+        const cid = cfg.company?.id || cfg.companyName;
+        if (!cid) continue;
+        // Find active agents with no pending signal and no in-progress task.
+        const _candidates = await this._mgQueryAsync(
+          `MATCH (a:BusinessAgent {companyId: $cid, status: 'active'})
+           OPTIONAL MATCH (sig:AgentReadySignal {agentId: a.id, companyId: $cid, status: 'pending'})
+           OPTIONAL MATCH (wip:Task {assigneeAgentId: a.id, companyId: $cid})
+             WHERE wip.status IN ['in_progress', 'andon_paused', 'help_pending']
+           WITH a, sig, wip
+           WHERE sig IS NULL AND wip IS NULL
+           RETURN a.id AS agentId`,
+          { cid }
+        ).catch(() => null);
+        for (const row of (_candidates?.rows ?? [])) {
+          const agentId = Array.isArray(row) ? row[0] : row?.agentId;
+          if (!agentId) continue;
+          _sweepAttempted++;
+          await this._mgQueryAsync(
+            `MATCH (a:BusinessAgent {id: $agentId, companyId: $cid, status: 'active'})
+             OPTIONAL MATCH (existing:AgentReadySignal {agentId: $agentId, companyId: $cid, status: 'pending'})
+             WITH a, existing
+             WHERE existing IS NULL
+             CREATE (s:AgentReadySignal {
+               id:        randomUUID(),
+               agentId:   $agentId,
+               companyId: $cid,
+               status:    'pending',
+               claimedBy: null,
+               createdAt: datetime()
+             })`,
+            { agentId, cid }
+          ).then(() => { _sweepEmitted++; }).catch(() => {});
+        }
+      }
+      log('info', `Startup AgentReadySignal sweep: ${_sweepEmitted}/${_sweepAttempted} signals emitted for ${_allCompanyConfigs.length} company(ies)`);
+    } catch (e) {
+      log('warn', `Startup AgentReadySignal sweep failed (non-fatal): ${e.message}`);
+    }
+
     // ── CV-T fix: reset stale in-progress RoutineRun nodes on restart ─────────
     // RoutineRun nodes with status 'queued' or 'running' from a previous daemon
     // session are permanently stuck — the process that started them is gone.
@@ -4467,10 +4827,24 @@ class HeliosCompanyDaemon {
     registry.register('tui_wakeup', new TuiWakeupAdapter(heliosConfig, this._mgQueryAsync.bind(this), _companyConfig.agents ?? []));
     registry.register('process', new ProcessAdapter());
 
-    this._agentDispatcher = new AgentDispatcher(this._mgQueryAsync.bind(this), primaryCompanyId, null, null, registry);
+    this._agentDispatcher = new AgentDispatcher(
+      this._mgQueryAsync.bind(this),
+      primaryCompanyId,
+      null,   // spawnFn
+      null,   // _testConfig
+      registry,
+      (...args) => this._broadcast?.(...args)  // broadcastFn — closure so live ref resolved at call time
+    );
     this._activityLogger = new ActivityLogger(this._mgQueryAsync.bind(this), primaryCompanyId);
-    this._taskCompletionWatchdog = new TaskCompletionWatchdog(this._mgQueryAsync.bind(this), primaryCompanyId);
-    this._runCompletionPoller = new RunCompletionPoller(this._mgQueryAsync.bind(this), primaryCompanyId);
+    this._taskCompletionWatchdog = new TaskCompletionWatchdog(this._mgQueryAsync.bind(this), primaryCompanyId, _daemonConfig.taskTimeoutMs ?? 1800000);
+    // Pass a closure for broadcastFn so it resolves daemon._broadcast at call time (not at construction).
+    // Pass _agentDispatcher._completionProcessor so TUI-completed tasks run the full completion pipeline.
+    this._runCompletionPoller = new RunCompletionPoller(
+      this._mgQueryAsync.bind(this),
+      primaryCompanyId,
+      (...args) => this._broadcast?.(...args),
+      this._agentDispatcher._completionProcessor ?? null
+    );
     this._costEventSyncer = new CostEventSyncer(this._mgQueryAsync.bind(this), primaryCompanyId);
     this._nodeCleaner = new NodeCleaner(this._mgQueryAsync.bind(this));
     this._mageAnalytics = new MageAnalytics(this._mgQueryAsync.bind(this));
@@ -5190,6 +5564,24 @@ if (require.main === module) {
         daemon._apiUpdateTick = updateTick;
       }
       daemon._broadcast = broadcast;
+
+      // Wire the broadcast function into every per-company HBOBridge instance.
+      // buildForCompany() receives companyConfig (not the broadcast fn) as its 4th arg,
+      // so _bc is null after _initModules() runs. We fix that here, immediately after
+      // the API server starts and broadcast becomes available.
+      // Without this, all startup-company HBOBridge instances have _bc = null for
+      // the entire daemon lifetime — no real-time SSE events (approval.created,
+      // wizard:pillars_ready, etc.) can be pushed to connected desktop clients.
+      for (const [, mods] of daemon._modulesByCompany || []) {
+        if (mods?.hboBridge && typeof mods.hboBridge.setBroadcast === 'function') {
+          mods.hboBridge.setBroadcast(broadcast);
+        }
+      }
+      // Also wire the legacy single-company bridge (used when _modulesByCompany is absent).
+      if (daemon._hboBridge && typeof daemon._hboBridge.setBroadcast === 'function') {
+        daemon._hboBridge.setBroadcast(broadcast);
+      }
+      log('info', `[startApi] HBOBridge broadcast wired for ${(daemon._modulesByCompany || new Map()).size} company(ies)`);
       const apiPort = _daemonConfig.apiPort ?? 9093;
       // Store the bound port on the daemon instance so _writeHealthFile() can include it.
       // This makes the port visible in daemon-health.json for operators and monitoring tools.
@@ -5208,5 +5600,5 @@ if (require.main === module) {
 
 // Export classes for testing
 if (typeof module !== 'undefined') {
-  module.exports = { HeliosCompanyDaemon, RoutineEvaluator, LivenessWatchdog, BudgetEnforcer, AgentDispatcher, ActivityLogger, TaskCompletionWatchdog, CostEventSyncer, NodeCleaner, requireRunId, MageAnalytics, _allCompanyConfigs, buildForCompany };
+  module.exports = { HeliosCompanyDaemon, RoutineEvaluator, LivenessWatchdog, BudgetEnforcer, AgentDispatcher, ApprovalWatcher, ActivityLogger, TaskCompletionWatchdog, CostEventSyncer, NodeCleaner, requireRunId, MageAnalytics, _allCompanyConfigs, buildForCompany };
 }