@cgh567/agent 2.4.3 → 2.4.5

package/lib/triage-core/mental-model/bedrock-config.ts

@@ -37,3 +37,81 @@ export const ROLE_INFERENCE_MODEL_ID = validateAndFallback(
 export const KEY_FACTS_MODEL_ID = validateAndFallback(
   process.env.KEY_FACTS_MODEL_ID || DEFAULT_KEY_FACTS_MODEL, 'KEY_FACTS_MODEL_ID', DEFAULT_KEY_FACTS_MODEL
 );
+
+// Phase 8B: Triage provider config
+export function getTriageProviderConfig(): { provider: string; model: string } {
+  // Read from settings.json triage block if available
+  try {
+    const settingsPath = process.env.HELIOS_SETTINGS_PATH ?? require('path').join(require('os').homedir(), '.helios', 'settings.json');
+    if (require('fs').existsSync(settingsPath)) {
+      const settings = JSON.parse(require('fs').readFileSync(settingsPath, 'utf-8'));
+      if (settings?.triage?.provider) {
+        return { provider: settings.triage.provider, model: settings.triage.model ?? 'auto' };
+      }
+    }
+  } catch { /* fall through to env vars */ }
+
+  return {
+    provider: process.env.HELIOS_TRIAGE_PROVIDER ?? 'local',
+    model: process.env.HELIOS_TRIAGE_MODEL ?? 'Qwen3-0.6B-Q4_K_M.gguf',
+  };
+}
+
+export const TRIAGE_PROVIDER = process.env.HELIOS_TRIAGE_PROVIDER ?? 'local';
+export const TRIAGE_MODEL = process.env.HELIOS_TRIAGE_MODEL ?? 'Qwen3-0.6B-Q4_K_M.gguf';
+
+// H10 fix: provide createExtractionClient so triage-llm-factory Tier 1 (cloud) path works.
+// Returns an ExtractionLLM adapter backed by the configured Bedrock/Anthropic/OpenAI client.
+export async function createExtractionClient(provider: string): Promise<import('../triage-local-llm.ts').ExtractionLLM | null> {
+  try {
+    switch (provider) {
+      case 'amazon-bedrock': {
+        const { BedrockRuntimeClient, InvokeModelCommand } = require('@aws-sdk/client-bedrock-runtime');
+        const client = new BedrockRuntimeClient({ region: process.env.AWS_REGION ?? 'us-east-1' });
+        return {
+          async call({ systemPrompt, userMessage }) {
+            const body = JSON.stringify({
+              anthropic_version: 'bedrock-2023-05-31',
+              max_tokens: 256,
+              temperature: 0.1,
+              system: systemPrompt,
+              messages: [{ role: 'user', content: userMessage }],
+            });
+            const cmd = new InvokeModelCommand({
+              modelId: EXTRACTION_MODEL_ID,
+              contentType: 'application/json',
+              accept: 'application/json',
+              body,
+            });
+            const response = await client.send(cmd);
+            const parsed = JSON.parse(new TextDecoder().decode(response.body));
+            const content = parsed?.content?.[0]?.text ?? '';
+            const inputTokens = parsed?.usage?.input_tokens ?? 0;
+            const outputTokens = parsed?.usage?.output_tokens ?? 0;
+            return { content, inputTokens, outputTokens };
+          },
+        };
+      }
+      case 'anthropic': {
+        const Anthropic = require('@anthropic-ai/sdk').default ?? require('@anthropic-ai/sdk');
+        const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+        return {
+          async call({ systemPrompt, userMessage }) {
+            const response = await client.messages.create({
+              model: 'claude-haiku-4-5-20251001',
+              max_tokens: 256, temperature: 0.1,
+              system: systemPrompt,
+              messages: [{ role: 'user', content: userMessage }],
+            });
+            const content = response.content?.[0]?.text ?? '';
+            return { content, inputTokens: response.usage?.input_tokens ?? 0, outputTokens: response.usage?.output_tokens ?? 0 };
+          },
+        };
+      }
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}

package/lib/triage-core/mental-model/cos-integration.ts

@@ -251,7 +251,7 @@ async function queryRelationshipStrength(personId: string): Promise<number> {
     `, { selfId: process.env.HELIOS_SELF_ID || '__SELF_ID_NOT_SET__', pid: personId });
     if (!result?.[0]) return 0.3;
     const { layer, msgs, health } = result[0];
-    const layerScore: Record<string, number> = { intimate: 1.0, close: 0.8, friend: 0.6, acquaintance: 0.3 };
+    const layerScore: Record<string, number> = { intimate: 1.0, close: 0.8, friend: 0.6, active: 0.4, recognized: 0.2 };
     const base = (layerScore[layer as string] ?? 0.2) * 0.6 + Math.min(1.0, Number(msgs || 0) / 500) * 0.4;
     return health === 'UNHEALTHY' ? base * 0.7 : base;
   } catch { return 0.5; }

package/lib/triage-core/mental-model/entity-extractor.ts

@@ -176,6 +176,10 @@ export function setExtractionLLM(llm: ExtractionLLM): void {
   _llm = llm;
 }
 
+// Phase 8: Lazy triage LLM factory — cloud → Ollama → bundled Qwen3 (C11: extraction only)
+let _triageLLMOverride: any = null;
+export function setExtractionLLMOverride(llm: any): void { _triageLLMOverride = llm; }
+
 // Pricing as of 2026-06 for claude-3-5-sonnet cross-region inference via Bedrock.
 // Override via env: BEDROCK_INPUT_COST_PER_1K, BEDROCK_OUTPUT_COST_PER_1K
 // Source: https://aws.amazon.com/bedrock/pricing/
@@ -324,15 +328,27 @@ const EXTRACTION_TOOL = {
   },
 };
 
+// ---------------------------------------------------------------------------
+// Prompt sanitization
+// ---------------------------------------------------------------------------
+
+function sanitizeForPrompt(input: string, maxLen = 200): string {
+  return input
+    .replace(/\[INST\]/gi, '')
+    .replace(/\[\/INST\]/gi, '')
+    .replace(/SYSTEM:/gi, '')
+    .replace(/`/g, '')
+    .replace(/<[^>]*>/g, '')
+    .slice(0, maxLen);
+}
+
 // ---------------------------------------------------------------------------
 // System prompt with few-shot examples
 // ---------------------------------------------------------------------------
 
 function buildSystemPrompt(context?: { senderName?: string; platform?: string }): string {
-  const safeSenderName = (context?.senderName || '')
-    .replace(/[^A-Za-z0-9 .,'\-]/g, '')
-    .slice(0, 100);
-  const safePlatform = (context?.platform || '').replace(/[\n\r"'`<>]/g, '').slice(0, 50);
+  const safeSenderName = sanitizeForPrompt(context?.senderName || '', 100);
+  const safePlatform = sanitizeForPrompt((context?.platform || '').replace(/[\n\r"']/g, ''), 50);
   const senderInfo = safeSenderName ? ` The message sender is "${safeSenderName}".` : '';
   const platformInfo = safePlatform ? ` The platform is ${safePlatform}.` : '';
 
@@ -754,6 +770,37 @@ async function callLLM(systemPrompt: string, userText: string): Promise<{
   inputTokens: number;
   outputTokens: number;
 }> {
+  // If explicit override set (tests) or HELIOS_TRIAGE_PROVIDER set, use triage-llm-factory
+  if (_triageLLMOverride || process.env.HELIOS_TRIAGE_PROVIDER === 'local' || process.env.HELIOS_TRIAGE_PROVIDER === 'ollama' || !process.env.HELIOS_TRIAGE_PROVIDER) {
+    const { getTriageLLM } = await import('../triage-llm-factory.js');
+    const triageLlm = _triageLLMOverride ?? await getTriageLLM();
+    if (!triageLlm) {
+      throw new Error('[entity-extractor] No LLM available — all tiers unavailable (cloud/Ollama/Qwen3 all failed)');
+    }
+    // triage-llm-factory ExtractionLLM uses { userMessage } not { userText } — adapt
+    const result = await triageLlm.call({ systemPrompt, userMessage: userText.slice(0, 16000) });
+    // Local/Ollama returns plain JSON string — parse and map to extraction shape
+    let data: Record<string, unknown>;
+    try { data = JSON.parse(result.content); } catch { throw new Error('triage-llm-factory returned non-JSON: ' + result.content.slice(0, 100)); }
+    return {
+      extraction: {
+        messageType: validateMessageType(data.messageType ?? data.message_type),
+        urgency: clamp(Number(data.urgency ?? data.urgency_score ?? 0) / (typeof data.urgency_score === 'number' && data.urgency_score > 1 ? 5 : 1), 0, 1),
+        sentiment: validateSentiment(data.sentiment),
+        topics: validateTopics(Array.isArray(data.topics) && typeof data.topics[0] === 'string' ? (data.topics as string[]).map(t => ({ name: t, category: 'general', sentiment: null })) : data.topics),
+        questions: validateQuestions(data.questions),
+        commitments: validateCommitments(data.commitments),
+        entities: validateEntities(data.entities ?? data.key_people?.map?.((p: string) => ({ name: p, type: 'person', role: null }))),
+        lifeEvents: validateLifeEvents(data.lifeEvents ?? data.life_events ?? []),
+        answersQuestion: Boolean(data.answersQuestion ?? data.answers_question ?? false),
+        referencesCommitment: Boolean(data.referencesCommitment ?? data.references_commitment ?? false),
+        extractionFailed: false,
+      },
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+    };
+  }
+
   if (_llm) {
     const result = await _llm.call({
       systemPrompt,

package/lib/triage-core/mental-model/identity-resolver.ts

@@ -48,7 +48,7 @@ const _inFlight = new Map<string, Promise<IdentityResolution>>();
 // ── Pending creations queue ───────────────────────────────────────────────────
 // Persons queued for background creation (strategy 5 fallback).
 // Declared at module top to eliminate temporal dead zone risk.
-const _pendingCreations: Array<{handle: string; platform: string; displayName: string; personId?: string; _retryCount?: number}> = [];
+const _pendingCreations: Array<{handle: string; platform: string; displayName: string; personId?: string; id?: string; _retryCount?: number}> = [];
 let _pendingFlush = false;
 
 function _getCached(handle: string, platform: string): IdentityResolution | undefined {
@@ -399,7 +399,7 @@ export async function resolveIdentity(
       };
       _cache.set(cacheKey, { value: pending, expiresAt: Date.now() + CACHE_TTL_MS });
 
-      _pendingCreations.push({ handle, platform, displayName: hints?.displayName || handle, personId: personUUID });
+      _pendingCreations.push({ handle, platform, displayName: hints?.displayName || handle, personId: personUUID, id: randomUUID() });
       process.stderr.write(JSON.stringify({ level: 'debug', module: 'identity-resolver', message: '[identity-resolver] Pending person queued', handle, platform, personId: personUUID, slug: pendingSlug }) + '\n');
 
       resolveDeferred(pending);
@@ -413,7 +413,7 @@ export async function resolveIdentity(
   return resolutionPromise;
 }
 
-export function getPendingCreations(): Array<{handle: string; platform: string; displayName: string; personId?: string; _retryCount?: number}> {
+export function getPendingCreations(): Array<{handle: string; platform: string; displayName: string; personId?: string; id?: string; _retryCount?: number}> {
   return [..._pendingCreations]; // non-destructive snapshot
 }
 
@@ -436,11 +436,11 @@ export async function flushPendingCreations(): Promise<number> {
                     p.name = h.displayName,
                     p.platform = h.platform,
                     p.createdAt = localdatetime(),
-                    p.dunbarLayer = null
+                      p.dunbarLayer = null
       SET p.updatedAt = localdatetime()
       WITH p, h
       MERGE (i:Identity {handle: h.handle, platform: h.platform})
-      ON CREATE SET i.personId = p.id
+      ON CREATE SET i.id = h.id, i.personId = p.id
       ON MATCH SET i.personId = coalesce(i.personId, p.id)
       MERGE (p)-[:HAS_IDENTITY]->(i)
     `, { handles: batch });

package/lib/triage-core/mental-model/model-assembler-sql.ts

@@ -0,0 +1,200 @@
+/**
+ * model-assembler-sql.ts — SQL fallback for assembleMentalModel()
+ *
+ * Used when Memgraph is unavailable. Reads from helios.db triage_* tables.
+ * Returns a PersonMentalModel with identical shape to the Memgraph version.
+ * C7: Memgraph is primary; this is the fallback only.
+ */
+
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+
+// Import PersonMentalModel type from types
+import type { PersonMentalModel } from '../types.ts';
+import { _getDb } from '../triage-sql-store.ts';
+
+export async function assembleMentalModelSQL(personId: string): Promise<PersonMentalModel | null> {
+  try {
+    const db = _getDb();
+
+    // Q_PERSON: Core person data
+    const person = db.prepare(`
+      SELECT id, name, email, total_interactions, last_interaction_at, is_vip,
+             page_rank, betweenness, community_id, dunbar_layer,
+             trajectory_direction, trajectory_velocity, clustering_coefficient,
+             avg_message_length, emoji_rate, formality_score, initiation_ratio,
+             recent_inbound_count, avg_weekly_inbound, resilience_level, resilience_score,
+             tags, blocked, job_title, company
+      FROM triage_persons WHERE id = ?
+    `).get(personId) as any;
+
+    if (!person) return null;
+
+    // Q_KNOWS: Relationship edges
+    const knowsEdges = db.prepare(`
+      SELECT k.src_id, k.dst_id, k.strength, k.favee, k.quality_profile, k.health_status,
+             k.episode_count, k.last_message_at, k.composite_strength, k.prev_composite_strength,
+             p.name AS other_name, p.email AS other_email
+      FROM triage_knows_edges k
+      JOIN triage_persons p ON (CASE WHEN k.src_id = ? THEN k.dst_id ELSE k.src_id END) = p.id
+      WHERE k.src_id = ? OR k.dst_id = ?
+      ORDER BY k.composite_strength DESC
+      LIMIT 50
+    `).all(personId, personId, personId) as any[];
+
+    // Q_EPISODES: Recent episodes
+    const episodes = db.prepare(`
+      SELECT id, text, platform, direction, received_at, message_type, urgency, sentiment, subject
+      FROM triage_episodes
+      WHERE person_id = ?
+      ORDER BY received_at DESC
+      LIMIT 20
+    `).all(personId) as any[];
+
+    // Q_KEY_FACTS: Key facts
+    const keyFacts = db.prepare(`
+      SELECT text, confidence, source FROM triage_key_facts
+      WHERE person_id = ?
+      ORDER BY confidence DESC
+      LIMIT 20
+    `).all(personId) as any[];
+
+    // Q_TOPICS: Topics
+    const topics = db.prepare(`
+      SELECT t.name, pt.strength FROM triage_person_topics pt
+      JOIN triage_topics t ON t.id = pt.topic_id
+      WHERE pt.person_id = ?
+      ORDER BY pt.strength DESC
+      LIMIT 10
+    `).all(personId) as any[];
+
+    // Q_GOALS: Active goals (for goal_relevance signal)
+    const goals = db.prepare(`
+      SELECT id, text, priority, status, category
+      FROM triage_goals WHERE status = 'active'
+      ORDER BY priority ASC
+      LIMIT 20
+    `).all() as any[];
+
+    // Q_QUESTIONS: Open questions involving this person
+    const questions = db.prepare(`
+      SELECT text FROM triage_questions
+      WHERE person_id = ? AND answered = 0
+      ORDER BY created_at DESC LIMIT 5
+    `).all(personId) as any[];
+
+    // Q_COMMITMENTS: Open commitments
+    const commitments = db.prepare(`
+      SELECT text, direction, due_at FROM triage_commitments
+      WHERE person_id = ? AND fulfilled = 0
+      ORDER BY due_at ASC LIMIT 5
+    `).all(personId) as any[];
+
+    // Q_CONNECTED: 2-hop neighborhood via recursive CTE
+    let connectedPeople: any[] = [];
+    try {
+      connectedPeople = db.prepare(`
+        WITH RECURSIVE hop(node_id, depth) AS (
+          SELECT ?, 0
+          UNION
+          SELECT CASE WHEN e.src_id = hop.node_id THEN e.dst_id ELSE e.src_id END, depth + 1
+          FROM triage_knows_edges e
+          JOIN hop ON (e.src_id = hop.node_id OR e.dst_id = hop.node_id)
+          WHERE depth < 2
+        )
+        SELECT DISTINCT h.node_id, p.name
+        FROM hop h
+        JOIN triage_persons p ON p.id = h.node_id
+        WHERE h.depth = 2 AND h.node_id <> ?
+        LIMIT 10
+      `).all(personId, personId) as any[];
+    } catch {
+      // Recursive CTE might fail on very old SQLite — silently degrade to empty
+    }
+
+    // Q_KNOWS_EDGE (self edge): for trajectory_signal
+    const selfKnows = knowsEdges.find((e: any) => e.src_id === personId || e.dst_id === personId);
+
+    // Assemble the PersonMentalModel shape
+    const model: PersonMentalModel = {
+      personId: person.id,
+      canonicalName: person.name ?? '',
+      identities: [],
+      summary: null,
+      summaryUpdatedAt: null,
+      communicationStyle: null,
+      responseLatencyAvg: null,
+      preferredChannel: null,
+      timezone: null,
+      totalInteractions: person.total_interactions ?? 0,
+      lastInteractionAt: person.last_interaction_at ?? null,
+      isVip: Boolean(person.is_vip),
+      pageRank: person.page_rank ?? 0,
+      betweennessCentrality: person.betweenness ?? 0,
+      degreeCentrality: 0,
+      communityId: person.community_id ?? null,
+      dunbarLayer: person.dunbar_layer ?? undefined,
+      trajectoryDirection: person.trajectory_direction ?? undefined,
+      trajectoryVelocity: person.trajectory_velocity ?? undefined,
+      clusteringCoefficient: person.clustering_coefficient ?? undefined,
+      avgMessageLength: person.avg_message_length ?? undefined,
+      emojiRate: person.emoji_rate ?? undefined,
+      formalityScore: person.formality_score ?? undefined,
+      initiationRatio: person.initiation_ratio ?? undefined,
+      recentInboundCount: person.recent_inbound_count ?? 0,
+      avgWeeklyInbound: person.avg_weekly_inbound ?? 0,
+      resilienceLevel: person.resilience_level ?? null,
+      resilienceScore: person.resilience_score ?? null,
+      tags: (() => { try { return JSON.parse(person.tags || '[]'); } catch { return []; } })(),
+      blocked: Boolean(person.blocked),
+      jobTitle: person.job_title ?? undefined,
+      company: person.company ?? undefined,
+      // Relationship data
+      relationshipStrength: selfKnows?.composite_strength ?? 0,
+      healthStatus: selfKnows?.health_status ?? null,
+      qualityProfile: selfKnows?.quality_profile ? (() => { try { return JSON.parse(selfKnows.quality_profile); } catch { return null; } })() : null,
+      // Arrays
+      recentEpisodes: episodes.map((e: any) => ({
+        id: e.id ?? '',
+        text: e.text ?? '',
+        platform: (e.platform ?? 'email') as any,
+        direction: (e.direction ?? 'inbound') as any,
+        receivedAt: e.received_at ?? '',
+        messageType: (e.message_type ?? 'fyi') as any,
+      })),
+      activeTopics: [],
+      openQuestions: questions.map((q: any) => ({
+        id: '',
+        text: q.text,
+        intent: 'general' as any,
+        status: 'open' as const,
+        urgency: 0,
+        askedAt: '',
+        answeredAt: null,
+      })),
+      openCommitments: commitments.map((c: any) => ({
+        id: '',
+        text: c.text,
+        owner: 'them' as const,
+        status: 'open' as const,
+        dueDate: c.due_at ?? null,
+        createdAt: '',
+        completedAt: null,
+        direction: c.direction ?? undefined,
+      })),
+      connectedPeople: connectedPeople.map((p: any) => ({
+        personId: p.node_id,
+        name: p.name ?? '',
+        relationship: '2-hop connection',
+      })),
+      keyFacts: keyFacts.map((kf: any) => kf.text),
+      topics: topics.map((t: any) => t.name),
+      goals: goals.map((g: any) => ({ id: g.id, text: g.text, priority: g.priority, status: g.status, category: g.category })),
+    } as PersonMentalModel & { keyFacts?: string[]; topics?: string[]; goals?: any[] };
+
+    return model;
+  } catch (e: any) {
+    console.warn(`[model-assembler-sql] assembleMentalModelSQL(${personId}) failed: ${e.message}`);
+    return null;
+  }
+}

package/lib/triage-core/mental-model/model-assembler.ts

@@ -9,6 +9,7 @@ import type { PersonMentalModel, Identity, Topic, Question, Commitment, TriagePl
 import { computeRelationshipStrength } from './relationship-strength.ts';
 import { assembleContextBrief } from './context-brief.ts';
 import { detectHorsemenForPerson } from './horsemen-detector.ts';
+import { assembleMentalModelSQL } from './model-assembler-sql.ts';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const { rawWrite: mgWrite } = require('../../../lib/safe-memgraph.js');
@@ -73,8 +74,21 @@ export async function assembleMentalModel(
   _reader?: (cypher: string, params: Record<string, unknown>) => Promise<Record<string, unknown>[]>,
 ): Promise<PersonMentalModel> {
   if (!personId) throw new Error('assembleMentalModel: personId is required');
-  
-  const reader = _reader ? { safeRead: _reader } : getReader();
+
+  // C7: SQL fallback when Memgraph unavailable or explicitly skipped
+  if (process.env.HELIOS_SKIP_MEMGRAPH === '1') {
+    const sqlModel = await assembleMentalModelSQL(personId);
+    if (sqlModel) return sqlModel;
+    // Fall through to Memgraph if SQL also fails
+  }
+
+  let reader: GraphReader;
+  try {
+    reader = _reader ? { safeRead: _reader } : getReader();
+  } catch (e) {
+    // C7: Memgraph unavailable — fall back to SQL
+    try { return (await assembleMentalModelSQL(personId)) as PersonMentalModel; } catch { throw e; }
+  }
   const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
 
   const [
@@ -336,7 +350,6 @@ export async function assembleMentalModel(
   } as PersonMentalModel;
 }
 
-
 // ---------------------------------------------------------------------------
 // assembleMentalModelByEmail — lookup by email address (B9: T3-18)
 // ---------------------------------------------------------------------------

package/lib/triage-core/orchestrator.ts

@@ -527,7 +527,7 @@ export class TriageOrchestrator {
         if (draftedItems.length > 0) {
           const { rawWrite } = require('../safe-memgraph.js');
           const batch = draftedItems.map(item => ({
-            id: `draft-${item.id}`,
+            id: `draft-${item.id}-${randomUUID().slice(0, 8)}`,
             type: item.platform === 'slack' ? 'slack' : 'email',
             triggeredBy: `auto_draft_${item.priority}`,
             content: JSON.stringify({ 
@@ -598,7 +598,7 @@ export class TriageOrchestrator {
         };
         const resolvedCompanyId = this.config.companyId ?? process.env.HELIOS_COMPANY_ID ?? null;
         if (!resolvedCompanyId) {
-          this.log('debug', 'hbo_bridge.skip_no_company', { reason: 'companyId not configured' });
+          this.log('error', 'hbo_bridge.skip_no_company', { reason: 'HELIOS_COMPANY_ID is not set — P0/P1 items will NOT create HBO Task or AgentReadySignal nodes. Set HELIOS_COMPANY_ID in .env to enable HBO wiring.' });
           // Skip HBO wiring when no companyId is available
         } else {
           const hboStats = await batchTriageToHBO(
@@ -1239,7 +1239,7 @@ export class TriageOrchestrator {
 
     // Step 4: Batch persist conversations
     const conversationBatch = batch.map(m => ({
-      id: `conv:${m.platform}:${m.threadId}`,
+      id: `conv:${m.platform}:${m.threadId || m.id}`,
       platform: m.platform,
       threadId: m.threadId || '',
       isGroup: m.isGroup || false,
@@ -1271,7 +1271,7 @@ export class TriageOrchestrator {
           rawId: m.rawId,
           labels: m.labels || [],
           personId: resolution.personId,
-          conversationId: `conv:${m.platform}:${m.threadId}`,
+          conversationId: `conv:${m.platform}:${m.threadId || m.id}`,
           subject: m.subject,
           threadId: m.threadId,
         };

package/lib/triage-core/scheduled-sends.ts

@@ -10,7 +10,11 @@ const QUEUE_PATH = join(homedir(), '.pi', 'agent', 'data', 'email-triage', 'send
 
 export interface ScheduledMessage {
   id: string; to: string; personId: string; platform: 'email' | 'imessage' | 'slack';
-  subject?: string; body: string; scheduledAt: string; createdAt: string; status: 'pending' | 'sent' | 'failed';
+  subject?: string; body: string; scheduledAt: string; createdAt: string; status: 'pending' | 'sent' | 'failed' | 'cancelled';
+  draftId?: string;
+  cancelDraft?: boolean;
+  accountEmail?: string;
+  error?: string;
 }
 
 export async function getOptimalSendTime(personId: string): Promise<Date> {
@@ -49,7 +53,7 @@ export function scheduleMessage(msg: Omit<ScheduledMessage, 'id' | 'createdAt' |
 
 export function getPendingMessages(): ScheduledMessage[] { return loadQueue().filter(m => m.status === 'pending'); }
 export function getDueMessages(): ScheduledMessage[] { const now = new Date().toISOString(); return loadQueue().filter(m => m.status === 'pending' && m.scheduledAt <= now); }
-export function markSent(id: string): void { const q = loadQueue(); const m = q.find(x => x.id === id); if (m) { m.status = 'sent'; saveQueue(q); } }
+export function markSent(id: string): void { const q = loadQueue(); const m = q.find(x => x.id === id && x.status === 'pending'); if (m) { m.status = 'sent'; saveQueue(q); } }
 
 function loadQueue(): ScheduledMessage[] { try { if (existsSync(QUEUE_PATH)) return JSON.parse(readFileSync(QUEUE_PATH, 'utf-8')); } catch {} return []; }
 function saveQueue(queue: ScheduledMessage[]): void {
@@ -57,3 +61,36 @@ function saveQueue(queue: ScheduledMessage[]): void {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   writeFileSync(QUEUE_PATH, JSON.stringify(queue, null, 2));
 }
+
+export async function executeDueMessages(
+  sendDraftFn: (draftId: string) => Promise<{ id: string }>,
+  deleteDraftFn: (draftId: string) => Promise<void>,
+): Promise<{ sent: number; failed: number }> {
+  const due = getDueMessages();
+  let sent = 0; let failed = 0;
+  for (const msg of due) {
+    try {
+      if (msg.draftId) {
+        await sendDraftFn(msg.draftId);
+      }
+      // else: non-draft scheduled send (not used in Phase 6 but keep path open)
+      markSent(msg.id);
+      sent++;
+    } catch (e) {
+      const q = loadQueue();
+      const m = q.find(x => x.id === msg.id);
+      if (m) { m.status = 'failed'; m.error = String(e); saveQueue(q); }
+      failed++;
+    }
+  }
+  return { sent, failed };
+}
+
+export function cancelScheduledSend(id: string): boolean {
+  const q = loadQueue();
+  const m = q.find(x => x.id === id && x.status === 'pending');
+  if (!m) return false;
+  m.status = 'cancelled';
+  saveQueue(q);
+  return true;
+}

package/lib/triage-core/signals/comms-style.ts

@@ -14,7 +14,7 @@ export async function score(
   item: Partial<TriageItem>,
   model: PersonMentalModel | null,
 ): Promise<{ score: number; evidence: string }> {
-  if (!model) return { score: 0.3, evidence: 'No model available' };
+  if (!model) return { score: 0.5, evidence: 'no model available' };
 
   const parts: string[] = [];
   let styleScore = 0.5; // default neutral

package/lib/triage-core/signals/cross-channel-escalation.ts

@@ -36,8 +36,8 @@ export async function score(
     }
   }
 
-  // Also include the current item's platform if present
-  if (item.platform) {
+  // Also include the current item's platform if it is within the 48-hour window
+  if (item.platform && item.receivedAt && (Date.now() - new Date(item.receivedAt).getTime()) <= WINDOW_MS) {
     channelsInWindow.add(item.platform);
   }
 

package/lib/triage-core/signals/favee-type.ts

@@ -32,7 +32,12 @@ export async function score(
     return { score: 0, evidence: 'no favee data' };
   }
 
-  const parsed = typeof favee === 'string' ? JSON.parse(favee) : favee;
+  let parsed: any = null;
+  try {
+    parsed = typeof favee === 'string' ? JSON.parse(favee) : favee;
+  } catch {
+    // SEC: malformed favee JSON — skip this connection's favee data
+  }
   const type = (parsed?.canonicalType as string) ?? null;
   const boost = type ? (TYPE_BOOST[type] ?? 0.5) : 0;
 

package/lib/triage-core/signals/goal-relevance.ts

@@ -1,6 +1,7 @@
 import type { TriageItem, PersonMentalModel } from '../types.ts';
 import { createRequire } from 'module';
-import { homedir } from 'os';
+import path from 'path';
+import { _getDb } from '../triage-sql-store.js';
 const require = createRequire(import.meta.url);
 
 
@@ -25,8 +26,14 @@ export function clearGoalCache(): void {
 async function getActiveGoals(): Promise<ActiveGoal[]> {
   if (_goalCache && Date.now() - _goalCache.fetchedAt < CACHE_TTL) return _goalCache.goals;
 
+  // In vitest context, skip live Memgraph query — tests manage their own data.
+  // Pre-fetched _ctx_activeGoals on the model is the preferred test path.
+  if (process.env.VITEST === 'true' || process.env.VITEST === '1') {
+    return [];
+  }
+
   try {
-    const { rawRead } = require(`${homedir()}/helios-agent/lib/safe-memgraph.js`);
+    const { rawRead } = require(path.join(__dirname, '../../safe-memgraph.js'));
     const rows = await Promise.race([
       rawRead(`
         MATCH (g:GoalNode) WHERE g.status = 'active'
@@ -44,6 +51,28 @@ async function getActiveGoals(): Promise<ActiveGoal[]> {
     _goalCache = { goals, fetchedAt: Date.now() };
     return goals;
   } catch {
+    // SQL fallback: query triage_goals when Memgraph is unavailable or times out
+    try {
+      const db = _getDb();
+      const sqlRows = db.prepare(
+        `SELECT text, priority FROM triage_goals WHERE status = 'active'`
+      ).all() as Array<{ text: string; priority: string }>;
+
+      if (sqlRows.length > 0) {
+        const goals: ActiveGoal[] = sqlRows.map((r) => ({
+          text: r.text || '',
+          // triage_goals.priority is an integer (lower = higher priority: 0=P0, 1=P1, 2+=P2)
+          priority: typeof r.priority === 'number'
+            ? (r.priority <= 0 ? 'P0' : r.priority === 1 ? 'P1' : 'P2')
+            : (r.priority || 'P2'),
+          keywords: (r.text || '').toLowerCase().split(/\s+/).filter((w: string) => w.length > 4),
+        }));
+        _goalCache = { goals, fetchedAt: Date.now() };
+        return goals;
+      }
+    } catch {
+      // SQL also unavailable — fall through to cache
+    }
     return _goalCache?.goals || [];
   }
 }

package/lib/triage-core/signals/personal-importance.ts

@@ -7,7 +7,7 @@ export async function score(
 ): Promise<{ score: number; evidence: string }> {
   if (!model) return { score: 0.3, evidence: 'unknown person' };
   const tier = model.tier || model.dunbarLayer || '';
-  const tierScores: Record<string, number> = { intimate: 0.95, close: 0.8, active: 0.6, casual: 0.3 };
+  const tierScores: Record<string, number> = { intimate: 0.95, close: 0.8, friend: 0.65, active: 0.6, recognized: 0.3 };
   const s = tierScores[tier] || 0.4;
   return { score: s, evidence: `${tier || 'unclassified'} contact` };
 }

package/lib/triage-core/signals/referral-chain.ts

@@ -5,7 +5,6 @@ export async function score(
   item: Partial<TriageItem>,
   model: PersonMentalModel | null,
 ): Promise<{ score: number; evidence: string }> {
-  if (!model) return { score: 0, evidence: 'no referral chain data' };
   const hasIntroduction = (item.body || item.snippet || '').toLowerCase().match(/intro|referred|connect you|meet/);
   return { score: hasIntroduction ? 0.6 : 0, evidence: hasIntroduction ? 'referral language detected' : 'no referral signals' };
 }