@cgh567/agent 2.4.1 → 2.4.2

package/daemon/routes/hbo.js

@@ -14,6 +14,7 @@ const { randomUUID } = crypto;
 const { HELIOS_ROOT } = require('../lib/paths');
 const { CompanyBeliefService } = require('../lib/company-belief-service');
 const { CompanyBeliefDiscovery } = require('../lib/company-belief-discovery');
+const hboStore = require('../../lib/hbo-core-store');
 
 
 const HBO_ROOT = path.resolve(__dirname, '../../skills/helios-business-operator');
@@ -648,20 +649,42 @@ async function handleGetMandala(req, res, ctx) {
     // Build the pillar MATCH differently depending on whether goalId is provided.
     // Memgraph requires extracting all properties into aliases BEFORE OPTIONAL MATCH;
     // referencing gp.property AFTER OPTIONAL MATCH causes "Unbound variable: gp."
-    const pillarQuery = goalId
-      ? `MATCH (gp:GoalPillar {companyId: $cid, goalId: $goalId})
-         WITH gp.id AS id, gp.name AS name, gp.pillarIndex AS pillarIndex,
-              gp.goalId AS goalId, gp.description AS description, gp AS gpNode
-         OPTIONAL MATCH (gpNode)-[:HAS_CELL]->(ac:ActionCell)
-         RETURN id, name, pillarIndex, goalId, description,
-                collect({id: ac.id, action: ac.action, status: ac.status, weekIndex: ac.weekIndex}) AS cells
-         ORDER BY pillarIndex ASC LIMIT toInteger(8)`
-      : `MATCH (gp:GoalPillar {companyId: $cid})
-         WITH gp.id AS id, gp.name AS name, gp.pillarIndex AS pillarIndex,
-              gp.goalId AS goalId, gp.description AS description, gp AS gpNode
-         OPTIONAL MATCH (gpNode)-[:HAS_CELL]->(ac:ActionCell)
-         RETURN id, name, pillarIndex, goalId, description,
-                collect({id: ac.id, action: ac.action, status: ac.status, weekIndex: ac.weekIndex}) AS cells
+    const pillarQuery = goalId
+      ? `MATCH (gp:GoalPillar {companyId: $cid, goalId: $goalId})
+         WITH gp.id AS id, gp.name AS name, gp.pillarIndex AS pillarIndex,
+              gp.goalId AS goalId, gp.description AS description,
+              coalesce(gp.l2ReviewStatus, null) AS l2ReviewStatus,
+              coalesce(gp.l2Strategy, null) AS l2Strategy,
+              gp AS gpNode
+         OPTIONAL MATCH (gpNode)-[:HAS_CELL]->(ac:ActionCell)
+         OPTIONAL MATCH (gpNode)<-[:FOR_PILLAR]-(approval:Approval)
+           WHERE approval.type IN ['harada_l2_review','harada_l3_review'] AND approval.status = 'pending'
+         WITH id, name, pillarIndex, goalId, description, l2ReviewStatus, l2Strategy, gpNode,
+              collect(DISTINCT {id: ac.id, description: ac.description, status: ac.status, cellIndex: ac.cellIndex}) AS cells,
+              count(DISTINCT approval) AS openReviewCount
+         WITH id, name, pillarIndex, goalId, description, l2ReviewStatus, l2Strategy, cells, openReviewCount,
+              size(cells) AS cellCount,
+              reduce(acc = 0, c IN cells | acc + CASE WHEN c.status = 'closed' THEN 1 ELSE 0 END) AS closedCellCount
+         RETURN id, name, pillarIndex, goalId, description, l2ReviewStatus, l2Strategy,
+                cells, openReviewCount, cellCount, closedCellCount
+         ORDER BY pillarIndex ASC LIMIT toInteger(8)`
+      : `MATCH (gp:GoalPillar {companyId: $cid})
+         WITH gp.id AS id, gp.name AS name, gp.pillarIndex AS pillarIndex,
+              gp.goalId AS goalId, gp.description AS description,
+              coalesce(gp.l2ReviewStatus, null) AS l2ReviewStatus,
+              coalesce(gp.l2Strategy, null) AS l2Strategy,
+              gp AS gpNode
+         OPTIONAL MATCH (gpNode)-[:HAS_CELL]->(ac:ActionCell)
+         OPTIONAL MATCH (gpNode)<-[:FOR_PILLAR]-(approval:Approval)
+           WHERE approval.type IN ['harada_l2_review','harada_l3_review'] AND approval.status = 'pending'
+         WITH id, name, pillarIndex, goalId, description, l2ReviewStatus, l2Strategy, gpNode,
+              collect(DISTINCT {id: ac.id, description: ac.description, status: ac.status, cellIndex: ac.cellIndex}) AS cells,
+              count(DISTINCT approval) AS openReviewCount
+         WITH id, name, pillarIndex, goalId, description, l2ReviewStatus, l2Strategy, cells, openReviewCount,
+              size(cells) AS cellCount,
+              reduce(acc = 0, c IN cells | acc + CASE WHEN c.status = 'closed' THEN 1 ELSE 0 END) AS closedCellCount
+         RETURN id, name, pillarIndex, goalId, description, l2ReviewStatus, l2Strategy,
+                cells, openReviewCount, cellCount, closedCellCount
          ORDER BY pillarIndex ASC LIMIT toInteger(8)`;
 
     const saQuery = agentId
@@ -715,7 +738,20 @@ async function handleGetMandala(req, res, ctx) {
       mgQuery(deptAgentQuery, { cid }).catch(() => ({ rows: [], keys: [] })),
     ]);
 
-    const pillarKeys = ['id', 'name', 'pillarIndex', 'goalId', 'description', 'cells'];
+    // Map pillar names to department slugs — GoalPillar nodes never have a .department
+    // property written to them, so we derive the slug from the pillar's canonical name.
+    const PILLAR_NAME_TO_DEPT_SLUG = {
+      'Revenue & Sales':              'sales',
+      'Product & Delivery':           'engineering',
+      'Customer Success':             'customer_success',
+      'Technology & Infrastructure':  'engineering',
+      'Team & Capability':            'people',
+      'Brand & Positioning':          'marketing',
+      'Finance & Sustainability':     'finance',
+      'Operations & Process':         'operations',
+    };
+
+    const pillarKeys = ['id', 'name', 'pillarIndex', 'goalId', 'description', 'l2ReviewStatus', 'l2Strategy', 'cells', 'openReviewCount', 'cellCount', 'closedCellCount'];
     const saKeys = ['id', 'agentId', 'strengths', 'weaknesses', 'opportunities', 'createdAt'];
     const cascadeKeys = ['id', 'agentId', 'weekNumber', 'weeklyGoal', 'dailyTasks', 'completionRate'];
     const deptAgentKeys = ['id', 'role', 'departmentId', 'status', 'currentTaskId', 'currentTask', 'taskStartedAt'];
@@ -733,7 +769,13 @@ async function handleGetMandala(req, res, ctx) {
     });
 
     jsonOk(res, {
-      pillars:      parseRows(pillarResult).map(r => rowToObj(r, pillarKeys)),
+      pillars:      parseRows(pillarResult).map(r => {
+        const p = rowToObj(r, pillarKeys);
+        // Derive department slug from pillar name so the frontend can build dept nav items.
+        // GoalPillar.department is indexed in the schema but never written by any daemon path.
+        p.department = PILLAR_NAME_TO_DEPT_SLUG[p.name] || null;
+        return p;
+      }),
       selfAnalysis: parseRows(selfAnalysisResult).map(r => rowToObj(r, saKeys)),
       cascades:     parseRows(cascadeResult).map(r => rowToObj(r, cascadeKeys)),
       deptAgents,   // live BusinessAgent + Task join for DepartmentPage TeamTab
@@ -1172,13 +1214,20 @@ async function handleCreatePdsa(req, res, ctx) {
     // in every department's decisions tab regardless of which pillar they belong to.
     // Task.pillarId is set by pillar-dispatcher.js when a task is dispatched to a pillar.
     try {
-      const taskRows = await mgQuery(
-        `MATCH (t:Task {id: $taskId, companyId: $cid}) RETURN t.pillarId AS pillarId LIMIT 1`,
-        { taskId: taskId.trim(), cid }
-      );
-      const pillarId = taskRows && taskRows.rows && taskRows.rows[0]
-        ? (Array.isArray(taskRows.rows[0]) ? taskRows.rows[0][0] : taskRows.rows[0].pillarId)
-        : null;
+      // SQLite-first task read for pillarId (P2-10)
+      let pillarId = null;
+      const _storeTask = hboStore.getTask ? hboStore.getTask(taskId.trim(), cid) : null;
+      if (_storeTask) {
+        pillarId = _storeTask.pillarId ?? null;
+      } else {
+        const taskRows = await mgQuery(
+          `MATCH (t:Task {id: $taskId, companyId: $cid}) RETURN t.pillarId AS pillarId LIMIT 1`,
+          { taskId: taskId.trim(), cid }
+        );
+        pillarId = taskRows && taskRows.rows && taskRows.rows[0]
+          ? (Array.isArray(taskRows.rows[0]) ? taskRows.rows[0][0] : taskRows.rows[0].pillarId)
+          : null;
+      }
       if (pillarId && typeof pillarId === 'string' && pillarId.trim()) {
         await mgQuery(
           `MATCH (p:PDSACycle {id: $id, companyId: $cid}) SET p.pillarId = $pillarId`,
@@ -2126,6 +2175,7 @@ async function handleResolveEmailInfraApproval(req, res, ctx, approvalId) {
  */
 async function handleGetHboApprovals(req, res, ctx) {
   try {
+    if (!ctx.mgQuery) { jsonErr(res, 503, 'Memgraph not connected'); return; }
     const url = new URL(req.url, 'http://localhost');
     const status = url.searchParams.get('status') || null;
     const type   = url.searchParams.get('type')   || null;
@@ -2149,6 +2199,17 @@ async function handleGetHboApprovals(req, res, ctx) {
         agentId: p?.agentId ?? null, taskId: p?.taskId ?? null,
         urgency: p?.urgency ?? null, humanAnswer: p?.humanAnswer ?? null,
         answeredVia: p?.answeredVia ?? null, createdAt: p?.createdAt ?? null,
+        description: p?.description ?? null,
+        question: p?.question ?? null,
+        defaultAnswer: p?.defaultAnswer ?? null,
+        ruleStrength: p?.ruleStrength ?? null,
+        sourceAgent: p?.sourceAgent ?? null,
+        pillarId: p?.pillarId ?? null,
+        expiresAt: p?.expiresAt ?? null,
+        kaizenProposalId: p?.kaizenProposalId ?? null,
+        department: p?.department ?? null,
+        templateKey: p?.templateKey ?? null,
+        inferredAnswer: p?.inferredAnswer ?? null,
       };
     });
     jsonOk(res, { approvals, count: approvals.length });
@@ -2338,14 +2399,14 @@ async function handleGetTriageSummary(req, res, ctx) {
       { cid }
     );
     const rows = parseRows(result);
-    const counts = { p0: 0, p1: 0, p2: 0, p3: 0, total: 0 };
+    const counts = { p0Count: 0, p1Count: 0, p2Count: 0, p3Count: 0, total: 0, topItems: [], generatedAt: new Date().toISOString() };
     for (const row of rows) {
       const pri = (row[0] ?? row['priority'] ?? '').toString().toUpperCase();
       const cnt = Number(row[1] ?? row['cnt'] ?? 0);
-      if (pri === 'P0') counts.p0 = cnt;
-      else if (pri === 'P1') counts.p1 = cnt;
-      else if (pri === 'P2') counts.p2 = cnt;
-      else if (pri === 'P3') counts.p3 = cnt;
+      if (pri === 'P0') counts.p0Count = cnt;
+      else if (pri === 'P1') counts.p1Count = cnt;
+      else if (pri === 'P2') counts.p2Count = cnt;
+      else if (pri === 'P3') counts.p3Count = cnt;
       counts.total += cnt;
     }
     jsonOk(res, counts);

package/daemon/routes/project.js

@@ -551,13 +551,14 @@ module.exports = function createProjectRoute({ mgQuery, broadcast, invalidateCon
     const { answer, answeredBy } = body;
     if (!answer) return jsonErr(res, 400, 'answer required', req);
     try {
-      await mgQuery(
+      const mgResult = await mgQuery(
         `MATCH (q:ProjectQuestion {id: $qid, projectId: $projId, companyId: $cid})
-         SET q.answer=$answer, q.answeredBy=$by, q.answeredAt=datetime(), q.status='answered'`,
+         SET q.answer=$answer, q.answeredBy=$by, q.answeredAt=datetime(), q.status='answered'
+         RETURN count(q) AS updated`,
         { qid, projId: projectId, cid: ctx?.cid || "", answer: String(answer), by: answeredBy || null }
       );
       // D2: if no row matched, task not found for this company
-      const _updated = taskResult?.rows?.[0]?.[0] ?? taskResult?.rows?.[0]?.updated ?? 0;
+      const _updated = mgResult?.rows?.[0]?.[0] ?? mgResult?.rows?.[0]?.updated ?? 0;
       if (!Number(_updated)) return jsonErr(res, 404, "Task not found for this company", req);
       jsonOk(res, { ok: true }, req);
     } catch (e) {

package/daemon/routes/wizard.js

@@ -184,9 +184,16 @@ async function handlePostWizard(req, res, ctx) {
         }
       }
 
-      // BUG-21 fix: fire tickGoalSync immediately after wizard completes so the
-      // first AgentReadySignal dispatch happens within the current tick (~30s)
-      // instead of waiting up to 2.5 min (5 ticks × 30s) for the next goal sync cycle.
+      // tickGoalDecompose (creates GoalPillar × 8) and wizard:pillars_ready broadcast are
+      // now handled in helios-company-daemon.js registerCompany(), which runs after the
+      // desktop calls POST /api/daemon/register-company. That is the correct point because:
+      //   (a) _modulesByCompany is guaranteed to have this company's entry
+      //   (b) daemon._broadcast is wired before setBroadcast() is called
+      //   (c) No race with the setImmediate firing before registerCompany completes
+      //
+      // tickGoalSync bridges any BusinessTask→Task nodes created by the wizard (CEO task).
+      // It still runs here because it needs to fire as soon as possible after wizard:done,
+      // not after the desktop round-trip to /api/daemon/register-company.
       if (result.companyId && ctx.daemon?._modulesByCompany) {
         setImmediate(async () => {
           try {
@@ -194,7 +201,7 @@ async function handlePostWizard(req, res, ctx) {
             if (mods?.hboBridge?.tickGoalSync) {
               await mods.hboBridge.tickGoalSync();
             }
-          } catch (_) { /* non-fatal — tickGoalSync will fire on next cycle */ }
+          } catch (_) { /* non-fatal */ }
         });
       }
 

package/extensions/context-compaction.ts

@@ -345,35 +345,55 @@ export default function contextCompaction(pi: ExtensionAPI): void {
         metrics.compactionTriggered++;
         metrics.lastCompactionAt = Date.now();
 
-        // ── Headroom compression (L1 + L2 replacement) ────────────────────────
-        // Uses the local Headroom proxy (SmartCrusher + IntelligentContext + CCR)
-        // instead of the hand-rolled L1 tool-result clearing and L2 extractive
-        // summarization. Headroom's content-routing selects the right compressor
-        // per content type (JSON arrays → SmartCrusher, prose → Kompress-base).
-        // CCR stores originals locally so the agent can retrieve them on demand.
+        // ── Helios Compression (L1 + L2 replacement) ────────────────────────
+        // Calls the Helios Compression Server (lib/compression/server.ts) via
+        // HTTP. The server runs as a sidecar process managed by HeadroomProxyManager.
+        // Its URL is injected into the Pi subprocess env as HEADROOM_PROXY_URL.
         //
-        // This fires on the same threshold as the old L1/L2 — no behaviour change
-        // for users, but compression quality is dramatically better:
-        //   - SmartCrusher preserves statistical distribution (30% start, 55%
-        //     importance-scored, 15% end) and always keeps errors/anomalies.
-        //   - IntelligentContext scores on 6 dimensions instead of oldest-first.
-        //   - CacheAligner stabilizes Bedrock KV-cache prefix on every call.
+        // No npm package required — uses Node's built-in http module.
+        // Works identically on Windows and macOS (the server is pure TypeScript).
+        //
+        // SmartCrusher preserves statistical distribution:
+        //   Lossless: CSV format for homogeneous arrays (51–84% savings)
+        //   Lossy:    30% start + 55% importance-scored + 15% end kept;
+        //             dropped rows stored in CCR and retrievable on demand.
         let headroomApplied = false;
         let headroomTokensSaved = 0;
 
         try {
-          // Dynamic import — headroom-ai is a regular npm dep, not a Pi module.
-          // eslint-disable-next-line @typescript-eslint/no-require-imports
-          const headroomAi = require('headroom-ai');
-          // eslint-disable-next-line @typescript-eslint/no-require-imports
-          const { HeadroomProxyManager } = require('../daemon/lib/headroom-proxy-manager');
-          const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-
-          if (baseUrl && headroomAi?.compress) {
-            const result = await headroomAi.compress(messages, {
-              model: modelId || 'claude',
-              baseUrl,
-              tokenBudget: compactionThreshold,
+          const baseUrl = process.env.HEADROOM_PROXY_URL || process.env.ANTHROPIC_BASE_URL;
+          if (baseUrl && baseUrl.includes('127.0.0.1')) {
+            // POST /headroom/compress with the current messages
+            const payload = JSON.stringify({ messages });
+            const result: any = await new Promise((resolve, reject) => {
+              // eslint-disable-next-line @typescript-eslint/no-var-requires
+              const http = require('http');
+              const url = new URL('/headroom/compress', baseUrl);
+              const req = http.request(
+                {
+                  hostname: url.hostname,
+                  port: parseInt(url.port || '8787', 10),
+                  path: '/headroom/compress',
+                  method: 'POST',
+                  headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(payload),
+                  },
+                },
+                (res: any) => {
+                  let body = '';
+                  res.on('data', (c: Buffer) => { body += c; });
+                  res.on('end', () => {
+                    try { resolve(JSON.parse(body)); }
+                    catch { reject(new Error('Invalid JSON from compression server')); }
+                  });
+                  res.on('error', reject);
+                }
+              );
+              req.setTimeout(5000, () => { req.destroy(); reject(new Error('Compression server timeout')); });
+              req.on('error', reject);
+              req.write(payload);
+              req.end();
             });
 
             if (result?.messages?.length) {
@@ -403,8 +423,7 @@ export default function contextCompaction(pi: ExtensionAPI): void {
             }
           }
         } catch (hrErr) {
-          // Headroom compress failed — this should not happen if the proxy is running.
-          // Log prominently and fall through to legacy L1 below.
+          // Headroom compress failed — log and fall through to legacy L1.
           process.stderr.write(
             `[context-compaction] ⚠️  Headroom compress error: ${String(hrErr)}\n` +
             `[context-compaction] Falling back to legacy L1 tool result clearing.\n`

package/extensions/cortex/activation-bridge.ts

@@ -230,6 +230,11 @@ export async function spreadActivation(
   initialActivation: EnrichedActivation,
   graphClient?: { safeRead: (q: string, p?: any) => Promise<any[]> } | null,
 ): Promise<EnrichedActivation> {
+  const { isMemgraphAvailable } = require('../../lib/graph-availability');
+  if (!isMemgraphAvailable()) {
+    process.stderr.write('[cortex:activation-bridge] Memgraph unavailable — skipping activation spread\n');
+    return {};
+  }
   if (!initialActivation.concepts.length) return initialActivation;
 
   const mg = graphClient !== undefined ? graphClient : getDefaultMg();

package/extensions/cortex/learn.ts

@@ -154,6 +154,32 @@ try {
   }
 } catch (err) { /* fail-open: WAL module init */ if (process.env.HELIOS_DEBUG) console.error(`[cortex-learn] WAL init error: ${String(err)}`); }
 
+// Register availability listener so cortex WAL replays automatically
+// when Memgraph comes back up after a period of unavailability (P4-2).
+// _walReplayInProgress guard prevents concurrent replays racing on the journal
+// file when Memgraph flaps rapidly (F13).
+let _walReplayInProgress = false;
+try {
+  const { onAvailabilityChange } = require('../../lib/graph-availability');
+  onAvailabilityChange((available: boolean) => {
+    if (!available || _walReplayInProgress) return;
+    _walReplayInProgress = true;
+    // Fire-and-forget: WAL replay runs in background, never blocks dispatch
+    import('./wal-replay').then(({ replayCortexWal }) => {
+      replayCortexWal()
+        .catch((e: unknown) =>
+          process.stderr.write(`[cortex-learn] WAL replay failed: ${String(e)}\n`)
+        )
+        .finally(() => { _walReplayInProgress = false; });
+    }).catch(() => {
+      // wal-replay not available (e.g. pre-build) — silently skip
+      _walReplayInProgress = false;
+    });
+  });
+} catch (_) {
+  // graph-availability not available — WAL replay disabled
+}
+
 function _persistCoherenceCounts(): void {
   try {
     const obj: Record<string, number> = {};

package/extensions/helios-governance/gates/high-impact.ts

@@ -11,7 +11,7 @@ const HIGH_IMPACT_SHARED_BRANCHES = /\b(main|master|dev|development|staging|stag
 const HIGH_IMPACT_GIT_OPS = /\b(cherry.?pick|git\s+push|force.?push|git\s+merge|merge\s+(?:to|into)\s+|push\s+to\s+(?:origin|remote|upstream)|git\s+rebase|git\s+reset\s+--hard)\b/i;
 const HIGH_IMPACT_AUTH_CRYPTO = /\b(?:auth|crypto|session|oauth|jwt|encrypt|decrypt|secret|cipher|password)\.(ts|js|tsx|jsx)\b|(?:session|token|secret|password|credential|encrypt|decrypt|hash|cipher|jwt|oauth)\s+(?:file|module|key|management)/i;
 const HIGH_IMPACT_INFRA = /\b(?:(?:run|apply|execute|deploy|push|revert|rollback|sync)\s+migration|schema\s+change|drop\s+table|alter\s+table|environment\s+variable|aws\s+ssm|amplify\s+deploy|\.env\b)\b/i;
-const HIGH_IMPACT_RUNTIME_UPGRADE = /\b(npm\s+install|npm\s+i|npm\s+update|npm\s+up)\b.*(pi-coding-agent|@mariozechner\/pi|@helios-agent\/pi)/i;
+const HIGH_IMPACT_RUNTIME_UPGRADE = /\b(npm\s+install|npm\s+i|npm\s+update|npm\s+up|pnpm\s+add|pnpm\s+install)\b.*(pi-coding-agent|@mariozechner\/pi|@helios-agent\/pi|@cgh567\/cli|@cgh567\/agent|@cgh567\/pi)/i;
 export const SHARED_INFRA_PATHS = /(?:~\/|\/Users\/\w+\/)?\.\.?pi\/agent\/(extensions|skills|agents)\//i;
 
 export function isHighImpactOperation(task: string): boolean {

package/extensions/helios-governance/handlers/_jiti-require.ts

@@ -28,15 +28,22 @@ import { homedir } from 'os';
 
 // Ordered list of jiti lib/jiti.cjs locations (lib/ not dist/ - dist requires module.createRequire which is unavailable in CJS context)
 const JITI_PATHS = [
+  // ── npm package layout (production: @cgh567/agent installed in node_modules) ──
+  // When helios-agent runs from node_modules/@cgh567/agent, jiti is provided by
+  // @cgh567/cli which is in the same scope. Walk up to workspace root node_modules.
+  // Resolve relative to __dirname (this file's location in extensions/helios-governance/handlers/)
+  // node_modules/@cgh567/agent/extensions/helios-governance/handlers/ -> up 6 levels -> workspace root
+  join(__dirname, '..', '..', '..', '..', '..', '..', 'node_modules', '@mariozechner', 'jiti', 'lib', 'jiti.cjs'),
+  // @cgh567/cli bundles jiti under its own node_modules
+  join(__dirname, '..', '..', '..', '..', '..', '..', 'node_modules', '@cgh567', 'cli', 'node_modules', '@mariozechner', 'jiti', 'lib', 'jiti.cjs'),
+  // ── local clone layout (dev: ~/Desktop/Helios/helios-agent-main) ──
+  join(homedir(), 'Desktop', 'Helios', 'helios-agent-main', 'node_modules', '@mariozechner', 'jiti', 'lib', 'jiti.cjs'),
+  join(homedir(), 'helios-agent-main', 'node_modules', '@mariozechner', 'jiti', 'lib', 'jiti.cjs'),
   join(homedir(), 'helios-agent', 'node_modules', '@mariozechner', 'jiti', 'lib', 'jiti.cjs'),
-  join(homedir(), 'helios-agent', 'node_modules', '@helios-agent', 'pi-coding-agent', 'node_modules', 'jiti', 'lib', 'jiti.cjs'),
-  join(homedir(), 'helios-agent', 'node_modules', '@earendil-works', 'pi-coding-agent', 'node_modules', 'jiti', 'lib', 'jiti.cjs'),
-  join(process.env.NVM_DIR || join(homedir(), '.nvm'),
-    'versions', 'node', process.version, 'lib', 'node_modules',
-    '@helios-agent', 'pi-coding-agent', 'node_modules', 'jiti', 'lib', 'jiti.cjs'),
-  join(process.env.NVM_DIR || join(homedir(), '.nvm'),
-    'versions', 'node', process.version, 'lib', 'node_modules',
-    '@earendil-works', 'pi-coding-agent', 'node_modules', 'jiti', 'lib', 'jiti.cjs'),
+  // ── HELIOS_ROOT env var override ──
+  ...(process.env.HELIOS_ROOT
+    ? [join(process.env.HELIOS_ROOT, 'node_modules', '@mariozechner', 'jiti', 'lib', 'jiti.cjs')]
+    : []),
 ];
 
 /** Module-level jiti instance cache: callerFile → jiti fn */

package/extensions/hema-dispatch-v3/graph-memory.ts

@@ -23,6 +23,11 @@ export async function queryGraphMemories(
   taskText: string,
   limit: number = 10
 ): Promise<GraphMemoryResult[]> {
+  const { isMemgraphAvailable } = require('../../lib/graph-availability');
+  if (!isMemgraphAvailable()) {
+    process.stderr.write('[hema:graph-memory] Memgraph unavailable — skipping graph memory recall\n');
+    return [];
+  }
   try {
     const mg = require('../../lib/safe-memgraph.js');
     
@@ -102,6 +107,11 @@ export async function queryCausalLessons(
   taskText: string,
   limit: number = 5
 ): Promise<GraphMemoryResult[]> {
+  const { isMemgraphAvailable } = require('../../lib/graph-availability');
+  if (!isMemgraphAvailable()) {
+    process.stderr.write('[hema:graph-memory] Memgraph unavailable — skipping causal lesson recall\n');
+    return [];
+  }
   try {
     const mg = require('../../lib/safe-memgraph.js');
     

package/extensions/hema-dispatch-v3/index.ts

@@ -1507,48 +1507,67 @@ export default function hemaDispatchV3(pi: any): void {
             logHemaEvent('hema_no_context', { nativePacksUsed, legacyUsed: admitted.admitted?.length > 0 });
           }
 
-          // ── Headroom: compress HEMA recall payload before injection ──────────
-          // The recall context injected into every subagent call is dominated by
-          // JSON graph payloads (leads, signals, tasks, goals, code nodes).
-          // SmartCrusher compresses these at 70–90%, preserving errors/anomalies
-          // and statistical distribution (30% start / 55% importance / 15% end).
-          // This reduces injection cost for all roles and all companies.
-          if (enrichedTask.length > 2000) { // only compress if there's meaningful context
-            try {
-              // eslint-disable-next-line @typescript-eslint/no-require-imports
-              const headroomAi = require('headroom-ai');
-              // eslint-disable-next-line @typescript-eslint/no-require-imports
-              const { HeadroomProxyManager } = require('../../daemon/lib/headroom-proxy-manager');
-              const _hrUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-              if (_hrUrl && headroomAi?.compress) {
-                const _hrResult = await headroomAi.compress(
-                  [{ role: 'user', content: [{ type: 'text', text: enrichedTask }] }],
-                  {
-                    model: 'claude',
-                    baseUrl: _hrUrl,
-                    // Use role injection budget as the token budget
-                    tokenBudget: agentType === 'planner' ? 8000
-                      : agentType === 'orchestrator' ? 10000
-                      : agentType === 'worker' ? 6000
-                      : agentType === 'scout' ? 3000
-                      : 6000,
-                  }
-                );
-                if (_hrResult?.messages?.[0]?.content) {
-                  const _compressed = typeof _hrResult.messages[0].content === 'string'
-                    ? _hrResult.messages[0].content
-                    : _hrResult.messages[0].content?.[0]?.text ?? enrichedTask;
-                  if (_compressed.length < enrichedTask.length) {
-                    const _saved = enrichedTask.length - _compressed.length;
-                    process.stderr.write(`[hema-dispatch-v3] Headroom compressed recall context: -${_saved} chars (${agentType})\n`);
-                    enrichedTask = _compressed;
-                    logHemaEvent('hema_headroom_compressed', { saved: _saved, agentType });
-                  }
+          // ── Helios Compression: compress HEMA recall payload before injection ──
+          // The recall context contains JSON graph payloads (leads, signals, tasks,
+          // goals, code nodes). Send the assembled text as a tool_result block to
+          // the compression server — it will find and compress embedded JSON arrays.
+          //
+          // Uses direct HTTP to HEADROOM_PROXY_URL (same pattern as context-compaction.ts)
+          // rather than the headroom-ai npm package so this works in Pi subprocess context.
+          // Applies to all companies: the role injection budgets enforce per-agent limits.
+          if (enrichedTask.length > 2000) {
+            const _hrUrl = process.env.HEADROOM_PROXY_URL;
+            if (_hrUrl) {
+              try {
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const http = require('http');
+                const _payload = JSON.stringify({
+                  messages: [{
+                    role: 'user',
+                    content: [{
+                      type: 'tool_result',
+                      tool_use_id: 'hema_recall',
+                      content: enrichedTask,
+                    }],
+                  }],
+                });
+                const _result: any = await new Promise((resolve, reject) => {
+                  const _url = new URL('/headroom/compress', _hrUrl);
+                  const _req = http.request(
+                    {
+                      hostname: _url.hostname,
+                      port: parseInt(_url.port || '8787', 10),
+                      path: '/headroom/compress',
+                      method: 'POST',
+                      headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(_payload),
+                      },
+                    },
+                    (res: any) => {
+                      let body = '';
+                      res.on('data', (c: Buffer) => { body += c; });
+                      res.on('end', () => { try { resolve(JSON.parse(body)); } catch { reject(new Error('bad json')); } });
+                      res.on('error', reject);
+                    }
+                  );
+                  _req.setTimeout(3000, () => { _req.destroy(); reject(new Error('timeout')); });
+                  _req.on('error', reject);
+                  _req.write(_payload);
+                  _req.end();
+                });
+
+                const _compressed = _result?.messages?.[0]?.content?.[0]?.content ?? enrichedTask;
+                if (typeof _compressed === 'string' && _compressed.length < enrichedTask.length) {
+                  const _saved = enrichedTask.length - _compressed.length;
+                  process.stderr.write(`[hema-dispatch-v3] Headroom compressed recall context: -${_saved} chars (${agentType})\n`);
+                  enrichedTask = _compressed;
+                  logHemaEvent('hema_headroom_compressed', { saved: _saved, agentType });
                 }
+              } catch (_hrErr: any) {
+                // Non-fatal: log and continue with uncompressed enrichedTask
+                process.stderr.write(`[hema-dispatch-v3] Headroom recall compress skipped: ${_hrErr?.message}\n`);
               }
-            } catch (_hrErr: any) {
-              // Non-fatal: log and continue with uncompressed enrichedTask
-              process.stderr.write(`[hema-dispatch-v3] Headroom recall compress failed (non-fatal): ${_hrErr?.message}\n`);
             }
           }
 

package/extensions/memgraph-autostart.ts

@@ -23,6 +23,17 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const QUIET = process.env.PI_QUIET === '1' || process.env.PI_LOG_LEVEL === 'error';
 
+// Graph availability singleton — updated whenever Memgraph comes up or goes down
+let _graphAvailability: { setMemgraphAvailable: (v: boolean) => void } | null = null;
+function getGraphAvailability() {
+  if (!_graphAvailability) {
+    try {
+      _graphAvailability = require('../lib/graph-availability');
+    } catch (_) {}
+  }
+  return _graphAvailability;
+}
+
 // ── Event emission helpers ───────────────────────────────────────────────────
 
 /** Load MAGE query modules after Bolt becomes reachable.
@@ -109,6 +120,7 @@ function emitMemgraphReady(log: (msg: string) => void): void {
     bus.emit('memgraph_ready', payload);
   } catch (e) { process.stderr.write(`[extensions] non-fatal if bus unavailable: ${String(e)}\n`); }
   log(`[memgraph-autostart] Memgraph ready — bolt reachable at ${BOLT_HOST}:${BOLT_PORT}`);
+  getGraphAvailability()?.setMemgraphAvailable(true);
 }
 
 /**
@@ -185,6 +197,7 @@ function emitMemgraphDegraded(log: (msg: string) => void, reason: string): void
   try {
     bus.emit('memgraph_degraded', payload);
   } catch (e) { process.stderr.write(`[extensions] non-fatal: ${String(e)}\n`); }
+  getGraphAvailability()?.setMemgraphAvailable(false);
 }
 
 /** Returns true if Memgraph bolt was confirmed reachable during this session. */