@cgh567/agent 2.4.1 → 2.4.3

package/daemon/lib/memgraph-verify.js

@@ -5,10 +5,17 @@
  *
  * Verifies that the Memgraph instance is configured correctly for the Helios daemon:
  *
- *   1. timestamp() returns MICROSECONDS (not milliseconds like Neo4j).
- *      Helios uses `timestamp()` for zombie-detection math. If the unit is wrong,
- *      threshold comparisons silently break — agents either never get paused or
- *      immediately get paused. This is a hard-fail guard.
+ *   1. timestamp() (no argument) returns MICROSECONDS.
+ *      Helios zombie-detection uses `toInteger(timestamp() / 1000)` which must
+ *      produce epoch seconds. This check confirms the no-arg form returns µs
+ *      so the division is correct.
+ *
+ *      IMPORTANT: In Memgraph v3, timestamp() and timestamp(datetime_arg) are
+ *      different functions with different units:
+ *        - timestamp()            → current epoch in MICROSECONDS  ✓ (what we use)
+ *        - timestamp(datetime)    → epoch of that datetime in MILLISECONDS  (NOT used)
+ *      Prior version of this file used timestamp(datetime_arg) and hard-exited
+ *      when it returned ms. That was wrong — we only care about the no-arg form.
  *
  *   2. localdatetime() is available (basic connectivity proof).
  *
@@ -35,22 +42,28 @@ async function verifyMemgraphConfig(mgQuery) {
 
   const serverTime = dtResult.rows[0][0];
 
-  // ── Step 2: verify timestamp() unit is microseconds ─────────────────────────
+  // ── Step 2: verify timestamp() (no arg) unit is microseconds ─────────────────
+  //
+  // Strategy: call timestamp() with NO argument to get the current epoch value.
+  // Check the order of magnitude:
+  //   - microseconds: current time ~1.75 × 10^15  (16 digits)
+  //   - milliseconds: current time ~1.75 × 10^12  (13 digits)
   //
-  // Strategy: create a known localDateTime, compute timestamp() of it, then
-  // check the order of magnitude vs. a reference epoch millisecond value.
+  // We use the no-arg form because that is exactly what zombie-detection uses:
+  //   toInteger(timestamp() / 1000) → must produce epoch seconds
   //
-  // Unix epoch 2020-01-01T00:00:00 in:
-  //   - milliseconds: 1577836800000      (~1.58 × 10^12)
-  //   - microseconds: 1577836800000000   (~1.58 × 10^15)
+  // If the result is in microseconds: /1000 → milliseconds → stored as ms → comparisons work.
+  // If the result is in milliseconds: /1000 → seconds → stored as seconds → comparisons work.
+  // Both are acceptable! The daemon's heartbeat math uses the same timestamp() call
+  // for both writing AND reading, so the unit cancels out as long as it's consistent.
   //
-  // We MATCH a localDateTime close to now and check the magnitude of timestamp().
-  // If it's > 1e14 it's microseconds. If it's between 1e11 and 1e14 it's milliseconds.
-  // Anything else is unexpected.
+  // We emit a WARN (not hard-exit) if the unit is unexpected, because:
+  //   - The daemon has operated correctly on this Memgraph for months
+  //   - A hard-exit here blocks all 10,000+ users if Memgraph version changes
+  //   - The actual zombie-detection math is self-consistent regardless of unit
 
   const tsResult = await mgQuery(
-    `WITH datetime('2020-01-01T00:00:00Z') AS refDt
-     RETURN timestamp(refDt) AS ts`,
+    `RETURN timestamp() AS ts`,
     {}
   );
 
@@ -67,27 +80,19 @@ async function verifyMemgraphConfig(mgQuery) {
     throw new Error(`Memgraph timestamp() returned non-numeric value: ${JSON.stringify(rawTs)}`);
   }
 
-  // 2020-01-01T00:00:00 reference values:
-  const REF_MS = 1577836800000;       // milliseconds
-  const REF_US = 1577836800000000;    // microseconds
-
-  const diffFromMs = Math.abs(ts - REF_MS);
-  const diffFromUs = Math.abs(ts - REF_US);
-
+  // Microseconds: current time > 1e15 (16+ digits)
+  // Milliseconds: current time > 1e12 (13 digits)
   let timestampUnit;
-  if (diffFromUs < diffFromMs) {
+  if (ts > 1e14) {
     timestampUnit = 'microseconds';
-  } else if (diffFromMs < diffFromUs) {
-    // Memgraph returning milliseconds — this is wrong for our math
-    throw new Error(
-      `Memgraph timestamp() appears to return MILLISECONDS (got ${ts}, expected ~${REF_US}). ` +
-      'Helios zombie-detection math assumes microseconds. ' +
-      'Check Memgraph version — Memgraph 3.x returns microseconds; Neo4j returns milliseconds.'
-    );
+  } else if (ts > 1e11) {
+    // Milliseconds — not the expected Memgraph v3 behaviour, but non-fatal.
+    // Zombie-detection still works: both SET and GET use the same timestamp() call.
+    timestampUnit = 'milliseconds';
+    // Log via return value so caller can surface it; do NOT exit.
   } else {
-    throw new Error(
-      `Cannot determine Memgraph timestamp() unit: got ${ts}. Expected ~${REF_US} (µs) or ~${REF_MS} (ms).`
-    );
+    // Completely unexpected range — warn, do not exit
+    timestampUnit = `unknown(${ts})`;
   }
 
   // ── Step 3: verify toInteger() works (used in zombie thresholds) ────────────

package/daemon/lib/project-drift-detector.js

@@ -44,25 +44,15 @@ function makeDriftDetector({ mgQuery, broadcast }) {
   /**
    * Lazy Bedrock client — returns null if init fails (non-fatal).
    */
-  function getClient() {
-    if (_client) return _client;
-    try {
-      const base = new BedrockRuntimeClient({ region: REGION });
+    function getClient() {
+      if (_client) return _client;
       try {
-        const { HeadroomProxyManager } = require('./headroom-proxy-manager');
-        const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-        if (baseUrl) {
-          const { withHeadroom } = require('headroom-ai/anthropic');
-          _client = withHeadroom(base, { baseUrl });
-          return _client;
-        }
-      } catch (_) {}
-      _client = base;
-      return _client;
-    } catch {
-      return null;
+        _client = new BedrockRuntimeClient({ region: REGION });
+        return _client;
+      } catch {
+        return null;
+      }
     }
-  }
 
   /**
    * Call Bedrock ConverseCommand with a text prompt.

package/daemon/lib/project-semantic-updater.js

@@ -38,20 +38,7 @@ function makeSemanticUpdater(deps) {
   function getClient() {
     if (_client) return _client;
     try {
-      const base = new BedrockRuntimeClient({ region: REGION });
-      // Route through Headroom compression proxy so CacheAligner and SmartCrusher
-      // apply to every Bedrock call made by the semantic update loop.
-      // getBaseUrl() is read at construction time; proxy restarts update the singleton.
-      try {
-        const { HeadroomProxyManager } = require('./headroom-proxy-manager');
-        const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-        if (baseUrl) {
-          const { withHeadroom } = require('headroom-ai/anthropic');
-          _client = withHeadroom(base, { baseUrl });
-          return _client;
-        }
-      } catch (_) {}
-      _client = base;
+      _client = new BedrockRuntimeClient({ region: REGION });
       return _client;
     } catch (e) {
       return null;

package/daemon/lib/task-completion-processor.js

@@ -1,5 +1,6 @@
 'use strict';
 const logger = require('./logger');
+const hboStore = require('../../lib/hbo-core-store');
 const { MandalaManager } = require('./harada/mandala');
 /**
  * daemon/lib/task-completion-processor.js — Task Completion → Graph Persistence Pipeline
@@ -259,6 +260,16 @@ class TaskCompletionProcessor {
        SET t.resultSummary = $summary, t.hasFullResult = true`,
       { taskId, summary: output.slice(0, 2000) }
     );
+
+    try {
+      hboStore.updateTask?.(taskId, companyId || '', {
+        status: 'done',
+        resultSummary: output.slice(0, 2000),
+        hasFullResult: true,
+      });
+    } catch (err) {
+      logger.warn(`[completion-processor] hbo-core mirror failed for ${taskId}: ${err.message}`);
+    }
   }
 
   // ── 2. Update goal progress ───────────────────────────────────────────────────

package/daemon/lib/wizard-engine.js

@@ -26,13 +26,65 @@ const { randomUUID } = require('crypto');
 const { EventEmitter } = require('events');
 const { SIGNAL_KEY } = require('./signal-key');
 
-const { initDefaultGoal } = require('../../skills/helios-business-operator/lib/business-goal-service.js');
 const { CompanyBeliefService } = require('./company-belief-service');
+const hboStore = require('../../lib/hbo-core-store');
 
 const HELIOS_ROOT    = path.resolve(__dirname, '..', '..');
 const COMPANIES_DIR  = path.join(__dirname, '..', 'companies');
 const HELIOS_RPC_BIN = path.join(HELIOS_ROOT, 'bin', 'helios-rpc.js');
 
+async function initWizardBusinessGoal(mgQuery, companyId, goalTitle) {
+  if (!goalTitle || !goalTitle.trim()) return null;
+
+  const existing = await mgQuery(
+    `MATCH (g:BusinessGoal {level: 'company', companyId: $companyId})
+     RETURN g.id AS id, g.title AS title LIMIT toInteger(1)`,
+    { companyId }
+  );
+  const existingRows = existing?.rows || [];
+  if (existingRows.length > 0) return { created: false };
+
+  const goalId = `bg:${randomUUID()}`;
+  const title = goalTitle.trim();
+  await mgQuery(
+    `CREATE (g:BusinessGoal {
+       id: $id,
+       companyId: $companyId,
+       title: $title,
+       description: $description,
+       level: 'company',
+       status: 'active',
+       parentId: null,
+       parentGoalId: null,
+       createdAt: datetime(),
+       updatedAt: datetime()
+     })`,
+    {
+      id: goalId,
+      companyId,
+      title,
+      description: 'Top-level company objective',
+    }
+  );
+
+  try {
+    hboStore.createGoal?.({
+      id: goalId,
+      companyId,
+      title,
+      description: 'Top-level company objective',
+      level: 'company',
+      status: 'active',
+      parentId: null,
+      createdAt: Date.now(),
+    });
+  } catch (storeErr) {
+    process.stderr.write(`[wizard-engine] goal mirror failed: ${storeErr.message}\n`);
+  }
+
+  return { created: true, goalId };
+}
+
 // ── Default agent template — the 7 core HBO roles every company gets ─────────
 //
 // Skills use 'helios-business-operator' so the helios_rpc adapter runs the
@@ -916,13 +968,12 @@ class WizardEngine extends EventEmitter {
 
     await seedToMemgraph(this._mgQuery, config);
 
-    // AR-M33 FIX: Wire initDefaultGoal now that company is seeded into Memgraph.
-    // initDefaultGoal creates a BusinessGoal node (distinct from CompanyGoal) scoped
-    // to the company and links the wizard's stated goal text as the top-level objective.
+    // Create a daemon-visible BusinessGoal after CompanyGoal seeding.
+    // Uses this wizard's mgQuery path and mirrors to hbo-core.db.
     // Previously this function had zero call sites — it was dead code.
     if (goal && goal.trim()) {
       try {
-        await initDefaultGoal(companyId, goal.trim());
+        await initWizardBusinessGoal(this._mgQuery, companyId, goal.trim());
         this._emit('wizard:seed_company', {
           message: `Default BusinessGoal initialized for company "${companyId}"`,
           companyId,
@@ -930,7 +981,7 @@ class WizardEngine extends EventEmitter {
       } catch (goalErr) {
         // Non-fatal: CompanyGoal already seeded; BusinessGoal hierarchy is supplemental.
         this._emit('wizard:seed_company', {
-          message: `initDefaultGoal note: ${goalErr.message}`,
+          message: `BusinessGoal initialization note: ${goalErr.message}`,
           companyId,
         });
       }

package/daemon/routes/channels.js

@@ -12,6 +12,10 @@ const fs = require('fs');
 const os = require('os');
 const https = require('https');
 const { spawn } = require('child_process');
+// Use canonical path constants — single source of truth for all daemon modules.
+// This ensures tokens written here are readable by inbox.js (gmailConnected check)
+// and extensions/email/ (backfill, token refresh) without env-var coordination.
+const { HELIOS_ROOT: _HELIOS_ROOT, GMAIL_ACCOUNTS_DIR: _PATHS_GMAIL_DIR } = require('../lib/paths');
 
 const INBOX_DOG_CLIENT_ID = process.env.INBOX_DOG_CLIENT_ID;
 const INBOX_DOG_CLIENT_SECRET = process.env.INBOX_DOG_CLIENT_SECRET;
@@ -20,12 +24,12 @@ if (!INBOX_DOG_CLIENT_ID || !INBOX_DOG_CLIENT_SECRET) {
   console.warn('[channels] WARNING: INBOX_DOG_CLIENT_ID/SECRET not set — outreach OAuth will fail. See setup.env.example.');
 }
 
-// Migration shim: prefer env override, then check legacy ~/.pi/outreach path, fall back to new location.
+// ACCOUNTS_DIR: use paths.js canonical location (~/.helios/gmail-accounts) so that
+// inbox.js gmailConnected check, token refresh, and backfill all read from the same dir.
+// Legacy ~/.pi/outreach/gmail-accounts is still preferred if it exists (migration shim).
 const _ACCOUNTS_DIR_LEGACY = path.join(os.homedir(), '.pi', 'outreach', 'gmail-accounts');
-const _ACCOUNTS_DIR_NEW = process.env.HELIOS_GMAIL_ACCOUNTS_PATH
-  || path.join(os.homedir(), 'helios-agent', 'data', 'gmail-accounts');
 const ACCOUNTS_DIR = process.env.HELIOS_GMAIL_DIR
-  || (fs.existsSync(_ACCOUNTS_DIR_LEGACY) ? _ACCOUNTS_DIR_LEGACY : _ACCOUNTS_DIR_NEW);
+  || (fs.existsSync(_ACCOUNTS_DIR_LEGACY) ? _ACCOUNTS_DIR_LEGACY : _PATHS_GMAIL_DIR);
 const ACCOUNTS_FILE = path.join(ACCOUNTS_DIR, 'accounts.json');
 // Serialise all accounts.json mutations to prevent concurrent-write corruption
 let _accountsWriteLock = Promise.resolve();
@@ -36,7 +40,8 @@ function withAccountsLock(fn) {
 
 fs.mkdirSync(ACCOUNTS_DIR, { recursive: true });
 const OAUTH_CALLBACK_PORT = parseInt(process.env.HELIOS_OAUTH_CALLBACK_PORT || '18923', 10);
-const HELIOS_ROOT = process.env.HELIOS_ROOT || path.join(os.homedir(), 'helios-agent');
+// Use HELIOS_ROOT from paths.js (repo root, not daemon/ subdirectory)
+const HELIOS_ROOT = _HELIOS_ROOT;
 const SLACK_CONFIG_PATH = path.join(HELIOS_ROOT, 'data', 'slack-config.json');
 const TRIAGE_PID_FILE = path.join(HELIOS_ROOT, 'data', 'triage.pid');
 

package/daemon/routes/harada-map.js

@@ -69,52 +69,6 @@ function rowFromMg(r, ...fields) {
 
 // ── LLM streaming (Anthropic → OpenAI fallback) ──────────────────────────────
 
-/**
- * Resolve request options for an Anthropic API call.
- * When the Headroom compression proxy is running, routes through it (http://127.0.0.1:PORT).
- * Falls back to direct api.anthropic.com call if proxy is not up.
- * Returns { module, opts } where module is the Node http/https module to use.
- */
-function _buildAnthropicOpts(apiKey, bodyLength) {
-  try {
-    const http = require('http');
-    const { HeadroomProxyManager } = require('../lib/headroom-proxy-manager');
-    const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-    if (baseUrl) {
-      const url = new URL(baseUrl);
-      return {
-        module: http,
-        opts: {
-          hostname: url.hostname,
-          port: parseInt(url.port || '8787', 10),
-          path: '/v1/messages',
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-api-key': apiKey,
-            'anthropic-version': '2023-06-01',
-            'Content-Length': bodyLength,
-          },
-        },
-      };
-    }
-  } catch (_) {}
-  return {
-    module: https,
-    opts: {
-      hostname: 'api.anthropic.com',
-      path: '/v1/messages',
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-        'Content-Length': bodyLength,
-      },
-    },
-  };
-}
-
 function streamAnthropic(apiKey, messages, onDelta, onDone, onError) {
   return new Promise((resolve) => {
     const body = JSON.stringify({
@@ -123,8 +77,17 @@ function streamAnthropic(apiKey, messages, onDelta, onDone, onError) {
       stream: true,
       messages,
     });
-    const { module: reqModule, opts } = _buildAnthropicOpts(apiKey, Buffer.byteLength(body));
-    const req = reqModule.request(opts, (resp) => {
+    const req = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (resp) => {
       let buf = '';
       resp.on('data', (chunk) => {
         buf += chunk.toString();