@arka-labs/nemesis 1.2.0

package/lib/kairos/event-router.js

@@ -0,0 +1,131 @@
+import { pushEvent } from './event-bus.js';
+import { verifyAgentAlive } from './pid-checker.js';
+import { readRegistry, getLanes } from '../core/registry.js';
+import { detectProject } from '../core/project.js';
+import { debug } from '../core/logger.js';
+
+/**
+ * Route an event to the target agent using PID-aware decision tree.
+ *
+ * Decision tree:
+ * 1. Agent in registry? No → failed
+ * 2. verifyAgentAlive(lane) → alive? Yes → pushEvent() (method: 'queued')
+ * 3. Agent dead + session_id → launchHeadless() with event prompt (method: 'direct')
+ * 4. No session_id → failed
+ *
+ * @param {string} projectRoot
+ * @param {object} event - { target_agent_id, event_type, payload, priority, ttl, source_agent_id }
+ * @returns {{ delivered: boolean, method: 'queued'|'direct'|'failed', detail: string }}
+ */
+export async function routeEvent(projectRoot, event) {
+  const project = detectProject(projectRoot);
+  if (!project) return { delivered: false, method: 'failed', detail: 'no_project' };
+
+  const reg = readRegistry(project.hcm_dir);
+  if (!reg) return { delivered: false, method: 'failed', detail: 'no_registry' };
+
+  const lanes = getLanes(reg);
+  const lane = lanes.find(l =>
+    l.id === event.target_agent_id || l.name === event.target_agent_id
+  );
+
+  // Step 1: Agent in registry?
+  if (!lane) {
+    return { delivered: false, method: 'failed', detail: `agent_not_found: ${event.target_agent_id}` };
+  }
+
+  // Step 2: Agent alive? → queue event
+  const { alive } = verifyAgentAlive(lane);
+  if (alive) {
+    pushEvent(projectRoot, event);
+    return { delivered: true, method: 'queued', detail: `queued for PID ${lane.pid}` };
+  }
+
+  // Step 3: Agent dead but has session_id → launch headless with event prompt
+  if (lane.session_id) {
+    try {
+      const { launchHeadless } = await import('./agent-runner.js');
+      const prompt = buildEventPrompt(event);
+      const txnId = `EVT-ROUTE-${Date.now()}`;
+      const { pid } = await launchHeadless(
+        { name: lane.name || lane.id, session_id: lane.session_id },
+        prompt,
+        { txnId, root: projectRoot },
+      );
+      return { delivered: true, method: 'direct', detail: `launched PID ${pid}` };
+    } catch (err) {
+      // Fallback: queue it anyway — agent may resume later
+      pushEvent(projectRoot, event);
+      return { delivered: true, method: 'queued', detail: `direct_failed: ${err.message}, queued as fallback` };
+    }
+  }
+
+  // Step 4: No session_id
+  return { delivered: false, method: 'failed', detail: 'no_session_id' };
+}
+
+/**
+ * Deliver an event directly to an alive agent by launching a headless prompt.
+ * Only called from CLI (nemesis kairos push), NOT from hooks (timeout < 5s).
+ *
+ * @param {string} projectRoot
+ * @param {object} lane - Registry lane
+ * @param {object} event - Event object
+ * @returns {{ delivered: boolean, pid: number|null }}
+ */
+export async function deliverDirect(projectRoot, lane, event) {
+  if (!lane.session_id) {
+    return { delivered: false, pid: null };
+  }
+
+  try {
+    const { launchHeadless } = await import('./agent-runner.js');
+    const prompt = buildEventPrompt(event);
+    const txnId = `EVT-DIRECT-${Date.now()}`;
+    const { pid } = await launchHeadless(
+      { name: lane.name || lane.id, session_id: lane.session_id },
+      prompt,
+      { txnId, root: projectRoot },
+    );
+    return { delivered: true, pid };
+  } catch (e) {
+    debug(`deliverDirect: ${e.message}`);
+    return { delivered: false, pid: null };
+  }
+}
+
+/**
+ * Build a prompt string from an event for headless injection.
+ * @param {object} event
+ * @returns {string}
+ */
+export function buildEventPrompt(event) {
+  const lines = [
+    `# Evenement Kairos : ${event.event_type}`,
+    '',
+    `Priorite: ${event.priority || 'MEDIUM'}`,
+    `De: ${event.source_agent_id || 'system'}`,
+    `Date: ${event.created_at || new Date().toISOString()}`,
+  ];
+
+  if (event.payload) {
+    lines.push('', '## Payload');
+    if (event.payload.summary) lines.push(`Resume: ${event.payload.summary}`);
+    if (event.payload.odmId) lines.push(`OdM: ${event.payload.odmId}`);
+    if (event.payload.cr_id) lines.push(`CR: ${event.payload.cr_id}`);
+    if (event.payload.message) lines.push(`Message: ${event.payload.message}`);
+
+    // Dump remaining payload keys
+    const shown = new Set(['summary', 'odmId', 'cr_id', 'message']);
+    for (const [key, val] of Object.entries(event.payload)) {
+      if (!shown.has(key) && val !== undefined && val !== null) {
+        lines.push(`${key}: ${typeof val === 'object' ? JSON.stringify(val) : val}`);
+      }
+    }
+  }
+
+  lines.push('', '## Action requise');
+  lines.push('Traite cet evenement selon son type et sa priorite.');
+
+  return lines.join('\n');
+}

package/lib/kairos/flowmap-bridge.js

@@ -0,0 +1,120 @@
+/**
+ * Flowmap Bridge — map dispatch results to XState flowmap events.
+ * Connects the dispatcher classification to the mission state machine.
+ */
+
+import { debug } from '../core/logger.js';
+
+/**
+ * Signal patterns for automatic flowmap event detection.
+ * Each pattern has keywords and the flowmap event to fire.
+ */
+const SIGNAL_PATTERNS = [
+  {
+    id: 'deliver_odm',
+    keywords: ['cr depose', 'cr deposé', 'cr-odm', 'compte-rendu', 'livrable depose', 'livrable deposé'],
+    event: { type: 'DELIVER_ODM' },
+  },
+  {
+    id: 'complete_implementation',
+    keywords: ['implementation complete', 'implémentation complète', 'implementation terminee', 'tache terminee', 'tâche terminée', 'implementation done'],
+    event: { type: 'COMPLETE_IMPLEMENTATION' },
+  },
+  {
+    id: 'qa_fail',
+    keywords: ['rejet', 'rejete', 'non conforme', 'qa fail', 'qa ko', 'renvoi', 'non valide'],
+    requiresLeader: true,
+    event: { type: 'QA_VERDICT', verdict: 'FAIL' },
+  },
+  {
+    id: 'qa_pass',
+    keywords: ['valide', 'validation ok', 'qa ok', 'qa pass', 'conforme'],
+    requiresLeader: true,
+    event: { type: 'QA_VERDICT', verdict: 'PASS' },
+  },
+];
+
+/**
+ * Process a dispatch result and determine if a flowmap event should fire.
+ *
+ * @param {string} projectRoot
+ * @param {object} result - dispatch result { agentName, odmId, response, ... }
+ * @param {object} classification - routing entry { target, reason, summary, priority }
+ * @returns {{ event: object, signalId: string, missionId: string|null } | null}
+ */
+export function processDispatchResult(projectRoot, result, classification) {
+  if (!result || !classification) return null;
+  if (classification.target === 'NOISE') return null;
+
+  const text = [
+    result.response || '',
+    classification.reason || '',
+    classification.summary || '',
+  ].join(' ').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+  const isLeader = classification.target === 'LEADER';
+
+  for (const pattern of SIGNAL_PATTERNS) {
+    if (pattern.requiresLeader && !isLeader) continue;
+
+    const matched = pattern.keywords.some(kw => {
+      const normalizedKw = kw.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+      return text.includes(normalizedKw);
+    });
+
+    if (matched) {
+      return {
+        event: { ...pattern.event },
+        signalId: pattern.id,
+        missionId: result.missionId || null,
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Send a detected flowmap event to the mission state machine.
+ * Graceful: returns null if no mission or flowmap error.
+ *
+ * @param {string} projectRoot
+ * @param {string} missionId
+ * @param {object} event - XState event { type, ... }
+ * @returns {Promise<{ value: string, context: object } | null>}
+ */
+export async function fireFlowmapEvent(projectRoot, missionId, event) {
+  if (!missionId) return null;
+
+  try {
+    const { sendFlowmapEvent } = await import('../core/flowmap/api.js');
+    return sendFlowmapEvent(missionId, event, { root: projectRoot });
+  } catch (e) {
+    debug(`fireFlowmapEvent: ${e.message}`);
+    return null;
+  }
+}
+
+/**
+ * Full pipeline: analyze dispatch result, detect signal, fire flowmap event.
+ *
+ * @param {string} projectRoot
+ * @param {object} result - dispatch result
+ * @param {object} classification - routing entry
+ * @returns {Promise<{ event: object, signalId: string, newState: string|null } | null>}
+ */
+export async function bridgeDispatchToFlowmap(projectRoot, result, classification) {
+  const detected = processDispatchResult(projectRoot, result, classification);
+  if (!detected) return null;
+
+  const missionId = detected.missionId || result.missionId || result.odmId;
+  if (!missionId) return { ...detected, newState: null };
+
+  const state = await fireFlowmapEvent(projectRoot, missionId, detected.event);
+
+  return {
+    event: detected.event,
+    signalId: detected.signalId,
+    newState: state?.value || null,
+  };
+}

package/lib/kairos/hook-handlers.js

@@ -0,0 +1,351 @@
+import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { openTurn, closeTurn } from '../core/notewriter/log.js';
+import { generateNote } from '../core/notewriter/notes.js';
+import { shouldGenerateCR, generateCR, consumePendingCr } from '../core/notewriter/cr.js';
+import { readNotewriterConfig } from '../core/notewriter/config.js';
+import { findPendingDispatch, writeDispatchResult, consumePendingDispatch } from './agent-runner.js';
+import { resolveAgentContext } from './context-loader.js';
+import { readCurrentSituation, writeCurrentSituation } from './context-writer.js';
+import { detectSituation } from './situation-detector.js';
+import { routeToFile } from './dispatcher-router.js';
+import { processDispatchResult, fireFlowmapEvent } from './flowmap-bridge.js';
+import { buildUnifiedContext, buildSituationUpdate } from './context-injector.js';
+
+function debugLog(hook, msg) {
+  try { appendFileSync('/tmp/kairos-debug.log', `[${new Date().toISOString()}] ${hook}: ${msg}\n`); } catch {}
+}
+
+export function readStdin() {
+  try {
+    const data = readFileSync(0, 'utf-8'); // fd 0 = stdin
+    if (!data.trim()) return {};
+    return JSON.parse(data);
+  } catch (e) {
+    debugLog('readStdin', `parse failed: ${e.message}`);
+    return {};
+  }
+}
+
+/**
+ * Extract the last assistant response from a Claude Code transcript JSONL.
+ * Transcript entries with type "assistant" have message.content[] with text blocks.
+ */
+export function extractLastResponse(transcriptPath) {
+  if (!transcriptPath) return '';
+  try {
+    const raw = readFileSync(transcriptPath, 'utf-8');
+    const lines = raw.trim().split('\n');
+    let lastAssistant = null;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'assistant') lastAssistant = entry;
+      } catch (e) { debugLog('extractLastResponse', `skip: ${e.message}`); }
+    }
+    if (!lastAssistant?.message?.content) return '';
+    const textBlocks = lastAssistant.message.content
+      .filter(b => b.type === 'text')
+      .map(b => b.text || '');
+    return textBlocks.join('\n').trim();
+  } catch (e) {
+    debugLog('extractLastResponse', `failed: ${e.message}`);
+    return '';
+  }
+}
+
+export async function detectAgent(projectRoot, sessionId) {
+  try {
+    const { readRegistry, getLanes } = await import('../core/registry.js');
+    const { detectProject } = await import('../core/project.js');
+    const project = detectProject(projectRoot);
+    debugLog('detectAgent', `root=${projectRoot} project=${project?.id || 'null'} hcm_dir=${project?.hcm_dir || 'null'}`);
+    if (!project) return null;
+    const reg = readRegistry(project.hcm_dir);
+    debugLog('detectAgent', `reg=${reg ? 'found' : 'null'}`);
+    if (!reg) return null;
+    const lanes = getLanes(reg);
+    debugLog('detectAgent', `lanes=${lanes?.length || 0} sessionId=${sessionId}`);
+    if (!lanes || lanes.length === 0) return null;
+    // Match by session_id when available (multi-agent safe)
+    if (sessionId) {
+      const match = lanes.find(l => l.session_id === sessionId);
+      if (match) return match.name || null;
+      // No match — unknown session (service LLM, etc.), do not fallback
+      return null;
+    }
+    // No sessionId provided — fallback to first agent (legacy)
+    const active = lanes.find(l => l.session_id);
+    return active?.name || lanes[0]?.name || null;
+  } catch (e) { debugLog('detectAgent', `failed: ${e.message}`); return null; }
+}
+
+// --- SessionStart ---
+
+export async function handlePreHook(projectRoot) {
+  try {
+    debugLog('SessionStart', 'fired');
+    const stdin = readStdin();
+    const agentName = await detectAgent(projectRoot, stdin.session_id);
+    debugLog('SessionStart', `agent=${agentName || 'none'} session=${stdin.session_id || 'none'}`);
+    if (!agentName) return;
+
+    // Update PID in registry (new process on --resume) + register for event bus
+    try {
+      const { registerPid } = await import('./pid-checker.js');
+      registerPid(projectRoot, agentName, process.ppid || process.pid, stdin.session_id);
+    } catch (e) { debugLog('SessionStart', `registerPid: ${e.message}`); }
+
+    // Poll + inject pending events + purge expired
+    try {
+      const { consumeAllEvents, formatEventsForInjection, purgeExpired } = await import('./event-bus.js');
+      purgeExpired(projectRoot);
+      const events = consumeAllEvents(projectRoot, agentName);
+      if (events.length > 0) {
+        process.stdout.write(formatEventsForInjection(events));
+      }
+    } catch (e) { debugLog('SessionStart', `event-bus: ${e.message}`); }
+
+    // Consume .pending-cr (injection CR at resume)
+    const crText = consumePendingCr(projectRoot, agentName);
+    if (crText) {
+      process.stdout.write(crText);
+    }
+
+    // Resolve role + projectId for unified context
+    const ctx = resolveAgentContext(projectRoot, agentName);
+    const role = ctx?.isLeader ? 'leader' : 'expert';
+    const projectId = ctx?.projectId || '';
+
+    // Write initial situation
+    writeCurrentSituation(projectRoot, 'onboarding');
+
+    // Single unified context injection (replaces 3 separate calls)
+    const contextInjection = await buildUnifiedContext(projectRoot, agentName, role, 'onboarding', { projectId });
+    if (contextInjection) {
+      process.stdout.write(contextInjection);
+      debugLog('SessionStart', `unified context injected for ${agentName} (${role})`);
+    }
+  } catch (e) { debugLog('SessionStart', `FAILED: ${e.message}`); }
+}
+
+// --- UserPromptSubmit ---
+
+export async function handleDynamicHook(projectRoot) {
+  try {
+    debugLog('UserPromptSubmit', 'fired');
+    const stdin = readStdin();
+    const sessionId = stdin.session_id;
+    const prompt = stdin.prompt;
+    debugLog('UserPromptSubmit', `session=${sessionId || 'none'} prompt=${(prompt || '').slice(0, 50)}`);
+    if (!sessionId || !prompt) return;
+
+    const agentName = await detectAgent(projectRoot, sessionId);
+    if (!agentName) return;
+
+    // Detect situation and inject update if situation changed
+    try {
+      const { situation } = detectSituation(prompt);
+      const currentSituation = readCurrentSituation(projectRoot);
+      if (situation !== currentSituation && situation !== 'general') {
+        writeCurrentSituation(projectRoot, situation);
+        const update = await buildSituationUpdate(projectRoot, situation);
+        if (update) {
+          process.stdout.write(update);
+          debugLog('UserPromptSubmit', `situation changed: ${currentSituation} → ${situation}`);
+        }
+      }
+    } catch (e) { debugLog('UserPromptSubmit', `situation detect FAILED: ${e.message}`); }
+
+    // Poll + inject pending events (ALL agents, not just Leader)
+    try {
+      const { consumeAllEvents, formatEventsForInjection } = await import('./event-bus.js');
+      const events = consumeAllEvents(projectRoot, agentName);
+      if (events.length > 0) {
+        process.stdout.write(formatEventsForInjection(events));
+      }
+    } catch (e) { debugLog('UserPromptSubmit', `event-bus: ${e.message}`); }
+
+    const nwConfig = readNotewriterConfig(projectRoot);
+    if (!nwConfig.note_enabled) return;
+
+    // Calculate turn number from temp counter
+    const counterPath = join(projectRoot, '.nemesis', `.turn-counter-${sessionId}`);
+    let turnNumber = 1;
+    if (existsSync(counterPath)) {
+      try { turnNumber = parseInt(readFileSync(counterPath, 'utf-8').trim()) + 1; }
+      catch (e) { debugLog('UserPromptSubmit', `turnCounter: ${e.message}`); turnNumber = 1; }
+    }
+    writeFileSync(counterPath, String(turnNumber), 'utf-8');
+
+    // openTurn — stores in memory + .pending-turn file
+    openTurn(projectRoot, agentName, sessionId, turnNumber, prompt);
+
+    // Store prompt for post-hook bridge
+    const lastPromptPath = join(projectRoot, '.nemesis', 'last-prompt.tmp');
+    writeFileSync(lastPromptPath, prompt, 'utf-8');
+
+    // Consume .pending-cr if present
+    const crText = consumePendingCr(projectRoot, agentName);
+    if (crText) {
+      process.stdout.write(crText);
+    }
+  } catch (e) { debugLog('UserPromptSubmit', `FAILED: ${e.message}`); }
+}
+
+// --- Stop ---
+
+export async function handlePostHook(projectRoot) {
+  try {
+    debugLog('Stop', 'fired');
+    const stdin = readStdin();
+    const sessionId = stdin.session_id;
+    debugLog('Stop', `session=${sessionId || 'none'} has_last_msg=${!!stdin.last_assistant_message}`);
+    // last_assistant_message = direct from Claude, no file parsing needed
+    // extractLastResponse = fallback via transcript JSONL
+    const response = stdin.last_assistant_message || extractLastResponse(stdin.transcript_path);
+    if (!sessionId) return;
+
+    const agentName = await detectAgent(projectRoot, sessionId);
+    if (!agentName) return;
+
+    // Dispatch signal — if this agent had a pending dispatch, write result
+    const pending = findPendingDispatch(projectRoot, agentName);
+    if (pending) {
+      const dispatchResult = {
+        agentName,
+        odmId: pending.metadata.odmId || '',
+        projectId: pending.metadata.projectId || '',
+        missionId: pending.metadata.missionId || '',
+        response: response || '',
+        finishedAt: new Date().toISOString(),
+      };
+      writeDispatchResult(projectRoot, pending.txnId, dispatchResult);
+      consumePendingDispatch(projectRoot, pending.txnId);
+
+      // Auto-deposit: update TXN status SENT → COMPLETED
+      try {
+        const txnPath = join(projectRoot, '.nemesis', 'HCM', 'transactions', `${pending.txnId}.json`);
+        if (existsSync(txnPath)) {
+          const txn = JSON.parse(readFileSync(txnPath, 'utf-8'));
+          if (txn.transaction_meta) {
+            txn.transaction_meta.status = 'COMPLETED';
+            txn.transaction_meta.completed_at = new Date().toISOString();
+          }
+          writeFileSync(txnPath, JSON.stringify(txn, null, 2) + '\n', 'utf-8');
+          debugLog('Stop', `TXN ${pending.txnId} → COMPLETED`);
+        }
+      } catch (e) { debugLog('Stop', `TXN update FAILED: ${e.message}`); }
+
+      // V2: classify response + route to file + bridge to flowmap
+      if (response) {
+        try {
+          const mod = await import('../sync/service-session.js');
+          const callLlm = mod.createServiceCaller(projectRoot, 'dispatcher');
+          const { classifyResponse } = await import('./dispatcher.js');
+          const context = { agentName, odmId: dispatchResult.odmId, projectId: dispatchResult.projectId };
+          const { routing } = await classifyResponse(response, context, callLlm);
+
+          // Route to files for inter-process consumption
+          routeToFile(routing, context, projectRoot);
+
+          // Bridge to flowmap: detect signal and fire event
+          for (const entry of routing) {
+            const detected = processDispatchResult(projectRoot, dispatchResult, entry);
+            if (detected && detected.missionId) {
+              await fireFlowmapEvent(projectRoot, detected.missionId, detected.event);
+              debugLog('Stop', `flowmap event fired: ${detected.signalId} → ${detected.missionId}`);
+            }
+          }
+
+          // Push event to Leader's inbox for LEADER-targeted routing entries
+          try {
+            const { pushEvent, EVENT_TYPES } = await import('./event-bus.js');
+            const { readRegistry, getLanes: getRegLanes } = await import('../core/registry.js');
+            const regForLeader = readRegistry(
+              (await import('../core/project.js')).detectProject(projectRoot)?.hcm_dir
+            );
+            if (regForLeader) {
+              const allLanes = getRegLanes(regForLeader);
+              const leader = allLanes.find(l => l.leader);
+              if (leader) {
+                for (const entry of routing) {
+                  if (entry.target === 'LEADER') {
+                    pushEvent(projectRoot, {
+                      target_agent_id: leader.id || leader.name,
+                      event_type: EVENT_TYPES.CR_DEPOSITED,
+                      source_agent_id: agentName,
+                      priority: entry.priority || 'MEDIUM',
+                      payload: { summary: entry.summary || '', odmId: dispatchResult.odmId },
+                    });
+                  }
+                }
+              }
+            }
+          } catch (e) { debugLog('Stop', `event-bus push to leader FAILED: ${e.message}`); }
+        } catch (e) { debugLog('Stop', `dispatch classify FAILED: ${e.message}`); }
+      }
+    }
+
+    // Note: NE PAS unregisterPid ici — Stop != session end
+    // L'agent peut etre repris via --resume
+
+    const nwConfig = readNotewriterConfig(projectRoot);
+    debugLog('Stop', `note_enabled=${nwConfig.note_enabled}`);
+
+    // 1. closeTurn (reads .pending-turn if Map empty — inter-process)
+    const turnEntry = closeTurn(projectRoot, agentName, sessionId, response || '');
+    debugLog('Stop', `turnEntry=${turnEntry ? 'found' : 'null'}`);
+
+    // 2. generateNote (if enabled)
+    if (nwConfig.note_enabled && turnEntry) {
+      let callLlm;
+      try {
+        const mod = await import('../sync/service-session.js');
+        callLlm = mod.createServiceCaller(projectRoot, 'notes');
+        debugLog('Stop', 'callLlm created');
+      } catch (e) {
+        // Service LLM not configured — skip
+        debugLog('Stop', `callLlm FAILED: ${e.message}`);
+        return;
+      }
+
+      await generateNote(projectRoot, agentName, turnEntry, callLlm);
+      debugLog('Stop', 'note generated');
+
+      // 3. Check CR timer (lazy)
+      if (nwConfig.cr_enabled) {
+        if (shouldGenerateCR(projectRoot, agentName, nwConfig.cr_timer_minutes)) {
+          await generateCR(projectRoot, agentName, 'timer_30min', callLlm);
+        }
+      }
+    }
+  } catch (err) {
+    // Never crash — log warning, exit 0
+    console.error(`NoteWriter hook error: ${err.message}`);
+  }
+}
+
+// --- PreCompact ---
+
+export async function handlePreCompact(projectRoot) {
+  try {
+    const stdin = readStdin();
+    const agentName = await detectAgent(projectRoot, stdin.session_id);
+    if (!agentName) return;
+
+    // Resolve role + projectId
+    const ctx = resolveAgentContext(projectRoot, agentName);
+    const role = ctx?.isLeader ? 'leader' : 'expert';
+    const projectId = ctx?.projectId || '';
+    const situation = readCurrentSituation(projectRoot) || 'general';
+
+    // Single unified context re-injection (same as SessionStart)
+    const contextInjection = await buildUnifiedContext(projectRoot, agentName, role, situation, { projectId });
+    if (contextInjection) {
+      process.stdout.write(contextInjection);
+      debugLog('PreCompact', `unified context re-injected for ${agentName}`);
+    }
+  } catch (e) { debugLog('PreCompact', `FAILED: ${e.message}`); }
+}