agentacta 2026.3.26 → 2026.3.27

package/delta-attribution-context.js

@@ -0,0 +1,57 @@
+'use strict';
+
+function extractCallBaseId(id) {
+  if (!id) return '';
+  return String(id).replace(/:(call|result)$/, '');
+}
+
+function loadDeltaAttributionContext(db, sessionId, rows) {
+  if (!db || !Array.isArray(rows) || !rows.length) return [];
+
+  const ordered = [...rows].sort((a, b) => {
+    const ta = Date.parse(a?.timestamp || 0) || 0;
+    const tb = Date.parse(b?.timestamp || 0) || 0;
+    if (ta !== tb) return ta - tb;
+    return String(a?.id || '').localeCompare(String(b?.id || ''));
+  });
+
+  const first = ordered[0];
+  const firstTs = first?.timestamp || '1970-01-01T00:00:00.000Z';
+  const firstId = first?.id || '';
+  const neighborhoodRows = db.prepare(
+    `SELECT * FROM events
+     WHERE session_id = ?
+       AND (timestamp < ? OR (timestamp = ? AND id < ?))
+     ORDER BY timestamp DESC, id DESC
+     LIMIT 12`
+  ).all(sessionId, firstTs, firstTs, firstId).reverse();
+
+  const callIds = [...new Set(
+    rows
+      .filter(row => row && row.type === 'tool_result')
+      .map(row => extractCallBaseId(row.id))
+      .filter(Boolean)
+      .map(base => `${base}:call`)
+  )];
+
+  if (!callIds.length) return neighborhoodRows;
+
+  const placeholders = callIds.map(() => '?').join(',');
+  const linkedCallRows = db.prepare(
+    `SELECT * FROM events
+     WHERE session_id = ?
+       AND type = 'tool_call'
+       AND id IN (${placeholders})`
+  ).all(sessionId, ...callIds);
+
+  const merged = [];
+  const seen = new Set();
+  for (const row of [...neighborhoodRows, ...linkedCallRows]) {
+    if (!row || !row.id || seen.has(row.id)) continue;
+    seen.add(row.id);
+    merged.push(row);
+  }
+  return merged;
+}
+
+module.exports = { loadDeltaAttributionContext };

package/insights.js

@@ -0,0 +1,260 @@
+'use strict';
+
+// SIGNAL_WEIGHTS kept for reference — no longer used directly in scoring.
+// Scoring is now severity-scaled per signal (see analyzeSession).
+const SIGNAL_WEIGHTS = {
+  tool_retry_loop: 30,
+  session_bail: 25,
+  high_error_rate: 20,
+  long_prompt_short_session: 15,
+  no_completion: 10
+};
+
+function analyzeSession(db, sessionId) {
+  const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(sessionId);
+  if (!session) return null;
+
+  const events = db.prepare(
+    'SELECT * FROM events WHERE session_id = ? ORDER BY timestamp ASC'
+  ).all(sessionId);
+
+  const signals = [];
+
+  // 1. tool_retry_loop: Same tool called 3+ times consecutively
+  // Group by tool, keep highest streak count per tool
+  const toolCalls = events.filter(e => e.type === 'tool_call');
+  if (toolCalls.length >= 3) {
+    const worstStreakByTool = {};
+    let consecutive = 1;
+    for (let i = 1; i < toolCalls.length; i++) {
+      if (toolCalls[i].tool_name === toolCalls[i - 1].tool_name) {
+        consecutive++;
+      } else {
+        if (consecutive >= 3) {
+          const tool = toolCalls[i - 1].tool_name;
+          if (!worstStreakByTool[tool] || consecutive > worstStreakByTool[tool]) {
+            worstStreakByTool[tool] = consecutive;
+          }
+        }
+        consecutive = 1;
+      }
+    }
+    // Check final streak
+    if (consecutive >= 3) {
+      const tool = toolCalls[toolCalls.length - 1].tool_name;
+      if (!worstStreakByTool[tool] || consecutive > worstStreakByTool[tool]) {
+        worstStreakByTool[tool] = consecutive;
+      }
+    }
+    for (const [tool, count] of Object.entries(worstStreakByTool)) {
+      signals.push({ type: 'tool_retry_loop', tool, count });
+    }
+  }
+
+  // 2. session_bail: >20 tool calls but no file write events
+  if (toolCalls.length > 20) {
+    const hasWrite = events.some(e =>
+      e.type === 'tool_call' && e.tool_name &&
+      (e.tool_name === 'Write' || e.tool_name === 'Edit' ||
+       e.tool_name.toLowerCase().includes('write') ||
+       e.tool_name.toLowerCase().includes('edit'))
+    );
+    if (!hasWrite) {
+      signals.push({
+        type: 'session_bail',
+        tool_calls: toolCalls.length
+      });
+    }
+  }
+
+  // 3. high_error_rate: >30% of tool calls returned errors
+  const toolResults = events.filter(e => e.type === 'tool_result');
+  if (toolResults.length > 0) {
+    const errorResults = toolResults.filter(e => {
+      const c = (e.content || e.tool_result || '').toLowerCase();
+      return c.includes('error') || c.includes('Error') || c.includes('ERROR') ||
+             c.includes('failed') || c.includes('exception');
+    });
+    const errorRate = errorResults.length / toolResults.length;
+    if (errorRate > 0.3) {
+      signals.push({
+        type: 'high_error_rate',
+        error_count: errorResults.length,
+        total: toolResults.length,
+        rate: Math.round(errorRate * 100)
+      });
+    }
+  }
+
+  // 4. long_prompt_short_session: Initial prompt <15 words but >30 tool calls
+  if (session.initial_prompt && toolCalls.length > 30) {
+    const wordCount = session.initial_prompt.trim().split(/\s+/).length;
+    if (wordCount < 15) {
+      signals.push({
+        type: 'long_prompt_short_session',
+        prompt_words: wordCount,
+        tool_calls: toolCalls.length
+      });
+    }
+  }
+
+  // 5. no_completion: Last event is a tool call, not an assistant message
+  if (events.length > 0) {
+    const lastEvent = events[events.length - 1];
+    if (lastEvent.type === 'tool_call' || lastEvent.type === 'tool_result') {
+      signals.push({
+        type: 'no_completion',
+        last_event_type: lastEvent.type,
+        last_tool: lastEvent.tool_name || null
+      });
+    }
+  }
+
+  // Compute confusion_score — severity-scaled per signal
+  function clamp(val, min, max) { return Math.max(min, Math.min(max, val)); }
+  function lerp(t, min, max) { return min + clamp(t, 0, 1) * (max - min); }
+
+  const seenTypes = new Set();
+  let confusionScore = 0;
+  for (const sig of signals) {
+    if (seenTypes.has(sig.type)) continue;
+    seenTypes.add(sig.type);
+
+    if (sig.type === 'tool_retry_loop') {
+      // streak 3 = base 20, streak 10+ = 40
+      const t = clamp((sig.count - 3) / 7, 0, 1);
+      confusionScore += Math.round(lerp(t, 20, 40));
+    } else if (sig.type === 'session_bail') {
+      // 20 tool calls = base 15, 60+ = 30
+      const t = clamp((sig.tool_calls - 20) / 40, 0, 1);
+      confusionScore += Math.round(lerp(t, 15, 30));
+    } else if (sig.type === 'high_error_rate') {
+      // 31% error rate = base 10, 100% = 35
+      const t = clamp((sig.rate - 30) / 70, 0, 1);
+      confusionScore += Math.round(lerp(t, 10, 35));
+    } else if (sig.type === 'long_prompt_short_session') {
+      // 30 tool calls = base 10, 80+ = 20
+      const t = clamp((sig.tool_calls - 30) / 50, 0, 1);
+      confusionScore += Math.round(lerp(t, 10, 20));
+    } else if (sig.type === 'no_completion') {
+      confusionScore += 10;
+    } else {
+      confusionScore += SIGNAL_WEIGHTS[sig.type] || 0;
+    }
+  }
+  confusionScore = Math.min(confusionScore, 100);
+
+  const flagged = confusionScore >= 30;
+
+  return {
+    session_id: sessionId,
+    signals,
+    confusion_score: confusionScore,
+    flagged,
+    computed_at: new Date().toISOString()
+  };
+}
+
+function analyzeAll(db) {
+  const sessions = db.prepare('SELECT id FROM sessions').all();
+  const results = [];
+
+  const upsert = db.prepare(`
+    INSERT OR REPLACE INTO session_insights
+    (session_id, signals, confusion_score, flagged, computed_at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+
+  const runAll = db.transaction(() => {
+    for (const s of sessions) {
+      const result = analyzeSession(db, s.id);
+      if (!result) continue;
+      upsert.run(
+        result.session_id,
+        JSON.stringify(result.signals),
+        result.confusion_score,
+        result.flagged ? 1 : 0,
+        result.computed_at
+      );
+      results.push(result);
+    }
+  });
+
+  runAll();
+  return results;
+}
+
+function getInsightsSummary(db) {
+  const rows = db.prepare(
+    'SELECT si.*, s.summary, s.model, s.agent, s.start_time, s.tool_count, s.message_count FROM session_insights si JOIN sessions s ON s.id = si.session_id'
+  ).all();
+
+  if (!rows.length) {
+    return {
+      total_sessions: 0,
+      flagged_count: 0,
+      flagged_percentage: 0,
+      avg_confusion_score: 0,
+      signal_counts: {},
+      by_agent: {},
+      top_flagged: []
+    };
+  }
+
+  let totalScore = 0;
+  let flaggedCount = 0;
+  const signalCounts = {};
+  const byAgent = {};
+
+  for (const row of rows) {
+    totalScore += row.confusion_score;
+    if (row.flagged) flaggedCount++;
+
+    const signals = JSON.parse(row.signals || '[]');
+    const seenTypes = new Set();
+    for (const sig of signals) {
+      if (!seenTypes.has(sig.type)) {
+        signalCounts[sig.type] = (signalCounts[sig.type] || 0) + 1;
+        seenTypes.add(sig.type);
+      }
+    }
+
+    const agent = row.agent || 'unknown';
+    if (!byAgent[agent]) byAgent[agent] = { count: 0, flagged: 0, total_score: 0 };
+    byAgent[agent].count++;
+    if (row.flagged) byAgent[agent].flagged++;
+    byAgent[agent].total_score += row.confusion_score;
+  }
+
+  for (const agent of Object.keys(byAgent)) {
+    byAgent[agent].avg_score = Math.round(byAgent[agent].total_score / byAgent[agent].count);
+  }
+
+  const topFlagged = rows
+    .filter(r => r.flagged)
+    .sort((a, b) => b.confusion_score - a.confusion_score)
+    .slice(0, 20)
+    .map(r => ({
+      session_id: r.session_id,
+      summary: r.summary,
+      model: r.model,
+      agent: r.agent,
+      start_time: r.start_time,
+      tool_count: r.tool_count,
+      message_count: r.message_count,
+      confusion_score: r.confusion_score,
+      signals: JSON.parse(r.signals || '[]')
+    }));
+
+  return {
+    total_sessions: rows.length,
+    flagged_count: flaggedCount,
+    flagged_percentage: rows.length ? Math.round((flaggedCount / rows.length) * 100) : 0,
+    avg_confusion_score: Math.round(totalScore / rows.length),
+    signal_counts: signalCounts,
+    by_agent: byAgent,
+    top_flagged: topFlagged
+  };
+}
+
+module.exports = { analyzeSession, analyzeAll, getInsightsSummary };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentacta",
-  "version": "2026.3.26",
+  "version": "2026.3.27",
   "description": "Audit trail and search engine for AI agent sessions",
   "main": "index.js",
   "bin": {
@@ -11,6 +11,9 @@
     "indexer.js",
     "db.js",
     "config.js",
+    "project-attribution.js",
+    "delta-attribution-context.js",
+    "insights.js",
     "public/",
     "LICENSE",
     "README.md"

package/project-attribution.js

@@ -0,0 +1,443 @@
+'use strict';
+
+const PATH_KEYS = new Set([
+  'path', 'file', 'filename', 'file_path', 'filepath',
+  'cwd', 'workdir', 'directory', 'dir', 'root',
+  'repository_path', 'repositorypath', 'repo_path', 'repopath'
+]);
+
+const PROJECT_KEYS = new Set([
+  'project', 'project_name', 'projectname',
+  'repo', 'repository', 'repo_name', 'reponame', 'repository_name', 'repositoryname',
+  'workspace'
+]);
+
+const BRANCH_KEYS = new Set([
+  'branch', 'branch_name', 'branchname', 'ref', 'git_ref', 'gitref'
+]);
+
+const LOOKAROUND_WINDOW = 6;
+const MIN_CONFIDENCE = 2;
+
+function safeParseJson(value) {
+  if (typeof value !== 'string') return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function normalizeKey(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function normalizeProjectKey(value) {
+  return String(value || '').trim().toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+
+function looksLikeFilesystemPath(value, options = {}) {
+  const { allowRelative = false } = options;
+  if (typeof value !== 'string') return false;
+
+  const raw = value.trim();
+  if (!raw) return false;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) return false;
+  if (/^[\w.-]+@[\w.-]+:.+/.test(raw)) return false;
+  if (/^refs\/(heads|tags|remotes)\//i.test(raw)) return false;
+
+  const normalized = raw.replace(/\\/g, '/');
+  const isWindowsDriveAbs = /^[a-zA-Z]:\//.test(normalized);
+  const isUncAbs = normalized.startsWith('//');
+  if (
+    normalized.startsWith('/')
+    || normalized.startsWith('~/')
+    || normalized.startsWith('./')
+    || normalized.startsWith('../')
+    || isWindowsDriveAbs
+    || isUncAbs
+  ) {
+    return true;
+  }
+
+  if (!allowRelative || !normalized.includes('/')) return false;
+  if (/^(origin|remotes)\//i.test(normalized)) return false;
+
+  const parts = normalized.split('/').filter(Boolean);
+  if (!parts.length) return false;
+  if (parts.length === 2 && !parts[1].includes('.')) return false;
+
+  return parts.length >= 2;
+}
+
+function isInternalProjectTag(tag) {
+  if (!tag) return true;
+  return tag.startsWith('agent:') || tag.startsWith('claude:');
+}
+
+function toDisplayProject(tag) {
+  if (!tag || typeof tag !== 'string') return null;
+  const value = tag.trim();
+  if (!value || isInternalProjectTag(value)) return null;
+  return value;
+}
+
+function extractProjectFromPath(filePath) {
+  if (!filePath || typeof filePath !== 'string') return null;
+  const normalized = filePath.trim().replace(/\\/g, '/');
+  if (!looksLikeFilesystemPath(normalized, { allowRelative: true })) return null;
+  const isWindowsDriveAbs = /^[a-zA-Z]:\//.test(normalized);
+  const isUncAbs = normalized.startsWith('//');
+  if (!normalized.startsWith('/') && !normalized.startsWith('~') && !isWindowsDriveAbs && !isUncAbs) return null;
+
+  const rel = normalized
+    .replace(/^[a-zA-Z]:\//, '')
+    .replace(/^\/\/[^/]+\/[^/]+\//, '')
+    .replace(/^\/home\/[^/]+\//, '')
+    .replace(/^\/Users\/[^/]+\//, '')
+    .replace(/^Users\/[^/]+\//, '')
+    .replace(/^~\//, '');
+
+  const parts = rel.split('/').filter(Boolean);
+  if (!parts.length) return null;
+
+  if (parts[0] === 'Developer' && parts[1]) return parts[1];
+  if (parts[0] === 'dev' && parts[1]) return parts[1];
+  if (parts[0] === 'code' && parts[1]) return parts[1];
+  if (parts[0] === '.openclaw' && parts[1] === 'workspace') return 'workspace';
+  if (parts[0] === '.openclaw' && parts[1] === 'agents' && parts[2]) return `agent:${parts[2]}`;
+  if (parts[0] === '.claude' && parts[1] === 'projects' && parts[2]) return `claude:${parts[2]}`;
+  if (parts[0] === 'Shared') return 'shared';
+  return null;
+}
+
+function extractSessionProjects(session) {
+  const raw = session && session.projects;
+  if (!raw) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return [...new Set(parsed.map(toDisplayProject).filter(Boolean))];
+}
+
+function addCandidate(candidateSet, value) {
+  const p = toDisplayProject(value);
+  if (p) candidateSet.add(p);
+}
+
+function visitObject(value, visitor, key = '') {
+  if (!value || typeof value !== 'object') return;
+  if (Array.isArray(value)) {
+    for (const item of value) visitObject(item, visitor, key);
+    return;
+  }
+  for (const [k, v] of Object.entries(value)) {
+    visitor(k, v);
+    if (v && typeof v === 'object') visitObject(v, visitor, k);
+  }
+}
+
+function buildCandidateProjects(session, events) {
+  const candidateSet = new Set(extractSessionProjects(session));
+
+  for (const event of events || []) {
+    const args = safeParseJson(event.tool_args);
+    if (!args) continue;
+
+    visitObject(args, (key, value) => {
+      if (typeof value !== 'string') return;
+
+      const keyNorm = normalizeKey(key);
+      if (PATH_KEYS.has(keyNorm)) {
+        if (!looksLikeFilesystemPath(value, { allowRelative: true })) return;
+        addCandidate(candidateSet, extractProjectFromPath(value));
+        return;
+      }
+
+      if (looksLikeFilesystemPath(value)) {
+        addCandidate(candidateSet, extractProjectFromPath(value));
+      }
+
+      if (PROJECT_KEYS.has(keyNorm)) {
+        addCandidate(candidateSet, value);
+      }
+    });
+  }
+
+  return [...candidateSet];
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function countCandidateMentions(text, candidate) {
+  if (!text || !candidate) return 0;
+  const rx = new RegExp(`(^|[^a-z0-9])${escapeRegExp(candidate.toLowerCase())}([^a-z0-9]|$)`, 'gi');
+  let matches = 0;
+  let m;
+  const haystack = text.toLowerCase();
+  while ((m = rx.exec(haystack)) !== null) {
+    matches += 1;
+  }
+  return matches;
+}
+
+function buildCandidateLookup(candidates) {
+  const byNorm = new Map();
+  for (const candidate of candidates) {
+    byNorm.set(normalizeProjectKey(candidate), candidate);
+  }
+  return byNorm;
+}
+
+function resolveCandidate(value, candidates, byNorm, options = {}) {
+  const { allowPath = true } = options;
+  if (!value || typeof value !== 'string') return null;
+  const raw = value.trim();
+  if (!raw) return null;
+
+  if (allowPath) {
+    const fromPath = toDisplayProject(extractProjectFromPath(raw));
+    if (fromPath) {
+      const resolved = byNorm.get(normalizeProjectKey(fromPath));
+      return resolved || fromPath;
+    }
+  }
+
+  const direct = byNorm.get(normalizeProjectKey(raw));
+  if (direct) return direct;
+
+  const lower = raw.toLowerCase();
+  for (const candidate of candidates) {
+    const rx = new RegExp(`(^|[^a-z0-9])${escapeRegExp(candidate.toLowerCase())}([^a-z0-9]|$)`, 'i');
+    if (rx.test(lower)) return candidate;
+  }
+
+  return null;
+}
+
+function chooseBestProject(scores) {
+  let bestProject = null;
+  let bestScore = 0;
+  let secondBest = 0;
+
+  for (const [project, score] of scores.entries()) {
+    if (score > bestScore) {
+      secondBest = bestScore;
+      bestScore = score;
+      bestProject = project;
+      continue;
+    }
+    if (score > secondBest) secondBest = score;
+  }
+
+  if (!bestProject || bestScore < MIN_CONFIDENCE) {
+    return { project: null, score: 0 };
+  }
+  if (bestScore === secondBest) {
+    return { project: null, score: 0 };
+  }
+  return { project: bestProject, score: bestScore };
+}
+
+function addScore(scores, project, value) {
+  if (!project || value <= 0) return;
+  scores.set(project, (scores.get(project) || 0) + value);
+}
+
+function extractCallBaseId(id) {
+  if (!id) return '';
+  return String(id).replace(/:(call|result)$/, '');
+}
+
+function scoreEvent(event, candidates, byNorm) {
+  const scores = new Map();
+  const args = safeParseJson(event.tool_args);
+
+  if (args) {
+    visitObject(args, (key, value) => {
+      if (typeof value !== 'string') return;
+      const keyNorm = normalizeKey(key);
+      if (PATH_KEYS.has(keyNorm)) {
+        const candidate = resolveCandidate(value, candidates, byNorm, { allowPath: true });
+        if (!candidate) return;
+        addScore(scores, candidate, 4);
+        return;
+      }
+
+      if (PROJECT_KEYS.has(keyNorm)) {
+        const candidate = resolveCandidate(value, candidates, byNorm, { allowPath: true });
+        if (!candidate) return;
+        addScore(scores, candidate, 3);
+        return;
+      }
+
+      if (BRANCH_KEYS.has(keyNorm)) {
+        const candidate = resolveCandidate(value, candidates, byNorm, { allowPath: false });
+        if (!candidate) return;
+        addScore(scores, candidate, 2);
+        return;
+      }
+
+      if (looksLikeFilesystemPath(value)) {
+        const candidate = resolveCandidate(value, candidates, byNorm, { allowPath: true });
+        if (!candidate) return;
+        addScore(scores, candidate, 3);
+        return;
+      }
+
+      const candidate = resolveCandidate(value, candidates, byNorm, { allowPath: false });
+      if (!candidate) return;
+      addScore(scores, candidate, 1);
+    });
+  }
+
+  if (typeof event.content === 'string' && event.content) {
+    for (const candidate of candidates) {
+      const count = countCandidateMentions(event.content, candidate);
+      if (count > 0) addScore(scores, candidate, Math.min(count, 2));
+    }
+  }
+
+  if (typeof event.tool_name === 'string' && event.tool_name) {
+    const candidate = resolveCandidate(event.tool_name, candidates, byNorm);
+    if (candidate) addScore(scores, candidate, 1);
+  }
+
+  return chooseBestProject(scores);
+}
+
+function findPrevAttributed(events, idx) {
+  for (let i = idx - 1; i >= 0 && idx - i <= LOOKAROUND_WINDOW; i--) {
+    if (events[i].project) return events[i].project;
+  }
+  return null;
+}
+
+function findNextAttributed(events, idx) {
+  for (let i = idx + 1; i < events.length && i - idx <= LOOKAROUND_WINDOW; i++) {
+    if (events[i].project) return events[i].project;
+  }
+  return null;
+}
+
+function attributeSessionEvents(session, events) {
+  const list = Array.isArray(events) ? events : [];
+  if (!list.length) return { events: [], projectFilters: [] };
+
+  const candidates = buildCandidateProjects(session, list);
+  const byNorm = buildCandidateLookup(candidates);
+  const withOrder = list.map((event, idx) => ({ idx, event }));
+
+  withOrder.sort((a, b) => {
+    const ta = Date.parse(a.event.timestamp || 0) || 0;
+    const tb = Date.parse(b.event.timestamp || 0) || 0;
+    if (ta !== tb) return ta - tb;
+    return String(a.event.id || '').localeCompare(String(b.event.id || ''));
+  });
+
+  const callProjectByBase = new Map();
+  const attributedOrdered = withOrder.map(({ idx, event }) => {
+    const base = {
+      ...event,
+      project: null,
+      project_confidence: 0
+    };
+
+    const scored = scoreEvent(base, candidates, byNorm);
+    if (scored.project) {
+      base.project = scored.project;
+      base.project_confidence = scored.score;
+    }
+
+    if (base.type === 'tool_call' && base.project) {
+      const callBaseId = extractCallBaseId(base.id);
+      if (callBaseId) callProjectByBase.set(callBaseId, base.project);
+    }
+
+    return { idx, event: base };
+  });
+
+  const orderedEvents = attributedOrdered.map(entry => entry.event);
+
+  for (let i = 0; i < orderedEvents.length; i++) {
+    const current = orderedEvents[i];
+    if (current.project) continue;
+
+    if (current.type === 'tool_result') {
+      const callBaseId = extractCallBaseId(current.id);
+      const linkedProject = callProjectByBase.get(callBaseId);
+      if (linkedProject) {
+        current.project = linkedProject;
+        current.project_confidence = 3;
+        continue;
+      }
+    }
+
+    if (current.type !== 'message') continue;
+
+    const prevProject = findPrevAttributed(orderedEvents, i);
+    const nextProject = findNextAttributed(orderedEvents, i);
+
+    if (prevProject && nextProject && prevProject === nextProject) {
+      current.project = prevProject;
+      current.project_confidence = 2;
+      continue;
+    }
+
+    if (prevProject && !nextProject) {
+      current.project = prevProject;
+      current.project_confidence = 2;
+    }
+  }
+
+  const eventsOut = new Array(list.length);
+  for (const entry of attributedOrdered) {
+    eventsOut[entry.idx] = entry.event;
+  }
+
+  const counts = new Map();
+  for (const event of eventsOut) {
+    if (!event.project || event.project_confidence < MIN_CONFIDENCE) {
+      event.project = null;
+      event.project_confidence = 0;
+      continue;
+    }
+    counts.set(event.project, (counts.get(event.project) || 0) + 1);
+  }
+
+  const projectFilters = [...counts.entries()]
+    .sort((a, b) => (b[1] - a[1]) || a[0].localeCompare(b[0]))
+    .map(([project, eventCount]) => ({ project, eventCount }));
+
+  return { events: eventsOut, projectFilters };
+}
+
+function attributeEventDelta(session, deltaEvents, contextEvents = []) {
+  const delta = Array.isArray(deltaEvents) ? deltaEvents : [];
+  if (!delta.length) return [];
+
+  const context = Array.isArray(contextEvents) ? contextEvents : [];
+  const merged = [...context, ...delta];
+  const attributed = attributeSessionEvents(session, merged).events;
+
+  const byId = new Map();
+  for (const event of attributed) {
+    if (!event || !event.id) continue;
+    byId.set(event.id, event);
+  }
+
+  return delta.map(event => byId.get(event.id) || { ...event, project: null, project_confidence: 0 });
+}
+
+module.exports = {
+  attributeSessionEvents,
+  attributeEventDelta,
+  extractProjectFromPath,
+  isInternalProjectTag
+};