@cgh567/agent 2.4.1 → 2.4.3

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/cortex/wal-replay.ts

@@ -0,0 +1,91 @@
+/**
+ * extensions/cortex/wal-replay.ts
+ *
+ * Auto-replay cortex WAL entries when Memgraph becomes available.
+ * Called by learn.ts on the memgraph:available event (P4-2).
+ *
+ * Reads cortex-write-journal.jsonl, replays each entry via rawWrite,
+ * removes successfully replayed entries atomically (temp file + rename).
+ *
+ * Uses extensions/lib/helios-root (same module as learn.ts) to ensure
+ * the journal path resolves identically in both files.
+ */
+import * as fs from 'fs';
+
+// Re-use the same path derivation as learn.ts.
+// MUST use '../lib/helios-root' (extensions/lib/helios-root), NOT
+// '../../lib/helios-root' (lib/helios-root) — different fallback strategies.
+const { heliosPath } = require('../lib/helios-root');
+const WRITE_JOURNAL_PATH: string = heliosPath('sessions', 'cortex-write-journal.jsonl');
+
+interface WalEntry {
+  cypher: string;
+  params: Record<string, unknown>;
+  timestamp?: number;
+}
+
+function readJournalEntries(): WalEntry[] {
+  if (!fs.existsSync(WRITE_JOURNAL_PATH)) return [];
+  try {
+    const lines = fs.readFileSync(WRITE_JOURNAL_PATH, 'utf8')
+      .split('\n')
+      .filter(Boolean);
+    return lines.map(line => {
+      try { return JSON.parse(line) as WalEntry; } catch { return null; }
+    }).filter((e): e is WalEntry => e !== null && typeof e.cypher === 'string');
+  } catch (e) {
+    process.stderr.write(`[cortex-wal-replay] failed to read journal: ${String(e)}\n`);
+    return [];
+  }
+}
+
+function writeJournalEntries(entries: WalEntry[]): void {
+  const tmp = WRITE_JOURNAL_PATH + '.tmp';
+  try {
+    fs.writeFileSync(tmp, entries.map(e => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : ''), 'utf8');
+    fs.renameSync(tmp, WRITE_JOURNAL_PATH);
+  } catch (e) {
+    process.stderr.write(`[cortex-wal-replay] failed to write journal: ${String(e)}\n`);
+    try { fs.unlinkSync(tmp); } catch {}
+  }
+}
+
+export async function replayCortexWal(): Promise<void> {
+  const entries = readJournalEntries();
+  if (entries.length === 0) return;
+
+  let rawWrite: ((cypher: string, params: Record<string, unknown>) => Promise<unknown>) | null = null;
+  try {
+    const mg = require('../../lib/safe-memgraph');
+    rawWrite = mg.rawWrite ?? mg.safeWrite ?? null;
+  } catch (e) {
+    process.stderr.write(`[cortex-wal-replay] failed to load safe-memgraph: ${String(e)}\n`);
+    return;
+  }
+
+  if (!rawWrite) {
+    process.stderr.write('[cortex-wal-replay] rawWrite not available — skipping replay\n');
+    return;
+  }
+
+  const remaining: WalEntry[] = [];
+  let replayed = 0;
+  let failed = 0;
+
+  for (const entry of entries) {
+    try {
+      await rawWrite(entry.cypher, entry.params ?? {});
+      replayed++;
+    } catch (e) {
+      failed++;
+      remaining.push(entry);
+      process.stderr.write(`[cortex-wal-replay] entry replay failed (kept in journal): ${String(e)}\n`);
+    }
+  }
+
+  writeJournalEntries(remaining);
+
+  process.stderr.write(
+    `[cortex-wal-replay] Replayed ${replayed} / ${entries.length} entries. ${failed} failed (left in journal).\n`
+  );
+}

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

@@ -682,15 +682,20 @@ export default function hemaDispatchV3(pi: any): void {
     } catch (_) { process.stderr.write(`[hema:catch] fail-open: graceful degradation: ${(_ as Error)?.message || _}\n`); } // HeliosRuntime may not be initialized — fail-open
 
     // ═══ TASK-13: Budget Pre-Admission Gate ═══
-    // Reads ~/helios-agent/brainv2/budget-status.json (written by GraphSyncService).
+    // MT-02: Path resolves from HELIOS_ROOT env var (required). If unset, daemon logs a startup error.
+    // budget-status.json is written by GraphSyncService at $HELIOS_ROOT/brainv2/budget-status.json.
     // Fail-open: if file missing or unreadable, proceed normally.
     // blocked=true  → hard block, return early with ⛔ message
     // warningActive → inject budget warning into agent context (soft signal)
     let _budgetStatus: { blocked?: boolean; warningActive?: boolean; policies?: any[] } = {};
     let _budgetWarning: string | null = null;
     try {
-      const _budgetStatusPath = join(homedir(), 'helios-agent/brainv2/budget-status.json');
-      if (fs.existsSync(_budgetStatusPath)) {
+      const _heliosRoot = process.env['HELIOS_ROOT'];
+      if (!_heliosRoot) {
+        process.stderr.write('[hema] HELIOS_ROOT not set — budget-status.json cannot be read. Set HELIOS_ROOT to the helios-agent repo root.\n');
+      }
+      const _budgetStatusPath = _heliosRoot ? join(_heliosRoot, 'brainv2/budget-status.json') : null;
+      if (_budgetStatusPath && fs.existsSync(_budgetStatusPath)) {
         _budgetStatus = JSON.parse(fs.readFileSync(_budgetStatusPath, 'utf8'));
       }
     } catch (_budgetErr) {
@@ -1507,48 +1512,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`);
             }
           }
 
@@ -2657,9 +2681,10 @@ export default function hemaDispatchV3(pi: any): void {
       } catch (_) { process.stderr.write(`[hema:catch] fail-open: ${(_ as Error)?.message || _}\n`); }
 
       // Load hot memory — ensure file exists
-      const hotMemoryPath = join(homedir(), 'helios-agent', 'sessions', 'hot-memory.json');
+      const _heliosRootForMem = process.env['HELIOS_ROOT'] ?? join(homedir(), 'helios-agent');
+      const hotMemoryPath = join(_heliosRootForMem, 'sessions', 'hot-memory.json');
       if (!fs.existsSync(hotMemoryPath)) {
-        const sessDir = join(homedir(), 'helios-agent', 'sessions');
+        const sessDir = join(_heliosRootForMem, 'sessions');
         if (!fs.existsSync(sessDir)) fs.mkdirSync(sessDir, { recursive: true });
         fs.writeFileSync(hotMemoryPath, JSON.stringify({ sessions: [] }, null, 2), 'utf8');
       }
@@ -2687,7 +2712,7 @@ export default function hemaDispatchV3(pi: any): void {
         const pendingIds = [..._pendingDispatchIds.keys()];
         try {
           const _walSessionId = di('sessionId') || process.pid;
-        const walPath = join(homedir(), `helios-agent/sessions/.pending-dispatches-${_walSessionId}.json`);
+        const walPath = join(process.env['HELIOS_ROOT'] ?? join(homedir(), 'helios-agent'), `sessions/.pending-dispatches-${_walSessionId}.json`);
           fs.writeFileSync(walPath, JSON.stringify({ ids: pendingIds, timestamp: Date.now(), sessionId: di('sessionId') || 'unknown' }));
           process.stderr.write(`[hema] session_shutdown: wrote ${pendingIds.length} pending dispatch ID(s) to WAL\n`);
         } catch (e: any) {
@@ -3125,7 +3150,7 @@ export default function hemaDispatchV3(pi: any): void {
         return { systemPrompt: appendDynamic(event.systemPrompt, '\n' + evalContext) };
       }
 
-      const hotMemoryPath = join(homedir(), 'helios-agent', 'sessions', 'hot-memory.json');
+      const hotMemoryPath = join(process.env['HELIOS_ROOT'] ?? join(homedir(), 'helios-agent'), 'sessions', 'hot-memory.json');
 
       let hotMemory: any = null;
       if (fs.existsSync(hotMemoryPath)) {

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. */

package/extensions/warm-tick/warm-tick-maintenance.ts

@@ -713,6 +713,14 @@ export async function runScheduledMaintenance(): Promise<void> {
     }
   }
 
+  // SEC-5: Daily cleanup of expired DraftAction PII nodes (30-day TTL)
+  try {
+    const { rawWrite: _rawWrite } = require('../../lib/safe-memgraph.js');
+    await _rawWrite('MATCH (da:DraftAction) WHERE da.expiresAt < datetime() DETACH DELETE da', {});
+  } catch (err: any) {
+    console.warn('[warm-tick] DraftAction TTL cleanup failed:', err?.message || String(err));
+  }
+
   // Daily: incremental label backfill (ensures critical graph labels are never empty)
   try {
     const { runIncrementalBackfill } = await import('./warm-tick-backfill.js');