@cgh567/agent 2.4.3 → 2.4.5

package/lib/triage-core/graph/__tests__/batch-persistence.test.ts

@@ -0,0 +1,283 @@
+// ============================================================================
+// lib/triage-core/graph/__tests__/batch-persistence.test.ts
+//
+// Unit tests for batch-persistence.ts with mocked safe-memgraph.
+// Verifies:
+//   - Each function calls bulkIngest with UNWIND $batch Cypher
+//   - MERGE (not CREATE) is used for all writes
+//   - MERGE key is on the correct property
+//   - Empty batches are no-ops
+// No live Memgraph connection required.
+// ============================================================================
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// ── Mock safe-memgraph BEFORE importing batch-persistence ───────────────────
+
+const mockBulkIngest = vi.fn().mockResolvedValue({ nodesCreated: 1, nodesModified: 0, errors: [] });
+const mockRawWrite = vi.fn().mockResolvedValue([]);
+
+vi.mock('../../safe-memgraph.js', () => ({
+  bulkIngest: mockBulkIngest,
+  rawWrite: mockRawWrite,
+}));
+
+// Re-import after mock is set up
+import {
+  setGraphWriter,
+  persistPersonsBatch,
+  persistIdentitiesBatch,
+  persistEpisodesBatch,
+  persistExtractionsBatch,
+  persistConversationsBatch,
+} from '../batch-persistence.ts';
+
+// ── Helper: capture all Cypher strings passed to bulkIngest ─────────────────
+
+function getCapturedCypher(): string[] {
+  return mockBulkIngest.mock.calls.flatMap((call: any[]) => {
+    const ops = call[0]; // first arg is array of {cypher, params}
+    return Array.isArray(ops) ? ops.map((op: any) => op.cypher) : [];
+  });
+}
+
+function getCapturedWriterCalls(): string[] {
+  // The writer injected by setGraphWriter captures cypher passed directly
+  return capturedWriterCyphers;
+}
+
+// Track injected writer calls
+const capturedWriterCyphers: string[] = [];
+const capturedWriterParams: Record<string, unknown>[] = [];
+
+// Inject a mock writer so we can inspect the Cypher without live DB
+beforeEach(() => {
+  capturedWriterCyphers.length = 0;
+  capturedWriterParams.length = 0;
+  vi.clearAllMocks();
+
+  setGraphWriter(async (cypher: string, params?: Record<string, unknown>) => {
+    capturedWriterCyphers.push(cypher);
+    capturedWriterParams.push(params ?? {});
+    return [];
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// persistPersonsBatch
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('persistPersonsBatch (unit — mocked writer)', () => {
+  it('calls writer with UNWIND $batch Cypher', async () => {
+    await persistPersonsBatch([
+      { id: 'unit-person-1', name: 'Unit Alice' },
+    ]);
+    expect(capturedWriterCyphers.length).toBeGreaterThan(0);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toContain('UNWIND $batch');
+  });
+
+  it('uses MERGE not CREATE for Person nodes', async () => {
+    await persistPersonsBatch([
+      { id: 'unit-person-2', name: 'Unit Bob' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toContain('MERGE');
+    expect(cypher).not.toMatch(/\bCREATE\b/);
+  });
+
+  it('MERGEs on Person.id (not email or name)', async () => {
+    await persistPersonsBatch([
+      { id: 'unit-person-3', name: 'Unit Carol' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toMatch(/MERGE \(p:Person \{id:/);
+  });
+
+  it('passes batch param containing the items', async () => {
+    await persistPersonsBatch([
+      { id: 'unit-person-4', name: 'Unit Dave' },
+    ]);
+    const params = capturedWriterParams[0];
+    expect(Array.isArray((params as any).batch)).toBe(true);
+    expect((params as any).batch[0].id).toBe('unit-person-4');
+  });
+
+  it('empty batch is a no-op — writer not called', async () => {
+    await persistPersonsBatch([]);
+    expect(capturedWriterCyphers.length).toBe(0);
+  });
+
+  it('handles multiple items in a single call', async () => {
+    await persistPersonsBatch([
+      { id: 'unit-person-5a', name: 'Unit Eve' },
+      { id: 'unit-person-5b', name: 'Unit Frank' },
+    ]);
+    const params = capturedWriterParams[0];
+    expect((params as any).batch.length).toBe(2);
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// persistIdentitiesBatch
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('persistIdentitiesBatch (unit — mocked writer)', () => {
+  it('calls writer with UNWIND $batch Cypher', async () => {
+    await persistIdentitiesBatch([
+      { id: 'unit-id-1', handle: 'alice@unit.com', platform: 'email', personId: 'unit-person-1' },
+    ]);
+    expect(capturedWriterCyphers.length).toBeGreaterThan(0);
+    expect(capturedWriterCyphers[0]).toContain('UNWIND $batch');
+  });
+
+  it('uses MERGE not CREATE', async () => {
+    await persistIdentitiesBatch([
+      { id: 'unit-id-2', handle: 'bob@unit.com', platform: 'email', personId: 'unit-person-2' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toContain('MERGE');
+    expect(cypher).not.toMatch(/\bCREATE\b/);
+  });
+
+  it('MERGEs Identity on id and links to Person', async () => {
+    await persistIdentitiesBatch([
+      { id: 'unit-id-3', handle: 'carol@unit.com', platform: 'email', personId: 'unit-person-3' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toMatch(/MERGE \(i:Identity \{id:/);
+    expect(cypher).toContain('HAS_IDENTITY');
+  });
+
+  it('empty batch is a no-op', async () => {
+    await persistIdentitiesBatch([]);
+    expect(capturedWriterCyphers.length).toBe(0);
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// persistEpisodesBatch
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('persistEpisodesBatch (unit — mocked writer)', () => {
+  it('calls writer with UNWIND $batch Cypher', async () => {
+    await persistEpisodesBatch([
+      { id: 'unit-ep-1', text: 'Hello', platform: 'email', direction: 'inbound', receivedAt: new Date().toISOString(), personId: 'unit-person-1' },
+    ]);
+    expect(capturedWriterCyphers.length).toBeGreaterThan(0);
+    expect(capturedWriterCyphers[0]).toContain('UNWIND $batch');
+  });
+
+  it('uses MERGE not CREATE', async () => {
+    await persistEpisodesBatch([
+      { id: 'unit-ep-2', text: 'World', platform: 'email', direction: 'inbound', receivedAt: new Date().toISOString(), personId: 'unit-person-2' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toContain('MERGE');
+    expect(cypher).not.toMatch(/\bCREATE\b/);
+  });
+
+  it('MERGEs on Episode.id', async () => {
+    await persistEpisodesBatch([
+      { id: 'unit-ep-3', text: 'Test', platform: 'email', direction: 'outbound', receivedAt: new Date().toISOString(), personId: 'unit-person-3' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toMatch(/MERGE \(e:Episode \{id:/);
+  });
+
+  it('empty batch is a no-op', async () => {
+    await persistEpisodesBatch([]);
+    expect(capturedWriterCyphers.length).toBe(0);
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// persistExtractionsBatch
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('persistExtractionsBatch (unit — mocked writer)', () => {
+  it('empty batch is a no-op', async () => {
+    await persistExtractionsBatch([]);
+    expect(capturedWriterCyphers.length).toBe(0);
+  });
+
+  it('calls writer with UNWIND $batch for topics', async () => {
+    await persistExtractionsBatch([{
+      episodeId: 'unit-ep-10',
+      personId: 'unit-person-10',
+      extraction: {
+        topics: [{ id: 'unit-topic-1', name: 'AI', category: 'tech', sentiment: 'positive' }],
+        questions: [],
+        commitments: [],
+      },
+    }]);
+    const hasUnwind = capturedWriterCyphers.some(c => c.includes('UNWIND $batch') || c.includes('UNWIND $topics'));
+    expect(hasUnwind).toBe(true);
+  });
+
+  it('uses MERGE not CREATE for Topic nodes', async () => {
+    await persistExtractionsBatch([{
+      episodeId: 'unit-ep-11',
+      personId: 'unit-person-11',
+      extraction: {
+        topics: [{ id: 'unit-topic-2', name: 'ML', category: 'tech', sentiment: 'neutral' }],
+        questions: [],
+        commitments: [],
+      },
+    }]);
+    const allCyphers = capturedWriterCyphers.join('\n');
+    expect(allCyphers).toContain('MERGE');
+    expect(allCyphers).not.toMatch(/(?<!\w)CREATE(?!\s+INDEX|\s+CONSTRAINT)/);
+  });
+
+  it('score in [0,1]: returns undefined (void function, no score)', async () => {
+    // persistExtractionsBatch is void — verify it does not throw
+    await expect(persistExtractionsBatch([])).resolves.toBeUndefined();
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// persistConversationsBatch
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('persistConversationsBatch (unit — mocked writer)', () => {
+  it('calls writer with UNWIND $batch Cypher', async () => {
+    await persistConversationsBatch([
+      { id: 'unit-conv-1', platform: 'email', threadId: 'thread-unit-1' },
+    ]);
+    expect(capturedWriterCyphers.length).toBeGreaterThan(0);
+    expect(capturedWriterCyphers[0]).toContain('UNWIND $batch');
+  });
+
+  it('uses MERGE not CREATE', async () => {
+    await persistConversationsBatch([
+      { id: 'unit-conv-2', platform: 'email', threadId: 'thread-unit-2' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toContain('MERGE');
+    expect(cypher).not.toMatch(/\bCREATE\b/);
+  });
+
+  it('MERGEs Conversation on id', async () => {
+    await persistConversationsBatch([
+      { id: 'unit-conv-3', platform: 'email', threadId: 'thread-unit-3' },
+    ]);
+    const cypher = capturedWriterCyphers[0];
+    expect(cypher).toMatch(/MERGE \(c:Conversation \{id:/);
+  });
+
+  it('empty batch is a no-op', async () => {
+    await persistConversationsBatch([]);
+    expect(capturedWriterCyphers.length).toBe(0);
+  });
+
+  it('passes batch param with correct fields', async () => {
+    await persistConversationsBatch([
+      { id: 'unit-conv-4', platform: 'imessage', threadId: 'thread-unit-4', participantCount: 3, isGroup: true },
+    ]);
+    const params = capturedWriterParams[0];
+    const batch = (params as any).batch;
+    expect(batch[0].id).toBe('unit-conv-4');
+    expect(batch[0].platform).toBe('imessage');
+  });
+});

package/lib/triage-core/graph/batch-persistence.ts

@@ -110,7 +110,7 @@ export async function persistPersonsBatch(
     ON CREATE SET
       p.name = item.name,
       p.createdAt = item.now,
-      p.totalInteractions = coalesce(item.totalInteractions, 0),
+      p.totalInteractions = coalesce(item.totalInteractions, 1),
       p.isVip = coalesce(item.isVip, false),
       p.pageRank = coalesce(item.pageRank, 0.0),
       p.betweennessCentrality = coalesce(item.betweennessCentrality, 0.0),
@@ -118,7 +118,7 @@ export async function persistPersonsBatch(
     ON MATCH SET
       p.name = item.name,
       p.totalInteractions = coalesce(p.totalInteractions, 0) + coalesce(item.totalInteractions, 1),
-      p.lastInteractionAt = item.now
+      p.lastInteractionAt = CASE WHEN item.lastEpisodeAt IS NOT NULL THEN item.lastEpisodeAt ELSE coalesce(p.lastInteractionAt, item.now) END
     WITH p, item
     WHERE item.summary IS NOT NULL
     SET
@@ -141,6 +141,27 @@ export async function persistPersonsBatch(
   }));
 
   await getWriter()(cypher, { batch });
+
+  // 7B: Dual-write to SQLite triage_persons (fire-and-forget, non-blocking)
+  try {
+    const { createRequire: cr } = await import('module');
+    const req = cr(import.meta.url);
+    const store = req('../triage-sql-store.js');
+    for (const item of items) {
+      store.upsertPerson({
+        id: item.id, name: item.name, email: undefined,
+        totalInteractions: item.totalInteractions ?? 1,
+        lastInteractionAt: (item as any).lastEpisodeAt ?? item.lastInteractionAt ?? null,
+        isVip: item.isVip ?? false, pageRank: item.pageRank ?? null,
+        communityId: item.communityId ?? null, dunbarLayer: (item as any).dunbarLayer ?? null,
+        jobTitle: item.jobTitle ?? null, company: item.company ?? null,
+      }).catch(() => { /* non-blocking */ });
+    }
+  } catch (e: any) { 
+    if (e?.code === 'MODULE_NOT_FOUND') {
+      console.debug('[batch-persistence] triage-sql-store not available — SQLite dual-write skipped');
+    }
+  }
 }
 
 /**
@@ -269,6 +290,27 @@ export async function persistEpisodesBatch(
     );
   } catch { /* fail-open: enrichmentNeeded is advisory */ }
 
+  // 7B: Dual-write to SQLite triage_episodes (fire-and-forget, non-blocking)
+  try {
+    const { createRequire: cr } = await import('module');
+    const req = cr(import.meta.url);
+    const store = req('../triage-sql-store.js');
+    for (const item of items) {
+      store.upsertEpisode({
+        id: item.id, personId: item.personId, text: item.text,
+        platform: item.platform, direction: item.direction, receivedAt: item.receivedAt,
+        messageType: item.messageType ?? null, urgency: item.urgency ?? null,
+        sentiment: item.sentiment ?? null, rawId: item.rawId ?? null,
+        subject: item.subject ?? null, threadId: item.threadId ?? null,
+        labels: item.labels ?? [],
+      }).catch(() => { /* non-blocking */ });
+    }
+  } catch (e: any) { 
+    if (e?.code === 'MODULE_NOT_FOUND') {
+      console.debug('[batch-persistence] triage-sql-store not available — SQLite dual-write skipped');
+    }
+  }
+
   // Layer 2A: Increment episodeCount on KNOWS edges + track lastMessageAt
   const selfId = process.env.HELIOS_SELF_ID || '__SELF_ID_NOT_SET__';
   // Guard: if HELIOS_SELF_ID is unset the sentinel never matches real IDs and self
@@ -555,6 +597,28 @@ export async function persistExtractionsBatch(
     `;
     await getWriter()(entityCypher, { batch: allEntities });
   }
+
+  // 7B: Dual-write topics/questions/commitments to SQLite (fire-and-forget)
+  try {
+    const { createRequire: cr } = await import('module');
+    const req = cr(import.meta.url);
+    const store = req('../triage-sql-store.js');
+    for (const item of items) {
+      for (const t of item.extraction.topics) {
+        store.upsertTopic({ id: t.id, name: t.name, category: t.category }).catch(() => {});
+      }
+      for (const q of item.extraction.questions) {
+        store.upsertQuestion({ id: q.id, episodeId: item.episodeId, personId: item.personId, text: q.text }).catch(() => {});
+      }
+      for (const c of item.extraction.commitments) {
+        store.upsertCommitment({ id: c.id, episodeId: item.episodeId, personId: item.personId, text: c.text, direction: c.direction ?? null, dueAt: c.dueDate ?? null }).catch(() => {});
+      }
+    }
+  } catch (e: any) { 
+    if (e?.code === 'MODULE_NOT_FOUND') {
+      console.debug('[batch-persistence] triage-sql-store not available — SQLite dual-write skipped');
+    }
+  }
 }
 
 /**

package/lib/triage-core/graph/betweenness-worker.js

@@ -0,0 +1,75 @@
+/**
+ * betweenness-worker.js — Approximate betweenness centrality (utilityProcess)
+ *
+ * Uses graphology's Brandes algorithm with k=1000 source node sampling.
+ * Reports progress via process.parentPort.postMessage every 50 iterations.
+ * On completion sends { type: 'RESULT', centralities: { [nodeId]: number } }.
+ *
+ * Called by warm-tick or a separate Electron utilityProcess.
+ */
+
+'use strict';
+
+const { workerData } = require('worker_threads');
+
+// Support both utilityProcess (Electron) and worker_threads
+const postMessage = (msg) => {
+  if (process.parentPort) {
+    process.parentPort.postMessage(msg);
+  } else if (typeof self !== 'undefined') {
+    self.postMessage(msg);
+  } else {
+    process.send?.(msg);
+  }
+};
+
+async function run() {
+  try {
+    const Graph = require('graphology');
+    const brandes = require('graphology-metrics/centrality/betweenness');
+
+    const { nodes = [], edges = [], k = 1000 } = workerData || {};
+
+    if (nodes.length === 0) {
+      return postMessage({ type: 'RESULT', centralities: {} });
+    }
+
+    const graph = new Graph.default({ type: 'undirected', multi: false });
+    for (const n of nodes) graph.addNode(n);
+    for (const e of edges) {
+      if (graph.hasNode(e[0]) && graph.hasNode(e[1]) && !graph.hasEdge(e[0], e[1])) {
+        graph.addEdge(e[0], e[1]);
+      }
+    }
+
+    // Approximate betweenness with k source sampling
+    const sampleSize = Math.min(k, graph.order);
+    const allNodes = graph.nodes();
+    const sampledNodes = allNodes.sort(() => Math.random() - 0.5).slice(0, sampleSize);
+
+    const centralities = {};
+    for (const n of allNodes) centralities[n] = 0;
+
+    const scalingFactor = graph.order / sampleSize;
+    let i = 0;
+
+    for (const source of sampledNodes) {
+      i++;
+      // Run single-source BFS/Brandes for this source
+      const result = brandes.default(graph, { normalized: false, weighted: false });
+      // Scale approximation
+      for (const [node, score] of Object.entries(result)) {
+        centralities[node] = (centralities[node] || 0) + (score / scalingFactor);
+      }
+      if (i % 50 === 0) {
+        postMessage({ type: 'PROGRESS', progress: Math.round((i / sampleSize) * 100) });
+      }
+    }
+
+    postMessage({ type: 'RESULT', centralities });
+  } catch (e) {
+    postMessage({ type: 'ERROR', error: e.message });
+  }
+}
+
+run();

package/lib/triage-core/graph/graph-rank-sql.ts

@@ -0,0 +1,67 @@
+/**
+ * graph-rank-sql.ts — PageRank + Louvain community detection on SQLite graph
+ *
+ * Loads triage_persons + triage_knows_edges into graphology,
+ * computes PageRank and Louvain communities,
+ * writes results back via triage-sql-store.upsertPerson().
+ *
+ * Called by warm-tick weekly cadence (7D).
+ */
+
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+
+import { _getDb, upsertPerson } from '../triage-sql-store.ts';
+
+export async function computeGraphRanksSQL(): Promise<{ personCount: number; edgeCount: number }> {
+  const db = _getDb();
+
+  // Load graph data
+  const persons = db.prepare('SELECT id FROM triage_persons').all() as { id: string }[];
+  const edges = db.prepare('SELECT src_id, dst_id, composite_strength FROM triage_knows_edges').all() as any[];
+
+  if (persons.length === 0) return { personCount: 0, edgeCount: 0 };
+
+  try {
+    const Graph = _require('graphology');
+    const { pagerank } = _require('graphology-metrics/centrality/pagerank');
+    const louvain = _require('graphology-communities-louvain');
+
+    // graphology CJS exports the Graph constructor directly (not .default)
+    const GraphConstructor = Graph.default ?? Graph;
+    const graph = new GraphConstructor({ type: 'undirected', multi: false });
+
+    for (const p of persons) graph.addNode(p.id);
+    for (const e of edges) {
+      if (graph.hasNode(e.src_id) && graph.hasNode(e.dst_id) && !graph.hasEdge(e.src_id, e.dst_id)) {
+        graph.addEdge(e.src_id, e.dst_id, { weight: e.composite_strength ?? 1.0 });
+      }
+    }
+
+    // PageRank
+    const pageRanks = pagerank(graph, { alpha: 0.85, maxIterations: 100 });
+
+    // Louvain community detection
+    let communities: Record<string, number> = {};
+    try {
+      const louvainFn = louvain.default ?? louvain;
+      communities = louvainFn(graph);
+    } catch {
+      // Louvain may fail on disconnected graphs — continue with empty communities
+    }
+
+    // Write back to SQLite
+    for (const personId of Object.keys(pageRanks)) {
+      await upsertPerson({
+        id: personId,
+        pageRank: pageRanks[personId],
+        communityId: communities[personId] ?? null,
+      });
+    }
+
+    return { personCount: persons.length, edgeCount: edges.length };
+  } catch (e: any) {
+    console.warn(`[graph-rank-sql] computeGraphRanksSQL failed: ${e.message}`);
+    return { personCount: persons.length, edgeCount: edges.length };
+  }
+}

package/lib/triage-core/graph/persistence.ts

@@ -428,7 +428,7 @@ export async function upsertPerson(props: UpsertPersonProps): Promise<Record<str
     lastInteractionAt: props.lastInteractionAt ?? null,
     isVip: props.isVip ?? false,
     pageRank: props.pageRank ?? 0.0,
-    betweennessCentrality: props.betweennessCentrality ?? 0.0,
+    betweennessCentrality: props.betweennessCentrality ?? null,
     degreeCentrality: props.degreeCentrality ?? 0.0,
     communityId: props.communityId ?? null,
     jobTitle: props.jobTitle ?? null,

package/lib/triage-core/graph/schema-v2.ts

@@ -51,6 +51,8 @@ const PROPERTY_INDEXES: MigrationStep[] = [
   { name: 'Index: StrengthSnapshot(personId)',     cypher: 'CREATE INDEX ON :StrengthSnapshot(personId)' },
   { name: 'Index: StrengthSnapshot(snapshotAt)',   cypher: 'CREATE INDEX ON :StrengthSnapshot(snapshotAt)' },
   { name: 'Index: Person(dunbarLayer)',            cypher: 'CREATE INDEX ON :Person(dunbarLayer)' },
+  { name: 'Index: TriageDecision(emailId)',        cypher: 'CREATE INDEX ON :TriageDecision(emailId) IF NOT EXISTS' },
+  { name: 'Constraint: Person(id) unique',        cypher: 'CREATE CONSTRAINT ON (p:Person) ASSERT p.id IS UNIQUE IF NOT EXISTS' },
 ];
 
 const TEXT_INDEXES: MigrationStep[] = [

package/lib/triage-core/graph/schema.cypher

@@ -14,6 +14,7 @@ CREATE CONSTRAINT ON (t:Topic) ASSERT t.id IS UNIQUE IF NOT EXISTS;
 CREATE CONSTRAINT ON (q:Question) ASSERT q.id IS UNIQUE IF NOT EXISTS;
 CREATE CONSTRAINT ON (c:Commitment) ASSERT c.id IS UNIQUE IF NOT EXISTS;
 CREATE CONSTRAINT ON (cv:Conversation) ASSERT cv.id IS UNIQUE IF NOT EXISTS;
+CREATE CONSTRAINT ON (p:Person) ASSERT p.id IS UNIQUE IF NOT EXISTS;
 
 // ---------------------------------------------------------------------------
 // INDEXES — Performance indexes for mental model queries

package/lib/triage-core/graph/triage-query.ts

@@ -121,7 +121,7 @@ export async function loadTriageItemsFromGraph(cutoffDate: string): Promise<Grap
       name: r.name || null,
       pageRank: r.pageRank || 0,
       isVip: r.isVip || false,
-      dunbarLayer: r.dunbarLayer || 'acquaintance',
+      dunbarLayer: r.dunbarLayer || null,
       summary: r.summary || null,
       interactions: intCount,
       identities: pid ? (identityMap.get(pid) || []) : [],

package/lib/triage-core/learning.ts

@@ -193,8 +193,8 @@ function saveLearnedWeights(weights: LearnedWeights, companyId?: string): void {
 
 /**
  * Update Beta distributions based on decision outcome.
- * On agree: increment α for signals that contributed most
- * On override: increment β for signals that scored highest (they were wrong)
+ * F15: Fractional credit allocation across all signals with positive weighted score.
+ * On agree: increment α proportionally; on override: increment β proportionally.
  */
 function updateBetaDistributions(decision: TriageDecision, learned: LearnedWeights): void {
   const signals = decision.signals || [];
@@ -202,28 +202,23 @@ function updateBetaDistributions(decision: TriageDecision, learned: LearnedWeigh
 
   const agreed = decision.agreedWithSuggestion ?? false;
 
-  // Sort signals by weighted score (contribution to decision)
-  const sortedSignals = [...signals].sort((a, b) => b.weightedScore - a.weightedScore);
-  
-  // Only the top signal (highest weighted score) gets updated.
-  // Updating multiple signals per decision creates cross-contamination:
-  // if A is #1 in overrides and #2 in agrees, its Beta params stay
-  // symmetric and convergence never occurs. Top-1 ensures only the signal
-  // most responsible for each outcome is credited or penalised.
-  const topSignals = sortedSignals.slice(0, 1);
-
-  for (const signal of topSignals) {
+  // F15: fractional credit across all signals with positive weighted score
+  const positiveSignals = signals.filter(s => s.weightedScore > 0);
+  const totalWeightedScore = positiveSignals.reduce((sum, s) => sum + s.weightedScore, 0);
+  if (totalWeightedScore === 0) return;
+
+  for (const signal of positiveSignals) {
     const source = signal.source;
     if (!learned.betaParams[source]) {
       learned.betaParams[source] = { alpha: 1, beta: 1 };
     }
-
+    const creditFraction = signal.weightedScore / totalWeightedScore;
     if (agreed) {
-      // User agreed with classification → this signal was helpful
-      learned.betaParams[source].alpha += 1;
+      // User agreed with classification → these signals were helpful
+      learned.betaParams[source].alpha += creditFraction;
     } else {
-      // User overrode → this signal misled the classifier
-      learned.betaParams[source].beta += 1;
+      // User overrode → these signals misled the classifier
+      learned.betaParams[source].beta += creditFraction;
     }
   }
 }
@@ -580,7 +575,7 @@ export function getDecisionCount(): number {
 /**
  * Get learning statistics.
  */
-export function getLearningStats(): {
+export function getLearningStats(companyId?: string): {
   totalDecisions: number;
   agreements: number;
   overrides: number;
@@ -591,7 +586,7 @@ export function getLearningStats(): {
   betaParams: Record<SignalSource, BetaParams> | null;
 } {
   const log = loadDecisionLog();
-  const learned = loadLearnedWeights();
+  const learned = loadLearnedWeights(companyId);
 
   return {
     totalDecisions: log.totalDecisions + decisionBuffer.pending.length,