@cgh567/agent 2.4.1 → 2.4.3

package/daemon/adapters/helios-rpc-adapter.js

@@ -33,11 +33,19 @@ const path = require('path');
 const fs   = require('fs');
 const { randomUUID } = require('crypto');
 
-const DEFAULT_TASK_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
-const MAX_STDOUT_BUF = 10 * 1024 * 1024; // 10MB
-
 // Resolve helios-agent root relative to this file: daemon/adapters/ → two levels up
 const HELIOS_ROOT = path.resolve(__dirname, '..', '..');
+
+// Lazy hboStore for SQLite-first CostEvent writes (P2-7)
+let _hboStoreRpc = null;
+function _getHboStoreRpc() {
+  if (_hboStoreRpc) return _hboStoreRpc;
+  try { _hboStoreRpc = require(path.join(HELIOS_ROOT, 'lib', 'hbo-core-store')); } catch (_) {}
+  return _hboStoreRpc;
+}
+
+const DEFAULT_TASK_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+const MAX_STDOUT_BUF = 10 * 1024 * 1024; // 10MB
 const HELIOS_RPC_BIN = path.join(HELIOS_ROOT, 'bin', 'helios-rpc.js');
 
 class HRpcAdapter {
@@ -120,21 +128,22 @@ class HRpcAdapter {
         skill:       skill,
         wakeReason:  config.originKind ?? 'heartbeat_timer',
       }),
-      // ── Headroom compression proxy ──────────────────────────────────────────
-      // Route all pi subprocess LLM calls through the local Headroom proxy.
-      // CacheAligner stabilizes Anthropic/Bedrock KV-cache prefixes.
-      // SmartCrusher compresses tool outputs and HEMA recall payloads.
-      // The proxy URL is read here at call time so it picks up the correct
-      // address after an auto-restart (restart may change the port).
+      // ── Helios Compression Server ───────────────────────────────────────────
+      // Inject HEADROOM_PROXY_URL so the context-compaction.ts extension can
+      // call the compression server directly from the Pi subprocess.
+      //
+      // IMPORTANT: We do NOT set ANTHROPIC_BASE_URL — that would route all LLM
+      // calls through the compression server, which is not a full LLM proxy.
+      // Instead, compression happens in the context-compaction.ts extension hook
+      // BEFORE the LLM call (compress messages array → Pi sends compressed to Bedrock).
+      // This is the correct architecture: compress at assembly time, not at wire time.
       ...(() => {
         try {
           const { HeadroomProxyManager } = require('../lib/headroom-proxy-manager');
           const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
           if (baseUrl) {
             return {
-              ANTHROPIC_BASE_URL:  baseUrl,
-              OPENAI_BASE_URL:     `${baseUrl}/v1`,
-              HEADROOM_PROXY_URL:  baseUrl,
+              HEADROOM_PROXY_URL: baseUrl,
             };
           }
         } catch (_) {}
@@ -395,20 +404,33 @@ class HRpcAdapter {
             onMeta?.({ type: 'agent_end', data: { taskId, textLength: lastAssistantText.length } });
             closeStdin(child);
             // Write real Bedrock spend as CostEvent so BudgetEnforcer can track it
-            if (totalCostCents > 0 && context.mgQuery && config.companyId) {
+            if (totalCostCents > 0 && config.companyId) {
               const ceId = 'ce:rpc:' + taskId + ':' + Date.now();
-              context.mgQuery(
-                `MERGE (ce:CostEvent {id: $id})
-                 ON CREATE SET
-                   ce.companyId   = $cid,
-                   ce.agentId     = $agentId,
-                   ce.costCents   = toInteger($costCents),
-                   ce.source      = 'helios_rpc',
-                   ce.taskId      = $taskId,
-                   ce.createdAt   = localdatetime()`,
-                { id: ceId, cid: config.companyId ?? '', agentId: config.agentId ?? agentId ?? '',
-                  costCents: totalCostCents, taskId }
-              ).catch(e => onLog?.({ stream: 'stderr', chunk: '[helios-rpc-adapter] CostEvent write failed: ' + e.message, ts: new Date().toISOString() }));
+              // SQLite-first CostEvent write (P2-7)
+              try {
+                const _store = _getHboStoreRpc();
+                if (_store && _store.createCostEvent) {
+                  _store.createCostEvent({
+                    id: ceId, companyId: config.companyId ?? '', agentId: config.agentId ?? agentId ?? '',
+                    costCents: totalCostCents, source: 'helios_rpc', taskId, createdAt: Date.now(),
+                  });
+                }
+              } catch (_) {}
+              // Non-blocking Memgraph projection (fire-and-forget)
+              if (context.mgQuery) {
+                setImmediate(() => context.mgQuery(
+                  `MERGE (ce:CostEvent {id: $id})
+                   ON CREATE SET
+                     ce.companyId   = $cid,
+                     ce.agentId     = $agentId,
+                     ce.costCents   = toInteger($costCents),
+                     ce.source      = 'helios_rpc',
+                     ce.taskId      = $taskId,
+                     ce.createdAt   = localdatetime()`,
+                  { id: ceId, cid: config.companyId ?? '', agentId: config.agentId ?? agentId ?? '',
+                    costCents: totalCostCents, taskId }
+                ).catch(e => onLog?.({ stream: 'stderr', chunk: '[helios-rpc-adapter] CostEvent write failed: ' + e.message, ts: new Date().toISOString() })));
+              }
             }
 
             // F1-3: if child doesn't exit within 30s after agent_end, settle now.

package/daemon/adapters/tui_wakeup.js

@@ -25,6 +25,14 @@ class TuiWakeupAdapter {
     if (!heliosConfig.apiUrl || !agentHelios.agentId || !agentHelios.apiKey) {
       return { exitCode: 1, signal: null, timedOut: false, errorCode: 'environment_unhealthy', resultJson: null };
     }
+    if (!heliosConfig.companyId) {
+      onLog?.({
+        stream: 'stderr',
+        chunk: 'HBO wakeup disabled: HELIOS_SAAS_COMPANY_ID is required for tui_wakeup adapter',
+        ts: new Date().toISOString(),
+      });
+      return { exitCode: 1, signal: null, timedOut: false, errorCode: 'environment_unhealthy', resultJson: null };
+    }
 
     // Ensure Helios issue exists
     let heliosIssueId = null;

package/daemon/config/com.familiar.helios-daemon.plist

@@ -90,6 +90,11 @@
         <string>unified</string>
         <key>HELIOS_ALLOW_SEND</key>
         <string>0</string>
+        <!-- --experimental-sqlite enables node:sqlite built-in (hbo-core-store).
+             Stable in Node ≥ 23; required flag in Node 22.
+             --max-old-space-size=1024 matches PM2 ecosystem.config.js memory cap (SVC-2 fix). -->
+        <key>NODE_OPTIONS</key>
+        <string>--experimental-sqlite --max-old-space-size=1024</string>
         <!-- PATH extended to cover common Node.js install locations:
              nvm default, volta, homebrew, system. The launch script will
              source the user's shell profile which adds nvm to PATH. -->

package/daemon/config/helios-daemon.service

@@ -35,6 +35,10 @@ Environment=TZ=UTC
 Environment=ROUTING_AUTHORITY=unified
 Environment=AWS_REGION=us-east-1
 Environment=MEMGRAPH_BOLT_URL=bolt://127.0.0.1:7687
+# --experimental-sqlite enables node:sqlite built-in (hbo-core-store fallback store).
+# Stable in Node ≥ 23; required flag in Node 22.
+# --max-old-space-size=1024 matches the PM2 ecosystem.config.js memory cap (SVC-1 fix).
+Environment=NODE_OPTIONS=--experimental-sqlite --max-old-space-size=1024
 # HELIOS_ROOT is resolved by launch-daemon.sh — not hardcoded here
 # EnvironmentFile uses - prefix (dash) to not fail if file is missing
 EnvironmentFile=-%h/helios-agent/.env

package/daemon/context-enrichment.js

@@ -4,6 +4,14 @@
 
 const { HELIOS_ROOT: _HELIOS_ROOT_CE } = require('./lib/paths');
 
+// Lazy-require hbo-core-store for SQLite-first business entity reads (P2-11)
+let _hboStoreCE = null;
+function _getHboStoreCE() {
+  if (_hboStoreCE) return _hboStoreCE;
+  try { _hboStoreCE = require('../lib/hbo-core-store'); } catch (_) {}
+  return _hboStoreCE;
+}
+
 /** Marker appended when buildContextBrief truncates an oversized brief. */
 const CONTEXT_BRIEF_TRUNCATED = '[CONTEXT BRIEF TRUNCATED — exceeded 30k char cap (aligned to adapter delivery limit)]';
 
@@ -430,19 +438,33 @@ async function buildContextBrief(mgQuery, agentId, taskTitle, companyId, hboBrid
   } catch (e) { /* non-fatal */ }
 
   // 3. Agent's own pending tasks (what else is on their plate)
+  // Memgraph primary — SQLite fallback on unavailability
   try {
-    const pendingResult = await mgQuery(
-      `MATCH (t:Task {assigneeAgentId: $aid, companyId: $cid})
-       WHERE t.status IN ['todo', 'in_progress']
-       RETURN t.title AS title, t.status AS status, t.priority AS priority
-       ORDER BY CASE t.priority WHEN 'P0' THEN 0 WHEN 'P1' THEN 1 WHEN 'P2' THEN 2 ELSE 3 END
-       LIMIT 5`,
-      { aid: agentId, cid: companyId }
-    );
-    const pendingRecords = toRecords(pendingResult);
-    if (pendingRecords.length) {
+    let pendingRecords = null;
+    try {
+      const pendingResult = await mgQuery(
+        `MATCH (t:Task {assigneeAgentId: $aid, companyId: $cid})
+         WHERE t.status IN ['todo', 'in_progress']
+         RETURN t.title AS title, t.status AS status, t.priority AS priority
+         ORDER BY CASE t.priority WHEN 'P0' THEN 0 WHEN 'P1' THEN 1 WHEN 'P2' THEN 2 ELSE 3 END
+         LIMIT 5`,
+        { aid: agentId, cid: companyId }
+      );
+      pendingRecords = toRecords(pendingResult).map(r => ({ _title: r.get('title'), _status: r.get('status'), _priority: r.get('priority') }));
+    } catch (_mgErr) {
+      // Memgraph unavailable — fall back to SQLite pending tasks
+      try {
+        const _storeCE = _getHboStoreCE();
+        if (_storeCE && _storeCE.getTasksByCompanyStatus) {
+          const _rows = _storeCE.getTasksByCompanyStatus(companyId, ['todo', 'in_progress'])
+            .filter(t => t.assigneeAgentId === agentId);
+          pendingRecords = _rows.map(t => ({ _title: t.title, _status: t.status, _priority: t.priority }));
+        }
+      } catch (_sqliteErr) { /* SQLite also unavailable — skip pending tasks section */ }
+    }
+    if (pendingRecords && pendingRecords.length) {
       const lines = pendingRecords.map(r =>
-        `- [${r.get('priority') || 'P3'}] ${r.get('title')} (${r.get('status')})`
+        `- [${r._priority || 'P3'}] ${r._title} (${r._status})`
       );
       sections.push({ id: 'active-tasks', content: `## Your Other Tasks\n${lines.join('\n')}` });
     }
@@ -502,16 +524,32 @@ async function buildContextBrief(mgQuery, agentId, taskTitle, companyId, hboBrid
     }
   } catch (_) { /* non-fatal */ }
 
-  // § QUARTERLY OKR
+  // § QUARTERLY OKR — Memgraph primary, SQLite fallback on unavailability
   try {
-    const okrResult = await mgQuery(
-      `MATCH (o:QuarterlyOKR {companyId: $cid, status: 'active'})
-       WHERE o.agentId = $agentId OR o.assigneeAgentId = $agentId
-       RETURN o.objective AS objective, o.keyResults AS keyResults, o.quarter AS quarter
-       ORDER BY o.createdAt DESC LIMIT 1`,
-      { agentId, cid: companyId }
-    ).catch(() => null);
-    const okrRec = toRecords(okrResult)?.[0];
+    let okrRec = null;
+    try {
+      const okrResult = await mgQuery(
+        `MATCH (o:QuarterlyOKR {companyId: $cid, status: 'active'})
+         WHERE o.agentId = $agentId OR o.assigneeAgentId = $agentId
+         RETURN o.objective AS objective, o.keyResults AS keyResults, o.quarter AS quarter
+         ORDER BY o.createdAt DESC LIMIT 1`,
+        { agentId, cid: companyId }
+      );
+      okrRec = toRecords(okrResult)?.[0] ?? null;
+    } catch (_mgErr) {
+      // Memgraph unavailable — fall back to SQLite OKR data
+      try {
+        const _storeOKR = _getHboStoreCE();
+        if (_storeOKR && _storeOKR.getOKRsByCompanyType) {
+          const _okrs = _storeOKR.getOKRsByCompanyType(companyId, 'quarterly_okr')
+            .filter(o => (o.agentId === agentId || o.assigneeAgentId === agentId) && o.status === 'active');
+          if (_okrs.length) {
+            const o = _okrs[0];
+            okrRec = { get: (k) => o[k] ?? null };
+          }
+        }
+      } catch (_sqliteErr) { /* SQLite also unavailable — skip OKR section */ }
+    }
     if (okrRec) {
       const objective = okrRec.get('objective');
       const keyResults = okrRec.get('keyResults') || [];
@@ -1736,7 +1774,7 @@ ${lines.join('\n')}` });
     try {
       const excl = JSON.parse(pillarData.exclusions || '[]');
       if (excl.length > 0) exclusionNote = `\nDo NOT: ${excl.slice(0, 3).join(', ')}`;
-    } catch (_) {}
+  } catch (_) {}
     sections.push(
       `<north_star_reminder>\n` +
       `Before responding, confirm your answer serves this intent:\n` +

package/daemon/daemon-manager.js

@@ -19,7 +19,7 @@ const os     = require('os');
 const fs     = require('fs');
 const { spawn } = require('child_process');
 
-const DEFAULT_PORT        = parseInt(process.env.HELIOS_DAEMON_PORT || '9091', 10);
+const DEFAULT_PORT        = parseInt(process.env.HELIOS_DAEMON_PORT || '9093', 10);
 const DAEMON_SCRIPT       = path.join(__dirname, 'helios-company-daemon.js');
 // Use HELIOS_ROOT from lib/paths.js so PID_FILE is correct for all install locations
 // (Desktop at C:\Users\...\Desktop\Helios\helios-agent-main, macOS ~/helios-agent, etc.)

package/daemon/db/email-infrastructure-migrate.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+const Database = require("better-sqlite3");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+
+const DB_PATH = path.join(process.env.HELIOS_ROOT || path.join(os.homedir(), "helios-agent"), "data", "email-infrastructure.db");
+fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
+
+const db = new Database(DB_PATH);
+db.pragma("journal_mode = WAL");
+db.pragma("foreign_keys = ON");
+
+db.exec(`
+CREATE TABLE IF NOT EXISTS email_domains (
+  id TEXT PRIMARY KEY,
+  company_id TEXT NOT NULL,
+  domain TEXT NOT NULL,
+  scenario TEXT NOT NULL DEFAULT 'existing',
+  registrar TEXT,
+  registrar_account_vault_key TEXT,
+  registrar_api_key_vault_key TEXT,
+  registered_at TEXT,
+  expires_at TEXT,
+  auto_renew INTEGER DEFAULT 1,
+  registration_cost_cents INTEGER,
+  annual_renewal_cents INTEGER,
+  porkbun_order_id TEXT,
+  mx_records TEXT DEFAULT '[]',
+  spf_record TEXT,
+  spf_verified INTEGER DEFAULT 0,
+  dkim_selectors TEXT DEFAULT '[]',
+  dmarc_policy TEXT,
+  dmarc_verified INTEGER DEFAULT 0,
+  status TEXT DEFAULT 'bootstrapping',
+  verified_at TEXT,
+  last_verified_at TEXT,
+  verification_error TEXT,
+  dns_provisioned_at TEXT,
+  inbound_provider TEXT,
+  outbound_provider TEXT,
+  inbound_provider_vault_key TEXT,
+  outbound_provider_vault_key TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(company_id, domain)
+);
+CREATE INDEX IF NOT EXISTS idx_email_domains_company ON email_domains(company_id);
+CREATE INDEX IF NOT EXISTS idx_email_domains_status ON email_domains(status);
+CREATE INDEX IF NOT EXISTS idx_email_domains_expires ON email_domains(expires_at);
+
+CREATE TABLE IF NOT EXISTS email_personas (
+  id TEXT PRIMARY KEY,
+  company_id TEXT NOT NULL,
+  slug TEXT NOT NULL,
+  first_name TEXT NOT NULL,
+  last_name TEXT,
+  full_name TEXT NOT NULL,
+  title TEXT NOT NULL,
+  company_display TEXT,
+  bio TEXT,
+  avatar_url TEXT,
+  persona_type TEXT NOT NULL DEFAULT 'ai_branded',
+  tone TEXT DEFAULT 'friendly',
+  writing_style TEXT,
+  avoid_phrases TEXT DEFAULT '[]',
+  signature_html TEXT,
+  signature_text TEXT,
+  linkedin_url TEXT,
+  calendar_url TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(company_id, slug)
+);
+CREATE INDEX IF NOT EXISTS idx_email_personas_company ON email_personas(company_id);
+
+CREATE TABLE IF NOT EXISTS email_channels (
+  id TEXT PRIMARY KEY,
+  company_id TEXT NOT NULL,
+  domain_id TEXT NOT NULL,
+  address TEXT NOT NULL,
+  local_part TEXT NOT NULL,
+  sender_identity_mode TEXT NOT NULL DEFAULT 'branded_ai_agent',
+  display_name TEXT NOT NULL,
+  agent_persona_name TEXT,
+  agent_persona_title TEXT,
+  persona_id TEXT,
+  ai_disclosure_enabled INTEGER DEFAULT 1,
+  ai_disclosure_statement TEXT,
+  ai_disclosure_placement TEXT DEFAULT 'footer',
+  reply_to TEXT,
+  signature_html TEXT,
+  signature_text TEXT,
+  agent_id TEXT,
+  role_pattern TEXT,
+  smtp_provider TEXT,
+  smtp_vault_key TEXT,
+  imap_provider TEXT,
+  imap_vault_key TEXT,
+  helios_mail_inbox_id TEXT,
+  hitl_required INTEGER DEFAULT 0,
+  max_daily_outbound INTEGER DEFAULT 50,
+  warmup_enabled INTEGER DEFAULT 1,
+  warmup_current_limit INTEGER DEFAULT 10,
+  warmup_started_at TEXT,
+  eu_compliance_acknowledged INTEGER DEFAULT 0,
+  can_email_eu_recipients INTEGER DEFAULT 0,
+  physical_address TEXT,
+  unsubscribe_url TEXT,
+  preferred_non_eu_mode TEXT,
+  status TEXT DEFAULT 'pending_verification',
+  total_sent INTEGER DEFAULT 0,
+  sent_today INTEGER DEFAULT 0,
+  bounce_rate REAL DEFAULT 0.0,
+  complaint_rate REAL DEFAULT 0.0,
+  last_sent_at TEXT,
+  last_bounce_at TEXT,
+  last_error_at TEXT,
+  last_error_message TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(company_id, address)
+);
+CREATE INDEX IF NOT EXISTS idx_email_channels_company ON email_channels(company_id);
+CREATE INDEX IF NOT EXISTS idx_email_channels_agent ON email_channels(agent_id);
+CREATE INDEX IF NOT EXISTS idx_email_channels_status ON email_channels(status);
+CREATE INDEX IF NOT EXISTS idx_email_channels_domain ON email_channels(domain_id);
+
+CREATE TABLE IF NOT EXISTS domain_bootstrap_jobs (
+  id TEXT PRIMARY KEY,
+  company_id TEXT NOT NULL,
+  domain_id TEXT,
+  triggered_by TEXT NOT NULL,
+  approval_id TEXT,
+  current_stage TEXT NOT NULL DEFAULT 'domain_search',
+  completed_stages TEXT DEFAULT '[]',
+  failed_stage TEXT,
+  fail_reason TEXT,
+  retry_count INTEGER DEFAULT 0,
+  max_retries INTEGER DEFAULT 3,
+  candidate_domains TEXT DEFAULT '[]',
+  selected_domain TEXT,
+  estimated_cost_cents INTEGER,
+  paid_cost_cents INTEGER,
+  porkbun_order_id TEXT,
+  porkbun_account_registry_id TEXT,
+  resend_account_registry_id TEXT,
+  zoho_account_registry_id TEXT,
+  zoho_org_id TEXT,
+  captcha_solves_attempted INTEGER DEFAULT 0,
+  captcha_solves_succeeded INTEGER DEFAULT 0,
+  captcha_solve_cost_cents INTEGER DEFAULT 0,
+  started_at TEXT NOT NULL DEFAULT (datetime('now')),
+  completed_at TEXT,
+  last_activity_at TEXT NOT NULL DEFAULT (datetime('now')),
+  next_retry_at TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_bootstrap_jobs_company ON domain_bootstrap_jobs(company_id);
+CREATE INDEX IF NOT EXISTS idx_bootstrap_jobs_stage ON domain_bootstrap_jobs(current_stage);
+CREATE INDEX IF NOT EXISTS idx_bootstrap_jobs_domain ON domain_bootstrap_jobs(domain_id);
+
+CREATE TABLE IF NOT EXISTS _schema_versions (
+  name TEXT PRIMARY KEY,
+  version INTEGER NOT NULL DEFAULT 1,
+  applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+CREATE TABLE IF NOT EXISTS email_draft_reviews (
+  id TEXT PRIMARY KEY,
+  company_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  channel_id TEXT NOT NULL,
+  recipient_email TEXT NOT NULL,
+  subject TEXT NOT NULL,
+  body_text TEXT NOT NULL,
+  body_html TEXT,
+  generated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  status TEXT NOT NULL DEFAULT 'pending',
+  reviewed_by TEXT,
+  reviewed_at TEXT,
+  review_note TEXT,
+  expires_at TEXT NOT NULL,
+  send_after_approval INTEGER DEFAULT 1
+);
+CREATE INDEX IF NOT EXISTS idx_drafts_company_pending ON email_draft_reviews(company_id, status);
+
+INSERT OR REPLACE INTO _schema_versions(name, version) VALUES('email_infrastructure', 2);
+`);
+
+db.close();
+console.log("email-infrastructure.db created/migrated successfully at:", DB_PATH);

package/daemon/db/hbo-core-migrate.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * hbo-core-migrate.js
+ * Migrates HBO core entity data from Memgraph → SQLite (hbo-core-store).
+ *
+ * Entity types: Task, Approval, BudgetPolicy, CostEvent, BusinessAgent,
+ *               QuarterlyOKR, CompanyGoal, SystemAim, GoalPillar,
+ *               Lead, CRMContact, Account, Opportunity
+ *
+ * Design:
+ *   - Idempotent: safe to run multiple times (INSERT OR REPLACE)
+ *   - Graceful: catches Memgraph connection errors, logs, exits 0
+ *   - Reports counts per entity type on completion
+ *   - Never throws to process for expected errors
+ *
+ * Phase 1 — TCP probe checks if Memgraph port 7687 is open.
+ *            If unreachable, logs "Memgraph unavailable" and exits 0.
+ * Phase 2 — Loads neo4j-driver and hbo-core-store, runs MATCH queries, upserts.
+ */
+'use strict';
+
+process.env.HELIOS_SKIP_BROKER = '1';
+globalThis.__helios_skip_broker = true;
+
+const net = require('net');
+
+function parseBoltUrl(url) {
+  try {
+    const u = new URL(url.replace(/^bolt:\/\//, 'tcp://'));
+    return { host: u.hostname || '127.0.0.1', port: parseInt(u.port || '7687', 10) };
+  } catch {
+    return { host: '127.0.0.1', port: 7687 };
+  }
+}
+
+function probeMemgraph(host, port, timeoutMs) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let done = false;
+    const finish = (ok) => {
+      if (done) return;
+      done = true;
+      try { socket.destroy(); } catch {}
+      resolve(ok);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('error', () => finish(false));
+    socket.once('timeout', () => finish(false));
+    socket.connect(port, host);
+  });
+}
+
+const ENTITY_SPECS = [
+  { label: 'Task',          cypher: 'MATCH (n:Task) RETURN n',          storeMethod: 'createTask' },
+  { label: 'Approval',      cypher: 'MATCH (n:Approval) RETURN n',      storeMethod: 'createApproval' },
+  { label: 'BudgetPolicy',  cypher: 'MATCH (n:BudgetPolicy) RETURN n',  storeMethod: 'upsertBudgetPolicy' },
+  { label: 'CostEvent',     cypher: 'MATCH (n:CostEvent) RETURN n',     storeMethod: 'createCostEvent' },
+  { label: 'BusinessAgent', cypher: 'MATCH (n:BusinessAgent) RETURN n', storeMethod: 'upsertBusinessAgent' },
+  { label: 'QuarterlyOKR',  cypher: 'MATCH (n:QuarterlyOKR) RETURN n',  storeMethod: 'upsertOKR', typeOverride: 'quarterly_okr' },
+  { label: 'CompanyGoal',   cypher: 'MATCH (n:CompanyGoal) RETURN n',   storeMethod: 'upsertOKR', typeOverride: 'company_goal' },
+  { label: 'SystemAim',     cypher: 'MATCH (n:SystemAim) RETURN n',     storeMethod: 'upsertOKR', typeOverride: 'system_aim' },
+  { label: 'GoalPillar',    cypher: 'MATCH (n:GoalPillar) RETURN n',    storeMethod: 'upsertOKR', typeOverride: 'goal_pillar' },
+  { label: 'Lead',          cypher: 'MATCH (n:Lead) RETURN n',          storeMethod: 'upsertLead' },
+  { label: 'CRMContact',    cypher: 'MATCH (n:CRMContact) RETURN n',    storeMethod: 'upsertCRMContact' },
+  { label: 'Account',       cypher: 'MATCH (n:Account) RETURN n',       storeMethod: 'upsertAccount' },
+  { label: 'Opportunity',   cypher: 'MATCH (n:Opportunity) RETURN n',   storeMethod: 'upsertOpportunity' },
+];
+
+async function main() {
+  console.log('[hbo-core-migrate] Starting HBO core data migration from Memgraph → SQLite');
+
+  const boltUrl = process.env.MEMGRAPH_BOLT_URL || 'bolt://127.0.0.1:7687';
+  const { host, port } = parseBoltUrl(boltUrl);
+  const available = await probeMemgraph(host, port, 3000);
+
+  if (!available) {
+    console.log('[hbo-core-migrate] Memgraph unavailable — skipping migration, SQLite will populate on first write');
+    process.exit(0);
+  }
+
+  console.log(`[hbo-core-migrate] Memgraph reachable at ${host}:${port} — loading modules`);
+
+  const neo4j = require('neo4j-driver');
+  const store = require('../../lib/hbo-core-store');
+
+  if (typeof store.createTask !== 'function') {
+    console.error('[hbo-core-migrate] ERROR: hbo-core-store failed to load (createTask is not a function).');
+    console.error('[hbo-core-migrate] Ensure NODE_OPTIONS=--experimental-sqlite and jiti is available.');
+    process.exit(1);
+  }
+
+  const auth = process.env.MEMGRAPH_USER
+    ? neo4j.auth.basic(process.env.MEMGRAPH_USER, process.env.MEMGRAPH_PASSWORD || '')
+    : neo4j.auth.basic('', '');
+
+  const driver = neo4j.driver(boltUrl, auth, {
+    maxConnectionPoolSize: 4,
+    connectionAcquisitionTimeout: 10000,
+    connectionTimeout: 8000,
+    maxTransactionRetryTime: 0,
+    encrypted: 'ENCRYPTION_OFF',
+    disableLosslessIntegers: true,
+  });
+
+  async function queryMemgraph(cypher) {
+    const session = driver.session({ defaultAccessMode: neo4j.session.READ });
+    try {
+      const result = await session.run(cypher);
+      return result.records.map(r => r.toObject());
+    } finally {
+      try { await session.close(); } catch {}
+    }
+  }
+
+  const counts = {};
+  const errors = [];
+
+  for (const spec of ENTITY_SPECS) {
+    let rows;
+    try {
+      rows = await queryMemgraph(spec.cypher);
+    } catch (err) {
+      console.warn(`[hbo-core-migrate] Warning: failed to read ${spec.label}: ${err.message}`);
+      errors.push({ label: spec.label, error: err.message });
+      counts[spec.label] = 0;
+      continue;
+    }
+
+    let count = 0;
+    const fn = store[spec.storeMethod];
+    if (typeof fn !== 'function') {
+      console.warn(`[hbo-core-migrate] Warning: store method '${spec.storeMethod}' not found — skipping ${spec.label}`);
+      counts[spec.label] = 0;
+      continue;
+    }
+
+    for (const row of rows) {
+      try {
+        const props = row.n && row.n.properties ? row.n.properties : (row.n || {});
+        const record = spec.typeOverride ? { ...props, type: spec.typeOverride } : { ...props };
+        fn(record);
+        count++;
+      } catch (writeErr) {
+        if (!errors.find(e => e.label === spec.label)) {
+          errors.push({ label: spec.label, error: writeErr.message });
+          console.warn(`[hbo-core-migrate] Warning: failed to upsert ${spec.label}: ${writeErr.message}`);
+        }
+      }
+    }
+    counts[spec.label] = count;
+  }
+
+  try { await driver.close(); } catch {}
+
+  const tasks       = counts['Task']          ?? 0;
+  const approvals   = counts['Approval']      ?? 0;
+  const budgetPols  = counts['BudgetPolicy']  ?? 0;
+  const costEvts    = counts['CostEvent']     ?? 0;
+  const bizAgents   = counts['BusinessAgent'] ?? 0;
+  const qOKRs       = counts['QuarterlyOKR']  ?? 0;
+  const compGoals   = counts['CompanyGoal']   ?? 0;
+  const sysAims     = counts['SystemAim']     ?? 0;
+  const goalPillars = counts['GoalPillar']    ?? 0;
+  const leads       = counts['Lead']          ?? 0;
+  const contacts    = counts['CRMContact']    ?? 0;
+  const accounts    = counts['Account']       ?? 0;
+  const opps        = counts['Opportunity']   ?? 0;
+
+  console.log(
+    `[hbo-core-migrate] Migrated ${tasks} tasks, ${approvals} approvals, ` +
+    `${budgetPols} budget policies, ${costEvts} cost events, ` +
+    `${bizAgents} agents, ${qOKRs + compGoals + sysAims + goalPillars} OKRs, ` +
+    `${leads} leads, ${contacts} CRM contacts, ${accounts} accounts, ${opps} opportunities`
+  );
+
+  if (errors.length > 0) {
+    console.warn(`[hbo-core-migrate] Completed with ${errors.length} warning(s).`);
+  } else {
+    console.log('[hbo-core-migrate] Migration complete — no errors');
+  }
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[hbo-core-migrate] Unexpected error:', err.message || err);
+  process.exit(0);
+});