agentacta 2026.3.26 → 2026.4.8

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/indexer.js

@@ -29,14 +29,21 @@ function discoverSessionDirs(config) {
   const dirs = [];
   const home = process.env.HOME;
   const codexSessionsPath = path.join(home, '.codex/sessions');
+  const cronRunsPath = path.join(home, '.openclaw/cron/runs');
 
   function normalizedPath(p) {
     return path.resolve(p).replace(/[\\\/]+$/, '');
   }
 
-  function hasDir(targetPath) {
+  function hasDir(targetPath, sourceType = 'transcript') {
     const wanted = normalizedPath(targetPath);
-    return dirs.some(d => normalizedPath(d.path) === wanted);
+    return dirs.some(d => normalizedPath(d.path) === wanted && (d.sourceType || 'transcript') === sourceType);
+  }
+
+  function addDir(dir) {
+    if (!dir || !dir.path) return;
+    if (hasDir(dir.path, dir.sourceType || 'transcript')) return;
+    dirs.push(dir);
   }
 
   // Expand a single path into session dirs, handling Claude Code's per-project structure
@@ -52,14 +59,14 @@ function discoverSessionDirs(config) {
         const projDir = path.join(p, proj);
         if (fs.statSync(projDir).isDirectory()) {
           const hasJsonl = fs.readdirSync(projDir).some(f => f.endsWith('.jsonl'));
-          if (hasJsonl) dirs.push({ path: projDir, agent: 'claude-code' });
+          if (hasJsonl) addDir({ path: projDir, agent: 'claude-code' });
         }
       }
     } else if (normalized === normalizedCodex) {
       // Codex CLI stores nested YYYY/MM/DD directories and must be recursive.
-      dirs.push({ path: p, agent: 'codex-cli', recursive: true });
+      addDir({ path: p, agent: 'codex-cli', recursive: true });
     } else {
-      dirs.push({ path: p, agent: path.basename(path.dirname(p)) });
+      addDir({ path: p, agent: path.basename(path.dirname(p)) });
     }
   }
 
@@ -70,11 +77,6 @@ function discoverSessionDirs(config) {
       ? sessionsOverride
       : sessionsOverride.split(':');
     overridePaths.forEach(expandPath);
-    // Keep direct Codex visibility even when custom overrides omit it.
-    if (fs.existsSync(codexSessionsPath) && fs.statSync(codexSessionsPath).isDirectory() && !hasDir(codexSessionsPath)) {
-      dirs.push({ path: codexSessionsPath, agent: 'codex-cli', recursive: true });
-    }
-    if (dirs.length) return dirs;
   }
 
   // Auto-discover: ~/.openclaw/agents/*/sessions/
@@ -83,7 +85,7 @@ function discoverSessionDirs(config) {
     for (const agent of fs.readdirSync(oclawAgents)) {
       const sp = path.join(oclawAgents, agent, 'sessions');
       if (fs.existsSync(sp) && fs.statSync(sp).isDirectory()) {
-        dirs.push({ path: sp, agent });
+        addDir({ path: sp, agent });
       }
     }
   }
@@ -94,13 +96,18 @@ function discoverSessionDirs(config) {
   // Scan ~/.codex/sessions recursively (Codex CLI stores nested YYYY/MM/DD/*.jsonl)
   const codexSessions = codexSessionsPath;
   if (fs.existsSync(codexSessions) && fs.statSync(codexSessions).isDirectory()) {
-    dirs.push({ path: codexSessions, agent: 'codex-cli', recursive: true });
+    addDir({ path: codexSessions, agent: 'codex-cli', recursive: true });
+  }
+
+  // Fallback synthetic source for cron-backed runs that have metadata but no transcript JSONL.
+  if (fs.existsSync(cronRunsPath) && fs.statSync(cronRunsPath).isDirectory()) {
+    addDir({ path: cronRunsPath, agent: 'cron', sourceType: 'cron-run' });
   }
 
   if (!dirs.length) {
     // Fallback to hardcoded
     const fallback = path.join(home, '.openclaw/agents/main/sessions');
-    if (fs.existsSync(fallback)) dirs.push({ path: fallback, agent: 'main' });
+    if (fs.existsSync(fallback)) addDir({ path: fallback, agent: 'main' });
   }
 
   return dirs;
@@ -261,6 +268,94 @@ function extractProjectFromPath(filePath, config) {
   return null;
 }
 
+function indexCronRunFile(db, filePath, agentName, stmts) {
+  const stat = fs.statSync(filePath);
+  const mtime = stat.mtime.toISOString();
+
+  if (!REINDEX) {
+    const state = stmts.getState.get(filePath);
+    if (state && state.last_modified === mtime) return { skipped: true };
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf8').trim();
+  if (!raw) return { skipped: true };
+
+  let meta;
+  try {
+    meta = JSON.parse(raw.split('\n').find(Boolean));
+  } catch {
+    return { skipped: true };
+  }
+
+  const sessionId = meta.sessionId;
+  if (!sessionId) return { skipped: true };
+
+  // Guard: don't overwrite a session that was already indexed from a real transcript.
+  // Check both event presence AND session_type — a transcript session with zero events
+  // (e.g. header-only file) should still win over synthetic cron metadata.
+  const existingSession = db.prepare('SELECT session_type FROM sessions WHERE id = ?').get(sessionId);
+  if (existingSession && existingSession.session_type !== 'cron') {
+    stmts.upsertState.run(filePath, 1, mtime);
+    return { skipped: true, preferredTranscript: true, sessionId };
+  }
+  const existingRealSession = db.prepare('SELECT EXISTS(SELECT 1 FROM events WHERE session_id = ?) AS has_events').get(sessionId);
+  if (existingRealSession && existingRealSession.has_events) {
+    stmts.upsertState.run(filePath, 1, mtime);
+    return { skipped: true, preferredTranscript: true, sessionId };
+  }
+
+  const ts = typeof meta.ts === 'number' ? new Date(meta.ts).toISOString() : new Date().toISOString();
+  const runAt = typeof meta.runAtMs === 'number' ? new Date(meta.runAtMs).toISOString() : ts;
+  const durationMs = typeof meta.durationMs === 'number' ? meta.durationMs : null;
+  const endTime = ts;
+  const startTime = durationMs ? new Date(new Date(endTime).getTime() - durationMs).toISOString() : runAt;
+  const summary = stripLeadingDatetimePrefix(meta.summary || 'Cron run');
+  const sessionKey = typeof meta.sessionKey === 'string' ? meta.sessionKey : '';
+  const sessionKeyParts = sessionKey.split(':');
+  const inferredAgent = sessionKeyParts[0] === 'agent' && sessionKeyParts[1] ? sessionKeyParts[1] : agentName;
+  const model = meta.model || meta.provider || null;
+  const totalInputTokens = meta.usage && typeof meta.usage.input_tokens === 'number' ? meta.usage.input_tokens : 0;
+  const totalOutputTokens = meta.usage && typeof meta.usage.output_tokens === 'number' ? meta.usage.output_tokens : 0;
+  const totalTokens = meta.usage && typeof meta.usage.total_tokens === 'number'
+    ? meta.usage.total_tokens
+    : totalInputTokens + totalOutputTokens;
+
+  const commitIndex = db.transaction(() => {
+    if (stmts.deleteArchive) stmts.deleteArchive.run(sessionId);
+    stmts.deleteFileActivity.run(sessionId);
+    stmts.deleteEvents.run(sessionId);
+    stmts.deleteSession.run(sessionId);
+
+    stmts.upsertSession.run(
+      sessionId,
+      startTime,
+      endTime,
+      0,
+      0,
+      model,
+      summary,
+      inferredAgent,
+      'cron',
+      0,
+      totalTokens,
+      totalInputTokens,
+      totalOutputTokens,
+      0,
+      0,
+      null,
+      null,
+      null,
+      model ? JSON.stringify([model]) : null,
+      null
+    );
+
+    stmts.upsertState.run(filePath, 1, mtime);
+  });
+
+  commitIndex();
+  return { sessionId, synthetic: true };
+}
+
 function indexFile(db, filePath, agentName, stmts, archiveMode, config) {
   const stat = fs.statSync(filePath);
   const mtime = stat.mtime.toISOString();
@@ -664,7 +759,7 @@ function run() {
   let allFiles = [];
   for (const dir of sessionDirs) {
     const files = listJsonlFiles(dir.path, !!dir.recursive)
-      .map(filePath => ({ path: filePath, agent: dir.agent }));
+      .map(filePath => ({ path: filePath, agent: dir.agent, sourceType: dir.sourceType || 'transcript' }));
     allFiles.push(...files);
   }
 
@@ -673,7 +768,9 @@ function run() {
   const indexMany = db.transaction(() => {
     let indexed = 0;
     for (const f of allFiles) {
-      const result = indexFile(db, f.path, f.agent, stmts, archiveMode, config);
+      const result = f.sourceType === 'cron-run'
+        ? indexCronRunFile(db, f.path, f.agent, stmts)
+        : indexFile(db, f.path, f.agent, stmts, archiveMode, config);
       if (!result.skipped) {
         indexed++;
         if (indexed % 10 === 0) process.stdout.write('.');
@@ -706,7 +803,9 @@ function run() {
               const files = listJsonlFiles(dir.path, true);
               let changed = 0;
               for (const filePath of files) {
-                const result = indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
+                const result = dir.sourceType === 'cron-run'
+                  ? indexCronRunFile(db, filePath, dir.agent, stmts)
+                  : indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
                 if (!result.skipped) changed++;
               }
               if (changed > 0) console.log(`Re-indexed ${changed} files (${dir.agent})`);
@@ -723,7 +822,9 @@ function run() {
         if (!fs.existsSync(filePath)) return;
         setTimeout(() => {
           try {
-            const result = indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
+            const result = dir.sourceType === 'cron-run'
+              ? indexCronRunFile(db, filePath, dir.agent, stmts)
+              : indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
             if (!result.skipped) console.log(`Re-indexed: ${filename} (${dir.agent})`);
           } catch (err) {
             console.error(`Error re-indexing ${filename}:`, err.message);
@@ -745,7 +846,9 @@ function indexAll(db, config) {
     const files = listJsonlFiles(dir.path, !!dir.recursive);
     for (const filePath of files) {
       try {
-        const result = indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
+        const result = dir.sourceType === 'cron-run'
+          ? indexCronRunFile(db, filePath, dir.agent, stmts)
+          : indexFile(db, filePath, dir.agent, stmts, archiveMode, config);
         if (!result.skipped) totalSessions++;
       } catch (err) {
         console.error(`Error indexing ${path.basename(filePath)}:`, err.message);
@@ -757,6 +860,6 @@ function indexAll(db, config) {
   return { sessions: stats.sessions, events: evStats.events, newSessions: totalSessions };
 }
 
-module.exports = { discoverSessionDirs, listJsonlFiles, indexFile, indexAll };
+module.exports = { discoverSessionDirs, listJsonlFiles, indexFile, indexCronRunFile, indexAll };
 
 if (require.main === module) run();

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.4.8",
   "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"
@@ -51,4 +54,4 @@
     "tar-fs": "^3.0.6",
     "npmlog": "^7.0.1"
   }
-}
+}

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
+};

package/public/style.css

@@ -162,6 +162,8 @@ body {
   -webkit-font-smoothing: antialiased;
   -moz-osx-font-smoothing: grayscale;
   font-feature-settings: 'cv02', 'cv03', 'cv04', 'cv11';
+  overscroll-behavior-y: none;
+  overflow-x: hidden;
 }
 
 html.cmdk-open,
@@ -563,6 +565,8 @@ body.cmdk-open {
   cursor: pointer;
   transition: all var(--duration-normal) var(--ease-out);
   position: relative;
+  overflow: hidden;
+  max-width: 100%;
 }
 
 .session-item:hover {
@@ -1550,7 +1554,8 @@ mark {
     bottom: calc(24px + env(safe-area-inset-bottom, 0px));
     left: 50%;
     right: auto;
-    transform: translateX(-50%);
+    transform: translateX(-50%) translateZ(0);
+    -webkit-transform: translateX(-50%) translateZ(0);
     width: auto;
     height: auto;
     border-right: none;