@cgh567/agent 2.4.2 → 2.4.4

package/lib/triage-core/orchestrator.ts.bak-r005-r006-r008

@@ -1,1823 +0,0 @@
-// ============================================================================
-// lib/triage-core/orchestrator.ts
-//
-// Production mental model triage orchestrator.
-// Single entry point for all channels: Gmail, iMessage, Outlook.
-// Replaces all ad-hoc scripts with a unified, reliable pipeline.
-// ============================================================================
-
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID, createHash } from 'node:crypto';
-import { exec, execFile } from 'node:child_process';
-import { homedir } from 'node:os';
-import type {
-  TriageItem,
-  TriageStats,
-  TriageBatch,
-  TriagePlatform,
-  MessageExtraction,
-  PersonMentalModel,
-} from './types.ts';
-import { extractEntitiesBatch } from './mental-model/entity-extractor-batch.ts';
-import {
-  persistPersonsBatch,
-  persistIdentitiesBatch,
-  persistEpisodesBatch,
-  persistExtractionsBatch,
-  persistConversationsBatch,
-} from './graph/batch-persistence.ts';
-import { resolveIdentity, flushPendingCreations } from './mental-model/identity-resolver.ts';
-import { assembleMentalModel } from './mental-model/model-assembler.ts';
-import { classifyWithContext } from './classifier.ts';
-import type { DraftModel } from '../../extensions/email/actions/draft-response.ts';
-import { generateBriefing } from './briefing.ts';
-import { generateDashboard } from './dashboard-generator.ts';
-import { recordDecision, flushDecisions } from './learning.ts';
-import { createRequire } from 'module';
-import eventBus from '../event-bus.mts';
-import { isLenderOrLegalEmail, buildAttorneyForwardDraft, ATTORNEY_EMAIL } from './legal-routing.ts';
-import { detectSituations, getActiveSituations } from './mental-model/situation-detector.ts';
-
-const require = createRequire(import.meta.url);
-
-// ---------------------------------------------------------------------------
-// Channel Adapter Interface
-// ---------------------------------------------------------------------------
-
-export interface ChannelAdapter {
-  name: string;
-  available(): boolean;
-  fetch(since: Date, limit: number): Promise<RawMessage[]>;
-}
-
-export interface RawMessage {
-  id: string;
-  threadId: string;
-  platform: TriagePlatform;
-  senderHandle: string;
-  senderName: string;
-  subject: string;
-  body: string;
-  receivedAt: string;
-  isGroup: boolean;
-  rawId: string;
-  labels?: string[];
-  /** Optional direction — 'inbound' (default) or 'outbound' (sent messages) */
-  direction?: 'inbound' | 'outbound';
-}
-
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-
-export interface OrchestratorConfig {
-  /** Skip actual processing, just test fetch */
-  dryRun?: boolean;
-  /** Max emails per channel per run */
-  limitPerChannel?: number;
-  /** Extraction concurrency (Bedrock parallel calls) */
-  extractionConcurrency?: number;
-  /** Batch size for graph UNWIND writes (Memgraph optimal: 500-5000) */
-  batchSize?: number;
-  /** Max parallel channel fetches (default: number of channels, i.e. all concurrent) */
-  fetchConcurrency?: number;
-  /** Max parallel batch persistence chunks (default: 3) */
-  persistConcurrency?: number;
-  /** Cache directory for briefings */
-  cacheDir?: string;
-  /** Channel adapters to use */
-  channels?: ChannelAdapter[];
-  /** SSE broadcast callback injected by daemon (optional) */
-  broadcast?: ((payload: Record<string, unknown>) => void) | null;
-  /** Log function (default: stderr) */
-  log?: (msg: string) => void;
-  /** Budget control: skip key-facts LLM extraction (set via TRIAGE_SKIP_KEY_FACTS=1) */
-  skipKeyFacts?: boolean;
-  /** Budget control: skip active-situations detection pass (set via TRIAGE_SKIP_SITUATION_DETECT=1) */
-  skipSituationDetect?: boolean;
-  /** Skip LLM draft generation (classify only, no Bedrock calls for drafts) */
-  skipDrafts?: boolean;
-  /** After triage, write full message bodies back to Email nodes in Memgraph */
-  persistBodies?: boolean;
-  /** Suppress background queue processing (key-facts, embeddings) during large bulk runs */
-  suppressBackgroundQueues?: boolean;
-}
-
-/**
- * Named configuration presets for common orchestration modes.
- * Use BACKFILL_PRESET for historical/bulk runs, LIVE_PRESET for incremental.
- */
-export const TRIAGE_BACKFILL_PRESET: Partial<OrchestratorConfig> = {
-  batchSize: 5,              // Small batches - less Memgraph contention
-  extractionConcurrency: 2,  // Conservative Bedrock concurrency for long runs
-  persistConcurrency: 1,     // Sequential persistence - no write conflicts
-  suppressBackgroundQueues: true,
-} as const;
-
-export const TRIAGE_LIVE_PRESET: Partial<OrchestratorConfig> = {
-  batchSize: 500,
-  extractionConcurrency: 5,
-  persistConcurrency: 3,
-} as const;
-
-export interface RunOptions {
-  /** Fetch messages since this date (default: 24h ago) */
-  since?: Date;
-  /** Override config limit per channel */
-  limit?: number;
-  /** Backfill mode (extended window) */
-  backfill?: boolean;
-  /** Skip deduplication — re-process all fetched messages */
-  skipDedup?: boolean;
-}
-
-export interface TriageResult {
-  success: boolean;
-  stats: TriageStats;
-  briefing?: { markdown: string };
-  items?: TriageItem[];
-  message?: string;
-  error?: string;
-  timings: Record<string, number>;
-}
-
-export interface CachedBriefingItem {
-  id: string;
-  subject: string;
-  senderName: string;
-  senderHandle: string;
-  priority: string;
-  autoDraft?: string;
-  autoDraftModel?: string;  // PersonMentalModel object (deprecated name, kept for compat)
-  autoDraftModelId?: string; // LLM model ID string (e.g. "amazon-bedrock")
-  draft_failed?: boolean;   // true when helios-rpc returned empty / timed out
-  platform?: string;
-  senderModel?: unknown;
-  activeSituations?: unknown[];
-}
-
-export interface CachedBriefing {
-  generatedAt: string;
-  markdown: string;
-  stats: TriageStats;
-  /** P0/P1 items with autoDraft, for consumption by pi-email-review */
-  draftItems?: CachedBriefingItem[];
-}
-
-// ---------------------------------------------------------------------------
-// Orchestrator Class
-// ---------------------------------------------------------------------------
-
-const DEFAULT_CACHE_DIR = path.join(homedir(), 'helios-agent/data/email-triage');
-const BRIEFING_CACHE_FILE = 'latest-briefing.json';
-
-export class TriageOrchestrator {
-  private config: Required<OrchestratorConfig>;
-  private correlationId: string;
-  _broadcast: ((payload: Record<string, unknown>) => void) | null = null;
-
-  constructor(config: OrchestratorConfig = {}) {
-    const channels = config.channels ?? [];
-    this.config = {
-      dryRun: config.dryRun ?? false,
-      limitPerChannel: config.limitPerChannel ?? 100,
-      extractionConcurrency: config.extractionConcurrency ?? 5,
-      batchSize: config.batchSize ?? 100,
-      fetchConcurrency: config.fetchConcurrency ?? Math.max(1, channels.length),
-      persistConcurrency: config.persistConcurrency ?? 3,
-      cacheDir: config.cacheDir ?? DEFAULT_CACHE_DIR,
-      channels,
-      log: config.log ?? ((msg: string) => process.stderr.write(msg + '\n')),
-      skipKeyFacts: config.skipKeyFacts ?? false,
-      skipSituationDetect: config.skipSituationDetect ?? false,
-      broadcast: config.broadcast ?? null,
-      skipDrafts: config.skipDrafts ?? false,
-      persistBodies: config.persistBodies ?? false,
-      suppressBackgroundQueues: config.suppressBackgroundQueues ?? false,
-    };
-    this.correlationId = randomUUID().slice(0, 12);
-    if (config.broadcast !== undefined) this._broadcast = config.broadcast ?? null;
-  }
-
-  /**
-   * Run the full triage pipeline.
-   */
-  async run(options: RunOptions = {}): Promise<TriageResult> {
-    const startTime = Date.now();
-    const timings: Record<string, number> = {};
-    const stats: TriageStats = {
-      p0Count: 0,
-      p1Count: 0,
-      p2Count: 0,
-      p3Count: 0,
-      vipPending: 0,
-      avgResponseLag: null,
-      estimatedTimeSaved: 0,
-      extractionCostTotal: 0,
-      extractionFailures: 0,
-    };
-
-    try {
-      this.log('info', 'pipeline.start', {
-        dryRun: this.config.dryRun,
-        backfill: options.backfill ?? false,
-        channels: this.config.channels.map(c => c.name),
-      });
-
-      // ── Step 1: Fetch ────────────────────────────────────────────────
-      const t0 = Date.now();
-      const since = options.since ?? new Date(Date.now() - 24 * 60 * 60 * 1000);
-      const limit = options.limit ?? this.config.limitPerChannel;
-      const rawMessages = await this.fetchAll(since, limit);
-      timings.fetch = Date.now() - t0;
-
-      if (rawMessages.length === 0) {
-        this.log('info', 'pipeline.complete', { message: 'No messages to triage' });
-        return {
-          success: true,
-          stats,
-          message: '✅ All clear — no unread messages to triage.',
-          timings,
-        };
-      }
-
-      if (this.config.dryRun) {
-        this.log('info', 'dryrun.complete', { fetched: rawMessages.length });
-        return {
-          success: true,
-          stats,
-          message: `✅ Dry run: fetched ${rawMessages.length} messages`,
-          timings,
-        };
-      }
-
-      // ── Step 2: Deduplicate ──────────────────────────────────────────
-      const t1 = Date.now();
-      const uniqueMessages = options.skipDedup ? rawMessages : await this.deduplicate(rawMessages, options.backfill ?? false);
-      timings.deduplicate = Date.now() - t1;
-
-      if (uniqueMessages.length === 0) {
-        this.log('info', 'pipeline.complete', { message: 'All messages already processed' });
-        return {
-          success: true,
-          stats,
-          message: '✅ All clear — no new messages to triage.',
-          timings,
-        };
-      }
-
-      // ── Step 3: Extract entities (parallel) ──────────────────────────
-      const t2 = Date.now();
-      const extractions = await this.extractBatch(uniqueMessages);
-      timings.extract = Date.now() - t2;
-
-      // Calculate total extraction cost
-      stats.extractionCostTotal = extractions.reduce((sum, e) => sum + (e.extraction.cost ?? 0), 0);
-      // H3: Count extraction failures so briefing can warn when LLM scoring is degraded
-      stats.extractionFailures = extractions.filter(e => e.extraction.extractionFailed === true).length;
-      if (stats.extractionFailures > 0) {
-        this.log('warn', 'extraction.failures', { count: stats.extractionFailures, total: extractions.length });
-      }
-
-      // ── Step 4: Persist (batch) ──────────────────────────────────────
-      const t3 = Date.now();
-      const enrichedItems = await this.persistBatch(uniqueMessages, extractions);
-      timings.persist = Date.now() - t3;
-
-      // ── Step 4b: Enqueue key facts extraction ─────────────────────────
-      // Budget control: skip when TRIAGE_SKIP_KEY_FACTS=1 (set via OrchestratorConfig.skipKeyFacts).
-      const t4b = Date.now();
-      if (this.config.skipKeyFacts) {
-        this.log('info', 'pipeline.facts_skipped', { reason: 'TRIAGE_SKIP_KEY_FACTS=1' });
-        timings.enqueueKeyFacts = 0;
-      } else
-      try {
-        const { enqueueFactExtraction } = await import('./mental-model/fact-extraction-queue.ts');
-        const { rawRead } = require('../safe-memgraph.js');
-
-        // Collect unique personIds from enriched items
-        const personIds = Array.from(new Set(enrichedItems.map(item => item.personId)));
-
-        let enqueued = 0;
-        for (const personId of personIds) {
-          try {
-            // Check if key facts need extraction
-            const result = await rawRead(
-              `MATCH (p:Person {id: $pid})
-               WHERE p.keyFactsUpdatedAt IS NULL 
-                 OR p.keyFactsUpdatedAt < datetime() - duration("P7D")
-               RETURN p.id AS id`,
-              { pid: personId }
-            );
-
-            if (result && result.length > 0) {
-              enqueueFactExtraction(personId);
-              enqueued++;
-            }
-          } catch (err) {
-            this.log('warn', 'enqueue.check_failed', {
-              personId,
-              error: err instanceof Error ? err.message : String(err),
-            });
-          }
-        }
-
-        timings.enqueueKeyFacts = Date.now() - t4b;
-        this.log('info', 'pipeline.facts_enqueued', { count: enqueued });
-      } catch (err) {
-        timings.enqueueKeyFacts = Date.now() - t4b;
-        this.log('warn', 'enqueue.failed', {
-          error: err instanceof Error ? err.message : String(err),
-          fallback: 'continuing without fact extraction',
-        });
-      }
-
-      // Flush pending Person creations NOW before model assembly tries to look them up
-      try {
-        const flushed = await flushPendingCreations();
-        if (flushed > 0) this.log('debug', 'identity.early_flush', { count: flushed });
-      } catch (err) {
-        this.log('warn', 'identity.flush_failed', { error: err instanceof Error ? err.message : String(err) });
-      }
-
-      // Flush key-facts queue in backfill mode so mental models are assembled with facts already present.
-      // suppressBackgroundQueues is set via TRIAGE_BACKFILL_PRESET (or explicitly in config);
-      // this ensures key-facts jobs that accumulated during batch persist are processed now.
-      if (this.config.suppressBackgroundQueues && !this.config.skipKeyFacts) {
-        try {
-          const { flushFactExtractionQueue } = await import('./mental-model/fact-extraction-queue.ts');
-          await flushFactExtractionQueue(120_000);
-          this.log('info', 'pipeline.facts_flushed_for_backfill', {});
-        } catch (err) {
-          this.log('warn', 'pipeline.facts_flush_failed', { error: err instanceof Error ? err.message : String(err) });
-        }
-      }
-
-      // ── Step 5: Assemble mental models ───────────────────────────────
-      const t4 = Date.now();
-      const itemsWithModels = await this.assembleModels(enrichedItems);
-      timings.assemble = Date.now() - t4;
-
-      // ── Step 5b: Situation detection (LLM-powered state machine over graph data) ──
-      if (!this.config.skipSituationDetect) {
-        try {
-          // detectSituations() runs the Cypher state-machine and returns aggregate counts.
-          // We then fetch the active situations from the graph and attach them to items
-          // by matching each item's sender personId against situation participants.
-          await detectSituations();
-          const activeSits = await getActiveSituations(50);
-          if (activeSits.length > 0) {
-            for (const item of itemsWithModels) {
-              const personId = ((item as any).senderModel as any)?.personId as string | undefined;
-              if (personId) {
-                (item as any).activeSituations = activeSits.filter((s: any) =>
-                  Array.isArray(s.participants)
-                    ? s.participants.some((name: string) => name && personId.includes(name))
-                    : false
-                );
-              }
-            }
-          }
-          this.log('info', 'situation_detect.done', { situationCount: activeSits.length });
-        } catch (err) {
-          this.log('warn', 'situation_detect.failed', { error: (err as Error).message });
-        }
-      }
-
-      // ── Step 6: Classify ─────────────────────────────────────────────
-      const t5 = Date.now();
-      const classified = await this.classify(itemsWithModels);
-      timings.classify = Date.now() - t5;
-
-      // Update stats from classification
-      for (const item of classified) {
-        if (item.priority === 'P0') stats.p0Count++;
-        else if (item.priority === 'P1') stats.p1Count++;
-        else if (item.priority === 'P2') stats.p2Count++;
-        else if (item.priority === 'P3') stats.p3Count++;
-        if (item.senderModel?.isVip) stats.vipPending++;
-
-        // Emit triage:classified event for each item
-        try {
-          (eventBus as any).emit('triage:classified', {
-            messageId: item.id,
-            senderHandle: item.senderHandle ?? '',
-            senderName: item.senderName ?? null,
-            personId: (item.senderModel as { personId?: string } | null)?.personId ?? null,
-            priority: item.priority,
-            compositeScore: item.compositeScore ?? 0,
-            platform: item.platform ?? 'email',
-            timestamp: Date.now(),
-          });
-
-          // Emit escalation for P0 items
-          if (item.priority === 'P0') {
-            (eventBus as any).emit('triage:escalation', {
-              messageId: item.id,
-              senderHandle: item.senderHandle ?? '',
-              senderName: item.senderName ?? item.senderHandle ?? 'Unknown',
-              reason: `P0 classification (score: ${(item.compositeScore ?? 0).toFixed(2)})`,
-              timestamp: Date.now(),
-            });
-          }
-        } catch { /* event bus emissions are fire-and-forget */ }
-      }
-
-      // ── Step 6b: Auto-draft for P0/P1 items ─────────────────────────
-      if (this.config.skipDrafts) {
-        this.log('info', 'pipeline.drafts_skipped', { reason: 'skipDrafts=true' });
-      } else {
-      const t5b = Date.now();
-      // Hoist imports before the loop to avoid repeated dynamic import overhead
-      const [{ draftResponse }, { assembleCrossChannelContext, formatCrossChannelContext }] = await Promise.all([
-        import('../../extensions/email/actions/draft-response.js'),
-        import('./cross-channel-context.js'),
-      ]);
-      // B3+B4+B5 fix: replaced serial for...of with Promise.allSettled to unblock pipeline.
-      // Each item's draft + context assembly now runs in parallel.
-      await Promise.allSettled(
-        classified
-          .filter(item => item.priority === 'P0' || item.priority === 'P1')
-          .map(async (item) => {
-          try {
-            // C2: Legal routing check — lender/MCA/attorney emails get forwarded to Chris,
-            // not replied to. This check runs BEFORE draftResponse() to skip the LLM call
-            // entirely and produce a forward draft instead.
-            if (isLenderOrLegalEmail({ senderHandle: item.senderHandle || '', subject: item.subject || '', body: item.body, snippet: (item as any).snippet })) {
-              const fwd = buildAttorneyForwardDraft({ ...item });
-              item.autoDraft = fwd.body;
-              item.autoDraftModel = 'forward-rule';
-              (item as any).forwardToAttorney = true;
-              (item as any).forwardDraft = fwd;
-              this.log('info', 'legal_routing.forward', {
-                messageId: item.id,
-                sender: item.senderHandle,
-                subject: (item.subject || '').slice(0, 80),
-                to: ATTORNEY_EMAIL,
-              });
-              return; // skip cross-channel context + draftResponse for forward items
-            }
-
-            let enrichedBody = item.body;
-
-            try {
-              const crossCtx = await assembleCrossChannelContext({
-                personId: item.senderModel?.personId,
-                personName: item.senderName,
-                senderHandle: item.senderHandle,
-                topic: item.subject,
-                messageBody: item.body,
-                limit: 8,
-              });
-              item.crossChannelContext = crossCtx;
-              const crossCtxBlock = formatCrossChannelContext(crossCtx);
-              if (crossCtxBlock) {
-                enrichedBody = `${enrichedBody}\n\n${crossCtxBlock}`;
-              }
-              this.log('info', 'cross_channel.complete', {
-                emails: crossCtx.emailHistory?.length || 0,
-                messages: crossCtx.messageHistory?.length || 0,
-                sessions: crossCtx.sessionContext?.length || 0,
-                facts: crossCtx.keyFacts?.length || 0,
-              });
-            } catch (ctxErr) {
-              // Non-fatal: context enrichment failure must not break drafting
-              this.log('warn', 'auto_draft.context_failed', {
-                messageId: item.id,
-                error: ctxErr instanceof Error ? ctxErr.message : String(ctxErr),
-              });
-            }
-
-            const draftItem = {
-              id: item.id,
-              senderName: item.senderName,
-              senderHandle: item.senderHandle,
-              subject: item.subject,
-              body: enrichedBody,
-              platform: item.platform,
-              receivedAt: item.receivedAt,
-            };
-            const model = item.senderModel || { name: item.senderName };
-            const draftResult = await draftResponse(draftItem, model as unknown as DraftModel);
-            item.autoDraft = draftResult.draft;
-            item.autoDraftModel = draftResult.modelId || 'amazon-bedrock';    // LLM model ID string
-            (item as any).autoDraftModelId = draftResult.modelId; // LLM model ID string
-            if (draftResult.draft_failed) (item as any).draft_failed = true;
-          } catch (err) {
-            this.log('warn', 'auto_draft.failed', {
-              messageId: item.id,
-              error: err instanceof Error ? err.message : String(err),
-            });
-          }
-        })
-      );
-      timings.autoDraft = Date.now() - t5b;
-      } // end skipDrafts
-
-      // Persist DraftAction nodes for items with auto-drafts
-      try {
-        const draftedItems = classified.filter(i => i.autoDraft && i.priority && ['P0', 'P1'].includes(i.priority));
-        if (draftedItems.length > 0) {
-          const { rawWrite } = require('../safe-memgraph.js');
-          const batch = draftedItems.map(item => ({
-            id: `draft-${item.id}`,
-            type: item.platform === 'slack' ? 'slack' : 'email',
-            triggeredBy: `auto_draft_${item.priority}`,
-            content: JSON.stringify({ 
-              to: item.senderHandle, 
-              subject: (item.subject || '').slice(0, 200),
-              body: (item.autoDraft || '').slice(0, 500)
-            }),
-            personId: (item.senderModel as any)?.personId || null,
-            status: 'created',
-            expiresAt: new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString(),
-          }));
-          await rawWrite(
-            `UNWIND $batch AS d
-             MERGE (n:DraftAction {id: d.id})
-             SET n.type = d.type, n.triggeredBy = d.triggeredBy, n.content = d.content,
-                 n.personId = d.personId, n.status = d.status, n.createdAt = datetime({timezone:'UTC'}),
-                 n.expiresAt = d.expiresAt`,
-            { batch }
-          );
-          this.log('info', 'draft_actions.persisted', { count: batch.length });
-        }
-      } catch (err: any) {
-        this.log('debug', 'draft_actions.persist_failed', { error: err?.message?.slice(0, 60) });
-      }
-
-      // ── Step 7: Brief ────────────────────────────────────────────────
-      const t6 = Date.now();
-      // Build mentalModels map from classified items for briefing context
-      const mentalModels = new Map<string, PersonMentalModel>();
-      for (const item of classified) {
-        if (item.senderModel?.personId) {
-          mentalModels.set(item.senderModel.personId, item.senderModel);
-        }
-      }
-      const platform = this.derivePlatform(classified);
-      const briefing = await generateBriefing({
-        batchId: this.correlationId,
-        platform,
-        startedAt: new Date(startTime).toISOString(),
-        completedAt: new Date().toISOString(),
-        totalMessages: classified.length,
-        classified: classified.length,
-        items: classified,
-        stats,
-      }, mentalModels);
-      timings.brief = Date.now() - t6;
-
-      // ── Ensure no item has null secretaryBrief ─────────────────────────
-      for (const item of classified) {
-        if (!item.secretaryBrief) {
-          item.secretaryBrief = `[${item.priority}] ${item.subject?.substring(0, 100) || `Message from ${item.senderName}`}`;
-        }
-      }
-
-      // ── Step 8: Learn (record decisions) ─────────────────────────────
-      const t7 = Date.now();
-      await this.learn(classified);
-      timings.learn = Date.now() - t7;
-
-      // ── Step 8b: Wire P0/P1 items into HBO operating loop ────────────
-      // triage-hbo-bridge creates Task + AgentReadySignal nodes so the
-      // HBO daemon dispatcher can act on high-priority inbound messages.
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { batchTriageToHBO } = require('../../daemon/lib/triage-hbo-bridge.js') as {
-          batchTriageToHBO: (items: typeof classified, companyId: string, log?: (msg: string) => void, writeFn?: ((q: string, p?: Record<string, unknown>) => Promise<unknown>) | null, broadcast?: ((payload: Record<string, unknown>) => void) | null) => Promise<{ wired: number; skipped: number; errors: number }>;
-        };
-        const resolvedCompanyId = process.env.HELIOS_COMPANY_ID ?? null;
-        const hboCompanyId = resolvedCompanyId ?? 'talisman';
-        const hboStats = await batchTriageToHBO(
-          classified,
-          hboCompanyId,
-          (msg: string) => this.log('debug', 'triage_hbo_bridge', { msg }),
-          null,                          // writeFn: null = use default safe-memgraph
-          (this as any)._broadcast ?? null, // broadcast: daemon-injected SSE push, or null
-        );
-        if (hboStats.wired > 0 || hboStats.errors > 0) {
-          this.log('info', 'hbo_bridge.complete', hboStats);
-        }
-      } catch (e) {
-        // Non-fatal: HBO bridge must not break the triage pipeline
-        this.log('warn', 'hbo_bridge.unavailable', { error: e instanceof Error ? e.message : String(e) });
-      }
-
-      // ── Step 8c: Update CRM outreach records for classified items ─────────
-      // onMessageProcessed advances Lead status, logs Outreach nodes, and
-      // detects replies for any item that matches a known CRM contact.
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { onMessageProcessed } = require('../../lib/crm/integration/triage-bridge.js') as {
-          onMessageProcessed: (event: {
-            personId: string;
-            episodeId: string;
-            direction: 'inbound' | 'outbound';
-            platform: string;
-            fromEmail?: string;
-            fromPhone?: string;
-          }) => Promise<{ crmUpdated: boolean; leadId?: string }>;
-        };
-        await Promise.allSettled(
-          classified
-            .filter(item => item.priority === 'P0' || item.priority === 'P1')
-            .map(item => onMessageProcessed({
-              personId: ((item.senderModel as Record<string, unknown> | null)?.personId as string | null) ?? '',
-              episodeId: `ep-${item.platform}-${item.id}`,
-              direction: (item.direction as 'inbound' | 'outbound') ?? 'inbound',
-              platform: item.platform ?? 'email',
-              fromEmail: item.senderHandle?.includes('@') ? item.senderHandle : undefined,
-              fromPhone: (item.senderHandle && !item.senderHandle.includes('@')) ? item.senderHandle : undefined,
-            }).catch((e: unknown) =>
-              this.log('warn', 'crm_bridge.failed', { error: String(e) })
-            ))
-        );
-      } catch (e) {
-        this.log('debug', 'crm_bridge_unavailable', { error: e instanceof Error ? e.message : String(e) });
-      }
-
-      // ── Step 8d: Persist message bodies (if persistBodies: true) ──────
-      try {
-        await this.persistMessageBodies(uniqueMessages);
-      } catch (err: any) {
-        this.log('warn', 'pipeline.bodies_persist_failed', { error: err?.message?.slice(0, 80) });
-      }
-
-      // ── Step 9: Route to departments via DepartmentRouterBridge ─────
-      try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { DepartmentRouterBridge } = require('./department-router-bridge.js') as { DepartmentRouterBridge: new (q: unknown) => { processClassification: (c: Record<string, unknown>) => Promise<unknown> } };
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { mgQueryAsync } = require('../graph/lib/utils.js') as { mgQueryAsync: unknown };
-        const bridge = new DepartmentRouterBridge(mgQueryAsync);
-        // B3+B4+B5 fix: replaced serial for...of with Promise.allSettled — routing runs in parallel.
-        await Promise.allSettled(
-          classified.map(item =>
-            bridge.processClassification({
-              messageId: item.id,
-              priority: item.priority,
-              signalType: item.suggestedAction ?? 'general_inquiry',
-              senderId: item.senderHandle,
-              faveType: (item as any).faveeType ?? undefined,
-              companyId: process.env.HELIOS_COMPANY_ID ?? 'talisman',
-            }            ).catch((e: unknown) => {
-              // Non-fatal: routing failure must not break triage
-              this.log('warn', 'department_routing_failed', { messageId: item.id, error: e instanceof Error ? e.message : String(e) });
-            })
-          )
-        );
-      } catch (e) {
-        // Non-fatal: bridge may not be available in all environments
-        this.log('warn', 'department_bridge_unavailable', { error: e instanceof Error ? e.message : String(e) });
-      }
-
-      // ── Step 10: Cache results ───────────────────────────────────────
-      const t8 = Date.now();
-       const draftItems: CachedBriefingItem[] = classified
-         .filter(item => (item.priority === 'P0' || item.priority === 'P1') && item.autoDraft)
-         .map(item => ({
-           id: item.id,
-           subject: item.subject,
-           senderName: item.senderName,
-           senderHandle: item.senderHandle,
-           priority: item.priority,
-           autoDraft: item.autoDraft!,
-           autoDraftModel: item.autoDraftModel,
-           draft_failed: (item as any).draft_failed || undefined,
-         }));
-       await this.cache({ generatedAt: briefing.generatedAt, markdown: briefing.markdown, stats, draftItems });
-       timings.cache = Date.now() - t8;
-
-       // ── Step 10b: Write inbox cache (consumed by daemon GET /api/inbox)
-        try {
-          await this.cacheInbox(classified, stats);
-          this.log('info', 'inbox_cache.written', {});
-        } catch (err: any) {
-          this.log('warn', 'inbox_cache.write_failed', { error: err.message });
-        }
-
-        try {
-          const created = await flushPendingCreations();
-          if (created > 0) this.log('info', 'identity.batch_created', { count: created });
-        } catch (err) {
-          this.log('warn', 'identity.flush_failed', { error: err instanceof Error ? err.message : String(err) });
-        }
-
-        // ── Step 10c: Generate dashboard HTML (after all data is written)
-       try {
-         await generateDashboard();
-         this.log('info', 'dashboard.generated', {});
-       } catch (err: any) {
-         this.log('warn', 'dashboard.generate_failed', { error: err.message });
-       }
-
-       // ── Auto-open dashboard (quiet hours: 10pm–7am) ──────────────────
-      const hour = new Date().getHours();
-      if (hour >= 7 && hour < 22) {
-        const dashboardPath = path.join(homedir(), 'helios-agent', 'data', 'triage', 'dashboard.html');
-        if (fs.existsSync(dashboardPath)) {
-          try {
-            if (process.platform === 'win32') {
-              execFile('cmd.exe', ['/c', 'start', '', dashboardPath]).unref();
-            } else {
-              const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
-              execFile(openCmd, [dashboardPath]).unref();
-            }
-          } catch { /* non-fatal — dashboard open is optional */ }
-          this.log('info', 'dashboard.auto_open', { dashboardPath });
-        } else {
-          this.log('info', 'dashboard.skip_not_found', { dashboardPath });
-        }
-      } else {
-        this.log('info', 'dashboard.skip_quiet_hours', { hour });
-      }
-
-      timings.total = Date.now() - startTime;
-
-      try {
-        // B6: `classified` is always a TriageItem[] at this point — the ternary was dead code.
-        const platform = this.derivePlatform(classified);
-        (eventBus as any).emit('triage:batch-complete', {
-          batchId: this.correlationId,
-          platform,
-          totalItems: classified.length,
-          p0Count: stats.p0Count,
-          p1Count: stats.p1Count,
-          timestamp: Date.now(),
-        });
-      } catch { /* fire-and-forget */ }
-
-      this.log('info', 'pipeline.success', {
-        processed: classified.length,
-        p0: stats.p0Count,
-        p1: stats.p1Count,
-        p2: stats.p2Count,
-        p3: stats.p3Count,
-        timings,
-      });
-
-      return {
-        success: true,
-        stats,
-        briefing: { markdown: briefing.markdown },
-        items: classified,
-        timings,
-      };
-    } catch (err) {
-      this.log('error', 'pipeline.failed', {
-        error: err instanceof Error ? err.message : String(err),
-        stack: err instanceof Error ? err.stack?.split('\n').slice(0, 5) : undefined,
-      });
-      return {
-        success: false,
-        stats,
-        error: err instanceof Error ? err.message : String(err),
-        timings,
-      };
-    }
-  }
-
-  /**
-   * Get cached briefing (instant display without re-running pipeline).
-   * NOTE: Sync-by-design — callers are synchronous (CLI display, daemon status).
-   * If an async variant is needed, use fs.promises.readFile with await instead.
-   */
-  getCachedBriefing(): CachedBriefing | null {
-    try {
-      const cachePath = path.join(this.config.cacheDir, BRIEFING_CACHE_FILE);
-      if (!fs.existsSync(cachePath)) return null;
-      const data = fs.readFileSync(cachePath, 'utf-8');
-      return JSON.parse(data) as CachedBriefing;
-    } catch (err) {
-      this.log('warn', 'cache.read_failed', {
-        error: err instanceof Error ? err.message : String(err),
-      });
-      return null;
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Public: Single-Message Pipeline
-  // -------------------------------------------------------------------------
-
-  /**
-   * Run the pipeline on a single pre-fetched message (bypasses fetch + dedup).
-   * Optionally includes thread context for richer drafting.
-   */
-  async runSingle(message: RawMessage, opts?: { threadContext?: string }): Promise<TriageResult> {
-    const startTime = Date.now();
-    const timings: Record<string, number> = {};
-    const stats: TriageStats = {
-      p0Count: 0, p1Count: 0, p2Count: 0, p3Count: 0,
-      vipPending: 0, avgResponseLag: null, estimatedTimeSaved: 0, extractionCostTotal: 0,
-    };
-
-    try {
-      // Step 1: Extract
-      const t2 = Date.now();
-      const extractions = await this.extractBatch([message]);
-      timings.extract = Date.now() - t2;
-      stats.extractionCostTotal = extractions.reduce((sum, e) => sum + (e.extraction.cost ?? 0), 0);
-      // H3: Count extraction failures so briefing can warn when LLM scoring is degraded
-      stats.extractionFailures = extractions.filter(e => e.extraction.extractionFailed === true).length;
-      if (stats.extractionFailures > 0) {
-        this.log('warn', 'extraction.failures', { count: stats.extractionFailures, total: extractions.length });
-      }
-
-      // Step 2: Persist
-      const t3 = Date.now();
-      const enrichedItems = await this.persistBatch([message], extractions);
-      timings.persist = Date.now() - t3;
-
-      if (enrichedItems.length === 0) {
-        return {
-          success: false,
-          stats,
-          error: 'Message could not be processed (identity resolution or extraction failed)',
-          timings,
-        };
-      }
-
-      // Step 3: Assemble mental models
-      const t4 = Date.now();
-      const itemsWithModels = await this.assembleModels(enrichedItems);
-      timings.assemble = Date.now() - t4;
-
-      // Step 4: Classify
-      const t5 = Date.now();
-      const classified = await this.classify(itemsWithModels);
-      timings.classify = Date.now() - t5;
-
-      // Update stats
-      for (const item of classified) {
-        if (item.priority === 'P0') stats.p0Count++;
-        else if (item.priority === 'P1') stats.p1Count++;
-        else if (item.priority === 'P2') stats.p2Count++;
-        else if (item.priority === 'P3') stats.p3Count++;
-        if (item.senderModel?.isVip) stats.vipPending++;
-      }
-
-      // Step 5: Auto-draft replies for all inbound messages
-      const t6 = Date.now();
-      const DRAFTABLE_PLATFORMS = new Set(['email', 'imessage', 'sms', 'slack', 'whatsapp']);
-      // Hoist imports before the loop to avoid repeated dynamic import overhead
-      const [{ draftResponse: draftResponseSingle }, { assembleCrossChannelContext: assembleCrossChannelContextSingle, formatCrossChannelContext: formatCrossChannelContextSingle }] = await Promise.all([
-        import('../../extensions/email/actions/draft-response.js'),
-        import('./cross-channel-context.js'),
-      ]);
-      for (const item of classified) {
-        if (DRAFTABLE_PLATFORMS.has(item.platform) && item.body) {
-          try {
-            // Assemble cross-channel context to enrich the draft
-            let enrichedBody = opts?.threadContext
-              ? `${item.body}\n\n--- Thread Context ---\n${opts.threadContext}`
-              : item.body;
-
-            try {
-              const crossCtx = await assembleCrossChannelContextSingle({
-                personId: item.senderModel?.personId,
-                personName: item.senderName,
-                senderHandle: item.senderHandle,
-                topic: item.subject,
-                messageBody: item.body,
-                limit: 8,
-              });
-              item.crossChannelContext = crossCtx;
-              const crossCtxBlock = formatCrossChannelContextSingle(crossCtx);
-              if (crossCtxBlock) {
-                enrichedBody = `${enrichedBody}\n\n${crossCtxBlock}`;
-              }
-              this.log('info', 'cross_channel.complete', {
-                emails: crossCtx.emailHistory?.length || 0,
-                messages: crossCtx.messageHistory?.length || 0,
-                sessions: crossCtx.sessionContext?.length || 0,
-                facts: crossCtx.keyFacts?.length || 0,
-              });
-            } catch (ctxErr) {
-              // Non-fatal: context enrichment failure must not break drafting
-              this.log('warn', 'auto_draft.context_failed', {
-                messageId: item.id,
-                error: ctxErr instanceof Error ? ctxErr.message : String(ctxErr),
-              });
-            }
-
-            const secretaryContext = item.brief?.context || "";
-            const draftItem = {
-              id: item.id,
-              senderName: item.senderName,
-              senderHandle: item.senderHandle,
-              subject: item.subject,
-              body: (secretaryContext ? secretaryContext + "\n\n--- Message to reply to ---\n" : "") + enrichedBody,
-              platform: item.platform,
-              receivedAt: item.receivedAt,
-            };
-            const model = item.senderModel || {
-              name: item.senderName,
-              relationship: secretaryContext.match(/\*\*Relationship\*\*:\s*(.+)/)?.[1] || "",
-              communicationStyle: secretaryContext.match(/\*\*Style\*\*:\s*(.+)/)?.[1] || "",
-            };
-            const draftResult = await draftResponseSingle(draftItem, model as unknown as DraftModel);
-            item.autoDraft = draftResult.draft;
-            item.autoDraftModel = draftResult.modelId || 'amazon-bedrock';    // LLM model ID string
-            (item as any).autoDraftModelId = draftResult.modelId; // LLM model ID string
-          } catch (err) {
-            this.log('warn', 'auto_draft.failed', {
-              messageId: item.id,
-              error: err instanceof Error ? err.message : String(err),
-            });
-          }
-        }
-      }
-      timings.autoDraft = Date.now() - t6;
-
-      // Step 6: Brief
-      const t7 = Date.now();
-      const mentalModels = new Map<string, PersonMentalModel>();
-      for (const item of classified) {
-        if (item.senderModel?.personId) {
-          mentalModels.set(item.senderModel.personId, item.senderModel);
-        }
-      }
-      const singlePlatform = this.derivePlatform(classified);
-      const briefing = await generateBriefing({
-        batchId: this.correlationId,
-        platform: singlePlatform,
-        startedAt: new Date(startTime).toISOString(),
-        completedAt: new Date().toISOString(),
-        totalMessages: classified.length,
-        classified: classified.length,
-        items: classified,
-        stats,
-      }, mentalModels);
-      timings.brief = Date.now() - t7;
-
-      // Step 7: Learn
-      await this.learn(classified);
-
-      timings.total = Date.now() - startTime;
-
-      return {
-        success: true,
-        stats,
-        briefing: { markdown: briefing.markdown },
-        items: classified,
-        timings,
-      };
-    } catch (err) {
-      this.log('error', 'runSingle.failed', {
-        error: err instanceof Error ? err.message : String(err),
-      });
-      return {
-        success: false,
-        stats,
-        error: err instanceof Error ? err.message : String(err),
-        timings,
-      };
-    }
-  }
-
-  // -------------------------------------------------------------------------
-  // Private Methods
-  // -------------------------------------------------------------------------
-
-  private async fetchAll(since: Date, limit: number): Promise<RawMessage[]> {
-    const availableChannels: ChannelAdapter[] = [];
-    for (const channel of this.config.channels) {
-      if (!channel.available()) {
-        this.log('info', 'channel.skip', {
-          channel: channel.name,
-          reason: 'unavailable',
-        });
-      } else {
-        availableChannels.push(channel);
-      }
-    }
-
-    if (availableChannels.length === 0) {
-      throw new Error('No channels available');
-    }
-
-    const concurrency = Math.min(this.config.fetchConcurrency, availableChannels.length);
-    const results: PromiseSettledResult<RawMessage[]>[] =
-      // B2 fix: use raw config value (not clamped `concurrency`) to decide branch.
-      // `concurrency >= availableChannels.length` was always true because concurrency
-      // was already clamped by Math.min above — making the limit branch dead code.
-      this.config.fetchConcurrency >= availableChannels.length
-        ? await Promise.allSettled(
-            availableChannels.map(channel => channel.fetch(since, limit)),
-          )
-        : await this.fetchWithConcurrencyLimit(availableChannels, since, limit, concurrency);
-
-    const allMessages: RawMessage[] = [];
-    const errors: Array<{ channel: string; error: unknown }> = [];
-
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      if (result.status === 'fulfilled') {
-        allMessages.push(...result.value);
-        this.log('info', 'channel.fetch_complete', {
-          channel: availableChannels[i].name,
-          count: result.value.length,
-        });
-      } else {
-        errors.push({ channel: availableChannels[i].name, error: result.reason });
-        this.log('error', 'channel.fetch_failed', {
-          channel: availableChannels[i].name,
-          error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-        });
-      }
-    }
-
-    if (errors.length > 0 && errors.length === availableChannels.length) {
-      throw new Error(`All channels failed: ${errors.map(e => e.channel).join(', ')}`);
-    }
-
-    return allMessages;
-  }
-
-  private async fetchWithConcurrencyLimit(
-    channels: ChannelAdapter[],
-    since: Date,
-    limit: number,
-    concurrency: number,
-  ): Promise<PromiseSettledResult<RawMessage[]>[]> {
-    const results: PromiseSettledResult<RawMessage[]>[] = new Array(channels.length);
-    let cursor = 0;
-
-    async function worker(): Promise<void> {
-      while (cursor < channels.length) {
-        const idx = cursor++;
-        try {
-          const value = await channels[idx].fetch(since, limit);
-          results[idx] = { status: 'fulfilled', value };
-        } catch (reason) {
-          results[idx] = { status: 'rejected', reason };
-        }
-      }
-    }
-
-    const workers = Array.from({ length: concurrency }, () => worker());
-    await Promise.all(workers);
-    return results;
-  }
-
-  private async deduplicate(messages: RawMessage[], backfill = false): Promise<RawMessage[]> {
-    // Check which messages already exist in graph by rawId
-    const rawIds = messages.map(m => m.rawId);
-    if (rawIds.length === 0) return [];
-
-    try {
-      const { safeRead } = require('../safe-memgraph.js');
-
-      if (backfill) {
-        // In backfill mode: only skip emails that already have a non-empty body stored.
-        // Emails in the graph with empty/null body must be re-processed so Phase 3b can
-        // write the body back (654 existing nodes from Phase 2 have body='' placeholder).
-        const cypher = `
-          UNWIND $rawIds AS rawId
-          MATCH (e:Email {messageId: rawId})
-          WHERE e.body IS NOT NULL AND e.body <> ''
-          RETURN e.messageId AS rawId
-        `;
-        const existing = await safeRead(cypher, { rawIds });
-        const hasBodySet = new Set(existing.map((r: any) => r.rawId));
-
-        const unique = messages.filter(m => !hasBodySet.has(m.rawId));
-        this.log('info', 'deduplicate.complete', {
-          total: messages.length,
-          existingWithBody: hasBodySet.size,
-          unique: unique.length,
-          mode: 'backfill-body-aware',
-        });
-        return unique;
-      }
-
-      // Normal mode: skip any message whose rawId already has an Episode node
-      const cypher = `
-        UNWIND $rawIds AS rawId
-        MATCH (e:Episode {rawId: rawId})
-        RETURN e.rawId AS rawId
-      `;
-      const existing = await safeRead(cypher, { rawIds });
-      const existingSet = new Set(existing.map((r: any) => r.rawId));
-
-      const unique = messages.filter(m => !existingSet.has(m.rawId));
-      this.log('info', 'deduplicate.complete', {
-        total: messages.length,
-        existing: existingSet.size,
-        unique: unique.length,
-      });
-      return unique;
-    } catch (err) {
-      this.log('warn', 'deduplicate.failed', {
-        error: err instanceof Error ? err.message : String(err),
-        fallback: 'processing all messages',
-      });
-      return messages;
-    }
-  }
-
-  private async extractBatch(
-    messages: RawMessage[],
-  ): Promise<Array<{ id: string; extraction: MessageExtraction; error?: string }>> {
-    const inputs = messages.map(m => ({
-      id: m.id,
-      text: `Subject: ${m.subject}\n\n${m.body}`,
-      context: { senderName: m.senderName, platform: m.platform },
-    }));
-
-    return await extractEntitiesBatch(inputs, this.config.extractionConcurrency);
-  }
-
-  private async persistMessageBodies(messages: RawMessage[]): Promise<void> {
-    if (!this.config.persistBodies) return;
-    const { safeWrite } = require('../safe-memgraph.js');
-
-    const bodyUpdates = messages
-      .filter(m => m.rawId && m.body && m.body.length > 10 && !m.body.includes('[Draft unavailable'))
-      .map(m => ({ messageId: m.rawId, body: m.body.slice(0, 65536), bodyLength: m.body.length }));
-
-    if (bodyUpdates.length === 0) return;
-
-    const CHUNK = 100;
-    for (let i = 0; i < bodyUpdates.length; i += CHUNK) {
-      const chunk = bodyUpdates.slice(i, i + CHUNK);
-      await safeWrite(
-        `UNWIND $batch AS item
-         MATCH (e:Email {messageId: item.messageId})
-         SET e.body = item.body, e.bodyLength = item.bodyLength,
-             e.bodyStored = true, e.bodyStoredAt = datetime({timezone:'UTC'})`,
-        { batch: chunk }
-      );
-    }
-    this.log('info', 'pipeline.bodies_persisted', { count: bodyUpdates.length });
-  }
-
-  private async persistBatch(
-    messages: RawMessage[],
-    extractions: Array<{ id: string; extraction: MessageExtraction; error?: string }>,
-  ): Promise<Array<{ message: RawMessage; extraction: MessageExtraction; personId: string }>> {
-    // Split into chunks
-    const chunks: RawMessage[][] = [];
-    for (let i = 0; i < messages.length; i += this.config.batchSize) {
-      chunks.push(messages.slice(i, i + this.config.batchSize));
-    }
-
-    // Run chunks in parallel, limited by persistConcurrency
-    const concurrency = this.config.persistConcurrency ?? 3;
-    const results: Array<Array<{ message: RawMessage; extraction: MessageExtraction; personId: string }>> = new Array(chunks.length);
-
-    // Process in groups of `concurrency`
-    for (let i = 0; i < chunks.length; i += concurrency) {
-      const group = chunks.slice(i, i + concurrency);
-      const groupResults = await Promise.all(
-        group.map((chunk) => this.persistBatchChunk(chunk, extractions)),
-      );
-      groupResults.forEach((r, j) => { results[i + j] = r; });
-    }
-
-    return results.flat();
-  }
-
-  private async persistBatchChunk(
-    batch: RawMessage[],
-    extractions: Array<{ id: string; extraction: MessageExtraction; error?: string }>,
-  ): Promise<Array<{ message: RawMessage; extraction: MessageExtraction; personId: string }>> {
-    const extractionMap = new Map(extractions.map(e => [e.id, e.extraction]));
-    const results: Array<{ message: RawMessage; extraction: MessageExtraction; personId: string }> = [];
-
-    // Step 1: Resolve identities
-    const identityResolutions = await Promise.all(
-      batch.map(m => resolveIdentity(m.senderHandle, m.platform, { displayName: m.senderName })),
-    );
-
-    // Step 2: Batch persist persons
-    const personBatch = identityResolutions
-      .map((r, idx) => r?.personId ? {
-        id: r.personId,
-        name: r.identity?.displayName || batch[idx].senderName || batch[idx].senderHandle,
-      } : null)
-      .filter((x): x is NonNullable<typeof x> => x !== null);
-    if (personBatch.length > 0) {
-      await persistPersonsBatch(personBatch);
-    }
-
-    // Step 3: Batch persist identities
-    const identityBatch = identityResolutions
-      .map(r => r?.identity ? {
-        id: r.identity.id,
-        handle: r.identity.handle,
-        platform: r.identity.platform,
-        displayName: r.identity.displayName,
-        verified: r.identity.verified,
-        personId: r.personId,
-      } : null)
-      .filter((x): x is NonNullable<typeof x> => x !== null);
-    if (identityBatch.length > 0) {
-      await persistIdentitiesBatch(identityBatch);
-    }
-
-    // Step 4: Batch persist conversations
-    const conversationBatch = batch.map(m => ({
-      id: `conv:${m.platform}:${m.threadId}`,
-      platform: m.platform,
-      threadId: m.threadId || '',
-      isGroup: m.isGroup || false,
-      lastMessageAt: m.receivedAt || new Date().toISOString(),
-      startedAt: m.receivedAt || new Date().toISOString(),
-    }));
-    if (conversationBatch.length > 0) {
-      await persistConversationsBatch(conversationBatch);
-    }
-
-    // Step 5: Batch persist episodes
-    const episodeBatch = batch
-      .map((m, idx) => {
-        const resolution = identityResolutions[idx];
-        if (!resolution?.personId) return null;
-        const extraction = extractionMap.get(m.id);
-        if (!extraction) return null;
-
-        return {
-          id: `ep-${m.platform}-${m.id}`,
-          text: `Subject: ${m.subject}\n\n${m.body}`,
-          platform: m.platform,
-          direction: (m.direction ?? 'inbound') as 'inbound' | 'outbound',
-          receivedAt: m.receivedAt,
-          messageType: extraction.messageType,
-          urgency: extraction.urgency,
-          sentiment: extraction.sentiment,
-          extractionCost: extraction.cost,
-          rawId: m.rawId,
-          labels: m.labels || [],
-          personId: resolution.personId,
-          conversationId: `conv:${m.platform}:${m.threadId}`,
-          subject: m.subject,
-          threadId: m.threadId,
-        };
-      })
-      .filter((e): e is NonNullable<typeof e> => e !== null);
-
-    if (episodeBatch.length > 0) {
-      await persistEpisodesBatch(episodeBatch);
-      this.checkExtractionTriggers(episodeBatch.map(e => e.personId));
-    }
-
-    // Step 6: Batch persist extractions (topics, questions, commitments)
-    const extractionBatch = batch
-      .map((m, idx) => {
-        const resolution = identityResolutions[idx];
-        if (!resolution?.personId) return null;
-        const extraction = extractionMap.get(m.id);
-        if (!extraction) return null;
-
-        // Generate IDs for extracted entities
-        const topicId = (name: string) => this._topicId(resolution.personId, name);
-        const contentId = (prefix: string, text: string) => this._contentId(prefix, resolution.personId, text);
-
-        return {
-          episodeId: `ep-${m.platform}-${m.id}`,
-          personId: resolution.personId,
-          extraction: {
-            topics: extraction.topics.map(t => ({
-              id: topicId(t.name),
-              name: t.name,
-              category: t.category,
-              sentiment: t.sentiment,
-            })),
-            questions: extraction.questions.map(q => ({
-              id: contentId('q', q.text),
-              text: q.text,
-              intent: q.intent,
-              urgency: q.urgency,
-            })),
-            commitments: extraction.commitments.map(c => ({
-              id: contentId('c', c.text),
-              text: c.text,
-              owner: c.owner,
-              dueDate: c.dueDate,
-              direction: c.direction,
-              confidence: c.confidence,
-              platform: m.platform,
-            })),
-          },
-        };
-      })
-      .filter((e): e is NonNullable<typeof e> => e !== null);
-
-    if (extractionBatch.length > 0) {
-      await persistExtractionsBatch(extractionBatch);
-    }
-
-    // Build results
-    let droppedCount = 0;
-    for (let idx = 0; idx < batch.length; idx++) {
-      const message = batch[idx];
-      const resolution = identityResolutions[idx];
-      const extraction = extractionMap.get(message.id);
-
-      if (resolution?.personId && extraction) {
-        results.push({
-          message,
-          extraction,
-          personId: resolution.personId,
-        });
-      } else {
-        droppedCount++;
-        this.log('warn', 'item.dropped', {
-          messageId: message.id,
-          reason: !resolution?.personId ? 'no_person_id' : 'no_extraction',
-        });
-      }
-    }
-
-    if (droppedCount > 0) {
-      this.log('warn', 'batch.dropped_summary', { droppedCount, batchSize: batch.length });
-    }
-
-    return results;
-  }
-
-  private async assembleModels(
-    items: Array<{ message: RawMessage; extraction: MessageExtraction; personId: string }>,
-  ): Promise<Array<{ message: RawMessage; extraction: MessageExtraction; model: PersonMentalModel }>> {
-    // Fix: bounded concurrency — each assembleMentalModel fires 13 parallel safeRead
-    // queries. With N items all running simultaneously, the Memgraph query semaphore
-    // (48 slots, 500 queue limit) saturates. Process MODEL_ASSEMBLY_CONCURRENCY items
-    // at a time so max inflight queries = MODEL_ASSEMBLY_CONCURRENCY × 13.
-    // At concurrency=5: max 65 queries — well within the 48-slot semaphore.
-    const MODEL_ASSEMBLY_CONCURRENCY = parseInt(process.env.TRIAGE_MODEL_CONCURRENCY || '5', 10);
-
-    const results: Array<{ message: RawMessage; extraction: MessageExtraction; model: PersonMentalModel }> = [];
-
-    for (let i = 0; i < items.length; i += MODEL_ASSEMBLY_CONCURRENCY) {
-      const batch = items.slice(i, i + MODEL_ASSEMBLY_CONCURRENCY);
-      const settled = await Promise.allSettled(batch.map(async item => {
-        const model = await assembleMentalModel(item.personId);
-        return { ...item, model };
-      }));
-      settled.forEach((r: any) => {
-        if (r.status === 'fulfilled') {
-          results.push(r.value);
-        } else {
-          this.log('warn', 'assemble.failed', { error: r.reason?.message });
-        }
-      });
-    }
-
-    return results;
-  }
-
-  private async classify(
-    items: Array<{ message: RawMessage; extraction: MessageExtraction; model: PersonMentalModel }>,
-  ): Promise<TriageItem[]> {
-    const settled = await Promise.allSettled(items.map(async item => {
-      const triageItem: TriageItem = {
-        id: item.message.id,
-        rawId: item.message.rawId,
-        threadId: item.message.threadId,
-        platform: item.message.platform,
-        senderHandle: item.message.senderHandle,
-        senderName: item.message.senderName,
-        subject: item.message.subject,
-        body: item.message.body,
-        snippet: (item.message.body ?? '').slice(0, 200),
-        receivedAt: item.message.receivedAt,
-        direction: item.message.direction ?? 'inbound',
-        isGroup: item.message.isGroup,
-        // These will be filled by classifier
-        priority: 'P3',
-        category: 'fyi',
-        suggestedAction: 'archive',
-        confidence: 0,
-        compositeScore: 0,
-        signals: [],
-        senderModel: item.model,
-        extraction: item.extraction,
-        classifiedAt: new Date().toISOString(),
-        classifierVersion: '1.0.0',
-      };
-      // Run classifier — pass mentalModel as 2nd arg, config as 3rd
-      const result = await classifyWithContext(triageItem, item.model, {});
-      return { ...triageItem, ...result };
-    }));
-    return settled
-      .filter((r): r is PromiseFulfilledResult<any> => r.status === 'fulfilled')
-      .map(r => r.value);
-  }
-
-  private async learn(items: TriageItem[]): Promise<void> {
-    // B3+B4+B5 fix: replaced serial for...of with Promise.allSettled — all recordDecision
-    // calls now run in parallel instead of blocking each other.
-    // FIX2: recordDecision() is synchronous (returns void). The map just calls it for
-    // each item; Promise.allSettled wraps void values. flushDecisions() runs ONCE after
-    // all decisions are recorded, fire-and-forget so it does not block the pipeline.
-    items.forEach(item =>
-      recordDecision({
-        messageId: item.id,
-        senderHandle: item.senderHandle,
-        platform: item.platform,
-        suggestedPriority: item.priority,
-        actualPriority: null,
-        suggestedAction: item.suggestedAction,
-        actualAction: null,
-        agreedWithSuggestion: null,
-        signals: item.signals,
-        timestamp: new Date().toISOString(),
-      })
-    );
-    // Fire-and-forget: flushDecisions does async disk I/O; do not await in hot path.
-    setImmediate(() => { flushDecisions().catch(err => { /* non-fatal */ }); });
-  }
-
-  // C5: Moved outside map() to avoid re-creating function objects per row
-  private derivePlatform(items: TriageItem[]): string {
-    const platforms = [...new Set(items.map(i => i.platform).filter(Boolean))];
-    return platforms.length === 1 ? platforms[0] : platforms.length > 1 ? 'multi' : 'email';
-  }
-
-  private _topicId(personId: string, name: string): string {
-    const input = `${personId}::${name.toLowerCase().trim()}`;
-    return `topic-${createHash('sha256').update(input).digest('hex').slice(0, 16)}`;
-  }
-
-  private _contentId(prefix: string, personId: string, text: string): string {
-    const input = `${personId}::${text.toLowerCase().trim().slice(0, 200)}`;
-    return `${prefix}-${createHash('sha256').update(input).digest('hex').slice(0, 16)}`;
-  }
-
-  private checkExtractionTriggers(personIds: string[]): void {
-    const selfId = process.env.HELIOS_SELF_ID || '';
-    if (!selfId) {
-      this.log('warn', 'self_id.missing', { fn: 'checkExtractionTriggers' });
-      return; // early exit, not fatal
-    }
-    const unique = [...new Set(personIds.filter(id => id && id !== selfId))];
-    if (unique.length === 0) return;
-
-    const EXTRACTION_INTERVAL = 10;
-
-    // B8 fix: wrap async IIFE so rejection is explicitly caught — prevents
-    // unhandled rejection if setImmediate's inner async throws after the
-    // outer synchronous call returns.
-    setImmediate(() => {
-      (async () => {
-      try {
-        const { rawRead: reader, rawWrite: writer } = require('../safe-memgraph.js');
-        const rows = await reader(`
-          MATCH (:Person {id: $selfId})-[k:KNOWS]->(p:Person)
-          WHERE p.id IN $pids AND k.episodeCount IS NOT NULL
-            AND toInteger(k.episodeCount) % toInteger($interval) = 0
-            AND (k.lastExtractionAt IS NULL OR k.lastMessageAt > k.lastExtractionAt)
-          RETURN p.id AS pid, k.episodeCount AS count
-        `, { selfId, pids: unique, interval: EXTRACTION_INTERVAL });
-
-        if (rows.length === 0) return;
-
-        const { extractKeyFacts } = await import('./mental-model/key-facts.ts');
-        for (const row of rows) {
-          try {
-            await extractKeyFacts(row.pid as string);
-            await writer(`
-              MATCH (:Person {id: $selfId})-[k:KNOWS]->(p:Person {id: $pid})
-              SET k.lastExtractionAt = datetime()
-            `, { selfId, pid: row.pid });
-          } catch { /* fail-open per contact */ }
-        }
-        this.log('info', 'extraction.triggered', { persons: rows.length });
-      } catch { /* fail-open: extraction triggers are advisory */ }
-      })().catch(() => { /* fail-open: extraction triggers are advisory */ });
-    });
-  }
-
-  private async cache(briefing: CachedBriefing): Promise<void> {
-    try {
-      await fs.promises.mkdir(this.config.cacheDir, { recursive: true });
-      const cachePath = path.join(this.config.cacheDir, BRIEFING_CACHE_FILE);
-      try {
-        await this.enrichBriefingWithSecretary(cachePath, briefing);
-      } catch {
-        // enrichment failed — write un-enriched as fallback
-        const tmp = cachePath + '.tmp';
-        await fs.promises.writeFile(tmp, JSON.stringify(briefing, null, 2));
-        await fs.promises.rename(tmp, cachePath);
-      }
-    } catch (err) {
-      this.log('warn', 'cache.write_failed', {
-        error: err instanceof Error ? err.message : String(err),
-      });
-    }
-  }
-
-  private async enrichBriefingWithSecretary(cachePath: string, briefing: CachedBriefing): Promise<void> {
-    try {
-      const { rawRead } = require('../safe-memgraph.js');
-      let md = briefing.markdown || '';
-      const selfId = process.env.HELIOS_SELF_ID || '';
-      if (!selfId) {
-        this.log('warn', 'self_id.missing', { fn: 'enrichBriefingWithSecretary' });
-        return; // early exit, not fatal
-      }
-
-      if (!md.includes('<!-- active-situations -->')) {
-        // NOTE: briefing.markdown uses emoji. All consumers must parse as UTF-8.
-        // For machine-only consumers, consider passing { noEmoji: true } option.
-        const sits = await rawRead(`MATCH (s:Situation) WHERE s.state IN ['escalating','active','new']
-          RETURN s.name AS name, s.state AS state, s.participantCount AS p
-          ORDER BY CASE s.state WHEN 'escalating' THEN 0 WHEN 'active' THEN 1 ELSE 2 END LIMIT toInteger(7)`, {});
-        if (sits?.length > 0) {
-          const block = ['<!-- active-situations -->\n\n### 🧠 Active Situations\n'];
-          for (const s of sits) block.push(`- ${s.state === 'escalating' ? '🔴' : '🟡'} **${s.name}** [${s.state}] — ${s.p} contacts`);
-          md = block.join('\n') + '\n' + md;
-        }
-      }
-
-      if (!md.includes('<!-- cos-suggestions -->')) {
-        const sugs = await rawRead(`MATCH (s:CoSSuggestion) WHERE datetime(s.sentAt) > datetime() - duration('P7D')
-          RETURN s.content AS content, s.priority AS prio ORDER BY s.sentAt DESC LIMIT toInteger(5)`, {});
-        if (sugs?.length > 0) {
-          const block = ['<!-- cos-suggestions -->\n\n### 🤖 Chief of Staff\n'];
-          for (const s of sugs) block.push(`- [${s.prio}] ${s.content?.slice(0, 80) ?? 'suggestion'}`);
-          md += block.join('\n') + '\n';
-        }
-      }
-
-      if (!md.includes('<!-- reconnection-alerts -->')) {
-        const recon = await rawRead(`MATCH (:Person {id: $selfId})-[k:KNOWS]-(p:Person)
-          WHERE p.dunbarLayer IN ['intimate','close'] AND k.lastMessageAt IS NOT NULL
-            AND datetime(k.lastMessageAt) < datetime() - duration('P14D')
-          RETURN p.name AS name, p.dunbarLayer AS layer, toString(k.lastMessageAt) AS lma
-          ORDER BY k.lastMessageAt ASC LIMIT toInteger(5)`, { selfId });
-        if (recon?.length > 0) {
-          const block = ['<!-- reconnection-alerts -->\n\n### 💤 Reconnection Alerts\n'];
-          for (const r of recon) {
-            const days = Math.floor((Date.now() - new Date(r.lma).getTime()) / 86400000);
-            if (!r.lma || isNaN(days)) continue; // skip if date unparseable
-            block.push(`- **${r.name}** (${r.layer}) — ${days}d silent`);
-          }
-          md += block.join('\n') + '\n';
-        }
-      }
-
-      if (md !== briefing.markdown) {
-        briefing.markdown = md;
-      }
-
-      // Promote high-priority CoS suggestions into unified inbox (draftItems)
-      const highSugs = await rawRead(`MATCH (s:CoSSuggestion) WHERE datetime(s.sentAt) > datetime() - duration('P7D') AND s.priority IN ['high','medium']
-        RETURN s.type AS type, s.content AS content, s.priority AS prio, s.personId AS pid, toString(s.sentAt) AS sent
-        ORDER BY CASE s.priority WHEN 'high' THEN 0 ELSE 1 END, s.sentAt DESC LIMIT toInteger(3)`, {});
-      if (highSugs?.length > 0) {
-        if (!briefing.draftItems) briefing.draftItems = [];
-        for (const s of highSugs) {
-          const exists = briefing.draftItems.some(d => d.id === `cos-${s.type}-${s.sent?.slice(0,16)}`);
-          if (!exists) {
-            briefing.draftItems.unshift({
-              id: `cos-${s.type}-${s.sent?.slice(0,16)}`,
-              subject: s.content?.slice(0, 80) ?? `[${s.type}] detected`,
-              senderName: '🤖 Chief of Staff',
-              senderHandle: `cos://${s.type}`,
-              priority: s.prio === 'high' ? 'P0' : 'P1',
-            });
-          }
-        }
-        if (!briefing.stats) briefing.stats = {
-          // B10 fix: complete TriageStats object — no `as any` cast needed.
-          p0Count: 0, p1Count: 0, p2Count: 0, p3Count: 0,
-          vipPending: 0, avgResponseLag: null, estimatedTimeSaved: 0, extractionCostTotal: 0,
-        };
-        const cosP0 = briefing.draftItems.filter(d => d.senderHandle?.startsWith('cos://') && d.priority === 'P0').length;
-        const cosP1 = briefing.draftItems.filter(d => d.senderHandle?.startsWith('cos://') && d.priority === 'P1').length;
-        briefing.stats.p0Count = (briefing.stats.p0Count ?? 0) + cosP0;
-        briefing.stats.p1Count = (briefing.stats.p1Count ?? 0) + cosP1;
-      }
-
-      // B1: Single atomic write after all enrichment sections are built
-      const tmp = cachePath + '.tmp';
-      await fs.promises.writeFile(tmp, JSON.stringify(briefing, null, 2));
-      await fs.promises.rename(tmp, cachePath);
-    } catch (err) { this.log('warn', 'briefing.enrich_failed', { error: err instanceof Error ? err.message : String(err) }); }
-  }
-
-  private async cacheInbox(classified: TriageItem[], stats: TriageStats): Promise<void> {
-    // Resolve "Unknown" sender names from graph identity mappings
-    try {
-      const { rawRead } = require('../safe-memgraph.js');
-      const unknowns = classified.filter(i => !i.senderName || i.senderName === 'Unknown' || i.senderName === i.senderHandle);
-      if (unknowns.length > 0) {
-        const handles = unknowns.map(i => i.senderHandle).filter(Boolean);
-        const resolved = await rawRead(`
-          UNWIND $handles AS h
-          OPTIONAL MATCH (p:Person)-[:HAS_IDENTITY]->(i:Identity {handle: h})
-          RETURN h AS handle, p.name AS name
-        `, { handles });
-        const nameMap = new Map<string, string>();
-        for (const r of resolved ?? []) {
-          if (r.name && r.name !== r.handle) nameMap.set(r.handle, r.name);
-        }
-        for (const item of unknowns) {
-          const better = nameMap.get(item.senderHandle);
-          if (better) { item.senderName = better; continue; }
-          if (item.senderHandle?.includes('@')) {
-            const local = item.senderHandle.split('@')[0];
-            // B12: Skip automated/no-reply senders — their local parts are not human names
-            const AUTOMATED_LOCALS = new Set(['no-reply','noreply','do-not-reply','donotreply','postmaster','mailer-daemon','automated','notifications']);
-            if (AUTOMATED_LOCALS.has(local.toLowerCase())) continue; // skip automated senders
-            const parts = local.split(/[._-]/).filter((p: string) => p.length > 1);
-            if (parts.length >= 2) {
-              item.senderName = parts.map((p: string) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join(' ');
-            }
-          }
-        }
-      }
-    } catch (err) { this.log('debug', 'inbox.name_resolve_failed', { error: err instanceof Error ? err.message : String(err) }); }
-
-    const mapActionType = (priority: string): string => {
-      switch (priority) {
-        case 'P0': return 'reply';
-        case 'P1': return 'review';
-        case 'P2': return 'watch';
-        default: return 'watch';
-      }
-    };
-
-    const mapItem = (item: TriageItem) => {
-      // Get FAVEE from strongest directConnection
-      const strongestConn = (item.senderModel as any)?.directConnections
-        ?.reduce((best: any, c: any) => (!best || (c.strength ?? 0) > (best.strength ?? 0)) ? c : best, null);
-      const faveeRaw = strongestConn?.favee;
-
-      return {
-        id: item.id,
-        rawId: item.rawId,
-        threadId: item.threadId,
-        platform: item.platform,
-        senderName: item.senderName,
-        senderHandle: item.senderHandle,
-        subject: item.subject,
-        snippet: (item.body ?? '').slice(0, 200),  // short preview only
-        body: item.body ?? '',           // full body — not truncated
-        receivedAt: item.receivedAt,
-        priority: item.priority,
-        suggestedAction: item.suggestedAction,
-        confidence: item.confidence,
-        openCommitments: (item as any).openCommitments ?? null,
-        signals: item.signals,
-        secretaryBrief: `${item.senderName} re: ${item.subject} — ${item.suggestedAction}`,
-        brief: {
-          action: item.suggestedAction || (item as any).secretaryBrief?.split('.')[0]?.trim() || `Review message from ${item.senderName}`,
-          action_type: mapActionType(item.priority),
-          timeframe: item.priority === 'P0' ? 'within 1 hour' : item.priority === 'P1' ? 'today' : null,
-          why: `${item.senderName} re: ${item.subject} — ${item.suggestedAction}`,
-          context: (item.senderModel as any)?.contextBrief || null,
-          landmine: null,
-        },
-        isGroup: item.isGroup ?? false,
-        labels: item.labels ?? [],
-        autoDraft: item.autoDraft ?? null,
-        dunbarLayer: (item.senderModel && item.senderModel.dunbarLayer != null)
-          ? item.senderModel.dunbarLayer
-          : null,
-        favee: faveeRaw ? {
-          formality: Math.max(0, Math.min(1, faveeRaw.formality ?? 0)),
-          activeness: Math.max(0, Math.min(1, faveeRaw.activeness ?? 0)),
-          valence: Math.max(0, Math.min(1, faveeRaw.valence ?? 0)),
-          exchange: Math.max(0, Math.min(1, faveeRaw.exchange ?? 0)),
-          equality: Math.max(0, Math.min(1, faveeRaw.equality ?? 0)),
-        } : null,
-        // personId — enables desktop profile popover lookups
-        personId: (item.senderModel as any)?.personId ?? null,
-      };
-    };
-
-    const inboxCache = {
-      generatedAt: new Date().toISOString(),
-      sections: {
-        actionRequired: classified.filter(i => i.priority === 'P0').map(mapItem),
-        reviewToday: classified.filter(i => i.priority === 'P1').map(mapItem),
-        fyi: classified.filter(i => i.priority === 'P2').map(mapItem),
-        lowPriority: classified.filter(i => i.priority === 'P3').map(mapItem),
-        other: [] as ReturnType<typeof mapItem>[],
-      },
-      stats: {
-        p0Count: stats.p0Count,
-        p1Count: stats.p1Count,
-        p2Count: stats.p2Count,
-        p3Count: stats.p3Count,
-        vipPending: stats.vipPending,
-        avgResponseLag: stats.avgResponseLag,
-        estimatedTimeSaved: stats.estimatedTimeSaved,
-        extractionCostTotal: stats.extractionCostTotal,
-      },
-    };
-
-    await fs.promises.mkdir(this.config.cacheDir, { recursive: true });
-    const inboxPath = path.join(this.config.cacheDir, 'latest-inbox.json');
-
-    // MERGE: Read existing items, keep non-duplicate items not older than 30 days (evict stale items)
-    try {
-      let existingRaw: string | null = null;
-      try { existingRaw = await fs.promises.readFile(inboxPath, 'utf-8'); } catch { /* file not yet created */ }
-      if (existingRaw) {
-        const existing = JSON.parse(existingRaw);
-        const newIds = new Set(classified.map(i => i.id));
-        // B13: Evict items older than 30 days to prevent unbounded cache growth
-        const MAX_INBOX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
-        const cutoff = new Date(Date.now() - MAX_INBOX_AGE_MS).toISOString();
-        for (const [section, items] of Object.entries(existing.sections || {})) {
-          if (!Array.isArray(items)) continue;
-          for (const item of items) {
-            if (newIds.has(item.id)) continue;
-            // Evict items older than 30 days
-            if (item.receivedAt && item.receivedAt < cutoff) continue;
-            // B13: Derive the target section from the item's current priority, not its stored
-            // section key. Old items may have been re-classified at a different priority level
-            // since they were cached — inserting them into the wrong section would corrupt the inbox.
-            const sectionFromPriority: Record<string, keyof typeof inboxCache.sections> = {
-              P0: 'actionRequired', P1: 'reviewToday', P2: 'fyi', P3: 'lowPriority',
-            };
-            const targetSection: keyof typeof inboxCache.sections =
-              (item.priority && sectionFromPriority[item.priority]) || 'other';
-            (inboxCache.sections[targetSection] as any[]).push(item);
-          }
-        }
-        const allItems = Object.values(inboxCache.sections).flat();
-        inboxCache.stats.p0Count = allItems.filter((i: any) => i.priority === 'P0').length;
-        inboxCache.stats.p1Count = allItems.filter((i: any) => i.priority === 'P1').length;
-        inboxCache.stats.p2Count = allItems.filter((i: any) => i.priority === 'P2').length;
-        inboxCache.stats.p3Count = allItems.filter((i: any) => i.priority === 'P3').length;
-      }
-    } catch (_) { /* first run or corrupted file — proceed with new data only */ }
-
-    // Persist to graph as InboxItem nodes (accumulate across file resets)
-    try {
-      const { rawWrite } = require('../safe-memgraph.js');
-      const allMapped = Object.values(inboxCache.sections).flat();
-      if (allMapped.length > 0) {
-        const items = allMapped.map((item: any) => ({
-          id: item.id,
-          platform: item.platform || 'email',
-          senderName: item.senderName || '',
-          senderHandle: item.senderHandle || '',
-          subject: item.subject || '',
-          snippet: (item.snippet || '').slice(0, 200),
-          body: item.body || '',
-          receivedAt: item.receivedAt || new Date().toISOString(),
-          priority: item.priority || 'P2',
-          suggestedAction: item.suggestedAction || 'review',
-          confidence: item.confidence || 0.5,
-          signalsJson: JSON.stringify(item.signals ?? []),
-          dunbarLayer: item.dunbarLayer ?? null,
-          autoDraft: item.autoDraft ?? null,
-          brief: item.brief ? JSON.stringify(item.brief) : null,
-          replyChannel: item.replyChannel ?? item.platform ?? 'email',
-          isGroup: item.isGroup ?? false,
-          labelsJson: JSON.stringify(item.labels ?? []),
-        })).filter((i: any) => i.id);
-        await rawWrite(
-          `UNWIND $items AS item
-           MERGE (i:InboxItem {id: item.id})
-           SET i.senderHandle = item.senderHandle,
-               i.senderName = item.senderName,
-               i.subject = item.subject,
-               i.snippet = item.snippet,
-               i.body = item.body,
-               i.priority = item.priority,
-               i.platform = item.platform,
-               i.receivedAt = item.receivedAt,
-               i.state = coalesce(i.state, 'unread'),
-               i.suggestedAction = item.suggestedAction,
-               i.createdAt = coalesce(i.createdAt, toString(datetime({timezone:'UTC'}))),
-               i.updatedAt = CASE WHEN i.priority IS NULL OR i.priority <> item.priority
-                                   OR i.suggestedAction IS NULL OR i.suggestedAction <> item.suggestedAction
-                                   OR i.createdAt IS NULL
-                                   THEN toString(datetime({timezone:'UTC'}))
-                                   ELSE i.updatedAt END`,
-          { items }
-        );
-      }
-    } catch (err) {
-      this.log('warn', 'inbox_graph.write_failed', {
-        error: err instanceof Error ? err.message : String(err),
-      });
-    }
-
-    const tmpPath = inboxPath + '.tmp';
-    await fs.promises.writeFile(tmpPath, JSON.stringify(inboxCache, null, 2));
-    await fs.promises.rename(tmpPath, inboxPath);
-  }
-
-  private log(level: string, operation: string, meta: Record<string, unknown> = {}): void {
-    const entry = {
-      ts: new Date().toISOString(),
-      level,
-      correlation_id: this.correlationId,
-      op: operation,
-      ...meta,
-    };
-    this.config.log(JSON.stringify(entry));
-  }
-}