server.js

import express from 'express';
import fs from 'fs';
import path from 'path';
import os from 'os';
import { fileURLToPath } from 'url';
import { execFile, execFileSync } from 'child_process';
import AnthropicBedrock from '@anthropic-ai/bedrock-sdk';
import { getClient as getValkeyClient, isReady as isValkeyReady } from './lib/valkey.js';

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const app = express();
const PORT = 6767;
const PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
const GLOBAL_RADAR_CONFIG = path.join(os.homedir(), '.claude', 'radar.json');
const { currentUsername, avatarUrl } = (() => {
  // 1. gh CLI — gives both login and avatar_url in one call
  try {
    const raw = execFileSync('gh', ['api', 'user'], { encoding: 'utf-8', timeout: 5000 });
    const user = JSON.parse(raw);
    if (user.login) return { currentUsername: user.login, avatarUrl: user.avatar_url || '' };
  } catch {}
  // 2. Explicit git config (username only, no avatar)
  try {
    const r = execFileSync('git', ['config', 'github.user'], { encoding: 'utf-8', timeout: 2000 }).trim();
    if (r) return { currentUsername: r, avatarUrl: '' };
  } catch {}
  // 3. Env var
  if (process.env.GITHUB_USERNAME) return { currentUsername: process.env.GITHUB_USERNAME, avatarUrl: '' };
  // 4. OS username, no avatar
  try { return { currentUsername: os.userInfo().username, avatarUrl: '' }; } catch {}
  return { currentUsername: '', avatarUrl: '' };
})();

const bedrock = new AnthropicBedrock({ aws_region: process.env.AWS_REGION || 'eu-west-1' });

// Cache parsed session files so we don't re-read unchanged files every poll
const fileCache = new Map(); // key: filePath, value: { mtime, data }

// Activity map — populated by hook-based POST /api/activity events.
// key: sessionId, value: { event, timestamp }
const activityMap = new Map();

function setActivity(sessionId, data) {
  activityMap.set(sessionId, data);
  try {
    const filePath = findSessionFile(sessionId);
    if (filePath) {
      const projPath = resolveProjectPath(path.basename(path.dirname(filePath)));
      for (const { client, swimlane } of getProjectPushTargets(projPath)) {
        client.set(`radar:${swimlane}:activity:${sessionId}`, JSON.stringify(data), 'EX', 7200).catch(() => {});
      }
    }
  } catch {}
}

function getActivity(sessionId) {
  return activityMap.get(sessionId);
}

// Persistent cache helper: stores { value: string, fileSize: number } per session.
// Reads from JSON file at startup; writes back to JSON file on every set.
// Per-project Valkey sync is handled separately via syncToValkey().
function createPersistentCache(filePath) {
  const map = new Map();
  try {
    const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
    for (const [id, entry] of Object.entries(data)) {
      // Migrate old { title, fileSize } format
      if (entry.value === undefined && entry.title !== undefined) {
        map.set(id, { value: entry.title, fileSize: entry.fileSize });
      } else {
        map.set(id, entry);
      }
    }
  } catch {}
  return {
    get(id) { return map.get(id); },
    has(id) { return map.has(id); },
    loadEntry(id, entry) { map.set(id, entry); },
    set(id, value, fileSize) {
      map.set(id, { value, fileSize });
      const obj = Object.fromEntries(map);
      fs.writeFileSync(filePath, JSON.stringify(obj), 'utf-8');
    },
    needsRefresh(id, sessionFilePath) {
      const cached = map.get(id);
      if (!cached || !cached.value) return true;
      try {
        const currentSize = fs.statSync(sessionFilePath).size;
        return currentSize - cached.fileSize >= 10240;
      } catch { return false; }
    },
  };
}

const titleCache = createPersistentCache(path.join(__dirname, 'titles.json'));
const blurbCache = createPersistentCache(path.join(__dirname, 'blurbs.json'));

// swimlaneKey → [projectPath, ...] — rebuilt on each GET /api/sessions, used by config endpoint
const swimlaneProjectPaths = new Map();

// Remote sessions pulled from subscriptions — key: "{url}:{swimlane}", value: [session, ...]
const remoteSessionsCache = new Map();

let lastSessionPush = 0;

function makeSlug(name, branch) {
  const base = (name || 'unnamed').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
  const b = (branch || '').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
  return (b && b !== 'main' && b !== 'master') ? `${base}-${b}` : base;
}

function readGlobalRadarConfig() {
  try { return JSON.parse(fs.readFileSync(GLOBAL_RADAR_CONFIG, 'utf-8')); } catch { return null; }
}

// Returns all push targets for a project: [{ client, swimlane }]
function getProjectPushTargets(projectPath) {
  const pushList = readRadarConfig(projectPath)?.push;
  if (!Array.isArray(pushList) || pushList.length === 0) return [];
  return pushList
    .filter(p => p?.valkey?.url)
    .map(p => ({
      client: getValkeyClient(p.valkey.url, p.valkey.password || ''),
      swimlane: p.swimlane || 'default',
    }));
}

// Push a cache entry to all of the project's Valkey targets (fire-and-forget)
// cacheType is 'titles' or 'blurbs' — keyed as radar:{swimlane}:{cacheType}
function syncToValkey(filePath, cacheType, sessionId, value, fileSize) {
  if (!value) return;
  try {
    const projPath = resolveProjectPath(path.basename(path.dirname(filePath)));
    for (const { client, swimlane } of getProjectPushTargets(projPath)) {
      client.hset(`radar:${swimlane}:${cacheType}`, sessionId, JSON.stringify({ value, fileSize }))
        .catch(() => {});
    }
  } catch {}
}

async function pushSessionsToValkey(projects) {
  for (const project of projects) {
    if (!project.valkeyPush?.length) continue;
    for (const { url, swimlane } of project.valkeyPush) {
      const radarConfig = readRadarConfig(project.projectPath);
      const password = radarConfig?.push?.find(p => p?.valkey?.url === url)?.valkey?.password || '';
      const client = getValkeyClient(url, password);
      if (client.status !== 'ready') continue;
      for (const s of project.sessions) {
        const key = `${s.username}:${s.sessionId}`;
        const payload = JSON.stringify({
          sessionId: s.sessionId, username: s.username, avatarUrl: s.avatarUrl,
          title: s.title, blurb: s.blurb, status: s.status,
          modified: s.modified, created: s.created,
          messageCount: s.messageCount, gitBranch: s.gitBranch, isSidechain: s.isSidechain,
          slug: project.slug, projectName: project.projectName,
          swimlaneTitle: project.swimlaneTitle, repoUrl: project.repoUrl, branch: project.branch,
          pushedAt: Date.now(),
        });
        client.hset(`radar:${swimlane}:sessions`, key, payload).catch(() => {});
      }
    }
  }
}

function maybePushSessionsToValkey(projects) {
  if (Date.now() - lastSessionPush < 30000) return;
  lastSessionPush = Date.now();
  pushSessionsToValkey(projects).catch(() => {});
}

async function pullSubscriptions() {
  const subs = (readGlobalRadarConfig()?.subscriptions || []).filter(s => s?.valkey?.url);
  for (const sub of subs) {
    const swimlane = sub.swimlane || 'default';
    const cacheKey = `${sub.valkey.url}:${swimlane}`;
    try {
      const client = getValkeyClient(sub.valkey.url, sub.valkey.password || '');
      await Promise.race([
        new Promise(r => client.status === 'ready' ? r() : client.once('ready', r)),
        new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 3000)),
      ]);
      const hash = await client.hgetall(`radar:${swimlane}:sessions`);
      const sessions = Object.values(hash || {})
        .map(v => { try { return JSON.parse(v); } catch {} })
        .filter(Boolean)
        .filter(s => Date.now() - s.pushedAt < 86400000);
      remoteSessionsCache.set(cacheKey, sessions);
      const [titles, blurbs] = await Promise.all([
        client.hgetall(`radar:${swimlane}:titles`),
        client.hgetall(`radar:${swimlane}:blurbs`),
      ]);
      if (titles) for (const [id, j] of Object.entries(titles)) try { titleCache.loadEntry(id, JSON.parse(j)); } catch {}
      if (blurbs) for (const [id, j] of Object.entries(blurbs)) try { blurbCache.loadEntry(id, JSON.parse(j)); } catch {}
    } catch {}
  }
}

app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));

// Find the .jsonl file for a session ID by scanning project dirs
function findSessionFile(sessionId) {
  try {
    for (const dir of fs.readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
      if (!dir.isDirectory()) continue;
      const fp = path.join(PROJECTS_DIR, dir.name, sessionId + '.jsonl');
      if (fs.existsSync(fp)) return fp;
    }
  } catch {}
  return null;
}

// ── Progressive compaction ─────────────────────────────────────────────────
// One compaction file per session: ~/.claude/radar-compact/{dirName}/{sessionId}.json
// { summary, coveredUpToBytes, generatedAt }
//
// The summary covers bytes 0..coveredUpToBytes. When the session grows, we extend
// the summary by incorporating new content in CHUNK-sized increments:
//   new_summary = compact(old_summary + raw_new_content)
// This ensures each title/blurb generation call costs at most one extra compact call
// once the session is larger than one chunk.

const CHUNK = 131072; // 128KB
const COMPACT_BASE = path.join(os.homedir(), '.claude', 'radar-compact');

// Extract user/assistant text turns from a raw .jsonl text blob
function extractTurns(text) {
  const seen = new Set();
  const turns = [];
  for (const line of text.split('\n')) {
    if (!line.trim()) continue;
    try {
      const obj = JSON.parse(line);
      if (obj.type !== 'user' && obj.type !== 'assistant') continue;
      const id = obj.message?.id || obj.uuid;
      if (id) { if (seen.has(id)) continue; seen.add(id); }
      const content = obj.message?.content;
      let t = '';
      if (typeof content === 'string') t = content;
      else if (Array.isArray(content)) {
        t = content.filter(c => c?.type === 'text' && c.text).map(c => c.text).join(' ');
      }
      if (t.trim()) turns.push({ role: obj.type, text: t.slice(0, 1000) });
    } catch {}
  }
  return turns;
}

function compactFilePath(dirName, sessionId) {
  return path.join(COMPACT_BASE, dirName, `${sessionId}.json`);
}

function readCompaction(dirName, sessionId) {
  try {
    return JSON.parse(fs.readFileSync(compactFilePath(dirName, sessionId), 'utf-8'));
  } catch { return null; }
}

function writeCompaction(dirName, sessionId, summary, coveredUpToBytes) {
  const dir = path.join(COMPACT_BASE, dirName);
  fs.mkdirSync(dir, { recursive: true });
  fs.writeFileSync(compactFilePath(dirName, sessionId), JSON.stringify({ summary, coveredUpToBytes, generatedAt: Date.now() }), 'utf-8');
}

// Read bytes [from, to) from an open fd and return as formatted turn text
function readChunkAsText(fd, from, to) {
  const buf = Buffer.alloc(to - from);
  fs.readSync(fd, buf, 0, to - from, from);
  const turns = extractTurns(buf.toString('utf-8'));
  return turns.map(t => `${t.role}: ${t.text}`).join('\n\n');
}

// Compact a text blob into a dense summary via Haiku
async function compactWithHaiku(inputText) {
  const resp = await bedrock.messages.create({
    model: 'eu.anthropic.claude-haiku-4-5-20251001-v1:0',
    max_tokens: 800,
    messages: [{
      role: 'user',
      content: `Summarize this coding session transcript into a dense summary (300-500 words) preserving: the main goal, key decisions, technologies and files involved, and current state of progress. This summary will be used alongside newer messages for final summarization.\n\n${inputText.slice(0, 60000)}`,
    }],
  });
  return (resp.content[0]?.text || '').trim();
}

// Return the best available conversation context for title/blurb generation.
// SYNCHRONOUS — never calls Haiku. Uses stored compaction if available, else raw head+tail.
// Compaction building is handled separately by buildSessionCompaction().
function getConversationContext(sessionId, filePath) {
  const size = fs.statSync(filePath).size;
  const dirName = path.basename(path.dirname(filePath));
  const fd = fs.openSync(filePath, 'r');

  try {
    if (size <= CHUNK) {
      const buf = Buffer.alloc(size);
      fs.readSync(fd, buf, 0, size, 0);
      const turns = extractTurns(buf.toString('utf-8'));
      return turns.map(t => `${t.role}: ${t.text}`).join('\n\n');
    }

    const tailStart = size - CHUNK;
    const tailText = readChunkAsText(fd, tailStart, size);
    const existing = readCompaction(dirName, sessionId);

    let headText;
    if (existing && existing.coveredUpToBytes >= tailStart) {
      // Compaction covers the entire head — best case
      headText = existing.summary;
    } else if (existing) {
      // Compaction is stale: use it + raw bridge to tailStart
      const bridgeText = readChunkAsText(fd, existing.coveredUpToBytes, tailStart);
      headText = bridgeText ? `${existing.summary}\n\n${bridgeText}` : existing.summary;
    } else {
      // No compaction yet: fall back to raw first CHUNK of head
      const headEnd = Math.min(tailStart, CHUNK);
      headText = readChunkAsText(fd, 0, headEnd);
    }

    return `${headText}\n\n${tailText}`;
  } finally {
    fs.closeSync(fd);
  }
}

// Build or extend the stored compaction for a session.
// Called from the background compaction pass, not from title/blurb generation.
async function buildSessionCompaction(sessionId, filePath) {
  const size = fs.statSync(filePath).size;
  if (size <= CHUNK) return; // No compaction needed for small sessions

  const dirName = path.basename(path.dirname(filePath));
  const tailStart = size - CHUNK;

  const existing = readCompaction(dirName, sessionId);
  if (existing && existing.coveredUpToBytes >= tailStart) return; // Already current

  let summary = existing?.summary || '';
  let coveredUpTo = existing?.coveredUpToBytes || 0;

  const fd = fs.openSync(filePath, 'r');
  try {
    while (coveredUpTo < tailStart) {
      const nextBoundary = Math.min(coveredUpTo + CHUNK, tailStart);
      const rawText = readChunkAsText(fd, coveredUpTo, nextBoundary);
      const input = summary
        ? `Previous summary:\n${summary}\n\nContinued:\n${rawText}`
        : rawText;
      summary = await compactWithHaiku(input);
      coveredUpTo = nextBoundary;
      writeCompaction(dirName, sessionId, summary, coveredUpTo);
    }
  } finally {
    fs.closeSync(fd);
  }
}

// Detect Haiku refusal/meta-responses (e.g. "I don't have a coding session...")
function isHaikuRefusal(text) {
  if (!text) return false;
  const t = text.toLowerCase();
  return (t.startsWith('i don') || t.startsWith('i can') || t.startsWith('i need')
    || t.startsWith('there') || t.startsWith('no coding')
    || t.includes('coding session') || t.includes('to summarize'));
}

// Generate a tweet-length blurb via Haiku
async function generateBlurb(sessionId) {
  const filePath = findSessionFile(sessionId);
  if (!filePath) return;

  let fileSize = 0;
  try { fileSize = fs.statSync(filePath).size; } catch { return; }

  let convo = '';
  try { convo = getConversationContext(sessionId, filePath); } catch {}
  if (!convo) {
    blurbCache.set(sessionId, '', fileSize);
    return;
  }

  try {
    const resp = await bedrock.messages.create({
      model: 'eu.anthropic.claude-haiku-4-5-20251001-v1:0',
      max_tokens: 120,
      messages: [{
        role: 'user',
        content: `Summarize this coding session in one sentence (under 200 chars), like a tweet. Focus on what was accomplished or is in progress. No hashtags or emoji. Just the substance.\n\n${convo}`,
      }],
    });
    let blurb = (resp.content[0] && resp.content[0].text || '').trim();
    if (isHaikuRefusal(blurb)) blurb = '';
    blurbCache.set(sessionId, blurb, fileSize);
    syncToValkey(filePath, 'blurbs', sessionId, blurb, fileSize);
  } catch (err) {
    console.error('Blurb generation failed:', err.message);
    blurbCache.set(sessionId, '', fileSize);
  }
}

// needsTitle/needsBlurb are just wrappers around the cache's needsRefresh
function needsTitle(sessionId, filePath) {
  return titleCache.needsRefresh(sessionId, filePath);
}

// Generate a short title via Haiku
async function generateTitle(sessionId) {
  const filePath = findSessionFile(sessionId);
  if (!filePath) return;

  let fileSize = 0;
  try { fileSize = fs.statSync(filePath).size; } catch { return; }

  let convo = '';
  try { convo = getConversationContext(sessionId, filePath); } catch {}
  if (!convo) {
    titleCache.set(sessionId, '', fileSize);
    return;
  }

  try {
    const resp = await bedrock.messages.create({
      model: 'eu.anthropic.claude-haiku-4-5-20251001-v1:0',
      max_tokens: 40,
      messages: [{
        role: 'user',
        content: `Summarize this coding session in 3-8 words as a title. No quotes, no punctuation, no preamble. Just the title.\n\n${convo}`,
      }],
    });
    let title = (resp.content[0] && resp.content[0].text || '').trim();
    // Discard Haiku refusals/meta-responses
    if (isHaikuRefusal(title)) title = '';
    titleCache.set(sessionId, title, fileSize);
    syncToValkey(filePath, 'titles', sessionId, title, fileSize);
  } catch (err) {
    console.error('Title generation failed:', err.message);
    titleCache.set(sessionId, '', fileSize);
  }
}

// Hook endpoint — receives activity events from Claude Code hooks
app.post('/api/activity', (req, res) => {
  const { sessionId, event } = req.body || {};
  if (!sessionId || !event) return res.status(400).json({ error: 'missing sessionId or event' });
  setActivity(sessionId, { event, timestamp: Date.now() });

  // Generate title and blurb on stop events (if stale)
  if (event === 'stop') {
    const filePath = findSessionFile(sessionId);
    if (filePath) {
      if (needsTitle(sessionId, filePath)) generateTitle(sessionId).catch(() => {});
      if (blurbCache.needsRefresh(sessionId, filePath)) generateBlurb(sessionId).catch(() => {});
    }
  }

  res.json({ ok: true });
});

// Determine session status. Uses hook-reported activity when available,
// falls back to file-tail heuristics for sessions without hook data.
// Read tail lines from a .jsonl file (shared helper)
function readTailLines(filePath) {
  try {
    const fd = fs.openSync(filePath, 'r');
    const stat = fs.fstatSync(fd);
    const size = stat.size;
    const readSize = Math.min(8192, size);
    const buf = Buffer.alloc(readSize);
    fs.readSync(fd, buf, 0, readSize, size - readSize);
    fs.closeSync(fd);
    return buf.toString('utf-8').split('\n').filter(l => l.trim());
  } catch {}
  return [];
}

// Read the last message (any type) from the tail of a .jsonl file
function readLastMessage(filePath) {
  const lines = readTailLines(filePath);
  for (let i = lines.length - 1; i >= 0; i--) {
    try {
      const obj = JSON.parse(lines[i]);
      if (obj.type === 'assistant' || obj.type === 'user') return obj;
    } catch { /* partial line */ }
  }
  return null;
}

// Read the last assistant-only message from the tail of a .jsonl file
function readLastAssistantMessage(filePath) {
  const lines = readTailLines(filePath);
  for (let i = lines.length - 1; i >= 0; i--) {
    try {
      const obj = JSON.parse(lines[i]);
      if (obj.type === 'assistant') return obj;
    } catch { /* partial line */ }
  }
  return null;
}

// Check if the last assistant message is waiting for user input:
// - Contains AskUserQuestion or ExitPlanMode tool use
// - Last text block ends with a question mark
function isWaitingForInput(lastMsg) {
  if (!lastMsg || lastMsg.type !== 'assistant') return false;
  const content = (lastMsg.message || {}).content;
  if (!Array.isArray(content)) return false;

  let lastText = '';
  for (const c of content) {
    if (!c || typeof c !== 'object') continue;
    if (c.type === 'tool_use') {
      const name = (c.name || '').toLowerCase();
      if (name === 'askuserquestion' || name === 'exitplanmode') return true;
    }
    if (c.type === 'text' && c.text) {
      lastText = c.text;
    }
  }

  return lastText.trimEnd().endsWith('?');
}

function detectSessionStatus(sessionId, filePath, mtimeMs) {
  const now = Date.now();

  // Check hook-reported activity first
  const activity = getActivity(sessionId);
  if (activity) {
    const ageMs = now - activity.timestamp;

    if (activity.event === 'working' || activity.event === 'prompt') {
      if (ageMs < 60000) return 'working';
      return 'idle';
    }
    if (activity.event === 'stop') {
      if (ageMs < 3600000) {
        const lastMsg = readLastAssistantMessage(filePath);
        return isWaitingForInput(lastMsg) ? 'waiting' : 'idle';
      }
      return 'idle';
    }
    if (activity.event === 'idle') {
      // Don't downgrade to idle if the session is waiting for user input
      const lastMsg = readLastAssistantMessage(filePath);
      if (isWaitingForInput(lastMsg)) return 'waiting';
      return 'idle';
    }
  }

  // Fallback: file-based heuristic for sessions without hook data
  const fileAge = now - mtimeMs;

  if (fileAge < 30000) {
    const lastMsg = readLastMessage(filePath);
    if (!lastMsg) return 'idle';
    if (lastMsg.type === 'assistant') {
      const stopReason = (lastMsg.message || {}).stop_reason || null;
      if (stopReason === null || stopReason === 'tool_use') return 'working';
    }
    if (lastMsg.type === 'user') {
      const content = lastMsg.message && lastMsg.message.content;
      if (Array.isArray(content)) {
        for (const c of content) {
          if (c && c.type === 'tool_result') return 'working';
        }
      }
      return 'working';
    }
  }

  if (fileAge < 3600000) {
    const lastAssistant = readLastAssistantMessage(filePath);
    return isWaitingForInput(lastAssistant) ? 'waiting' : 'idle';
  }
  return 'idle';
}

// Resolve a project dirName (e.g. "-Users-DavidCampey-clode-claude-kanban")
// back to a real filesystem path. Hyphens are ambiguous (path separator vs literal),
// so we walk the filesystem to find the matching directory.
const projectPathCache = new Map();
function resolveProjectPath(dirName) {
  if (projectPathCache.has(dirName)) return projectPathCache.get(dirName);

  const parts = dirName.replace(/^-/, '').split('-');

  function walk(idx, currentPath) {
    if (idx >= parts.length) {
      try {
        if (fs.statSync(currentPath).isDirectory()) return currentPath;
      } catch {}
      return null;
    }
    // Try consuming progressively more parts as a single segment (with hyphens)
    for (let end = parts.length; end > idx; end--) {
      const segment = parts.slice(idx, end).join('-');
      const candidate = path.join(currentPath, segment);
      const result = walk(end, candidate);
      if (result) return result;
    }
    return null;
  }

  const resolved = walk(0, '/') || '/' + parts.join('/');
  projectPathCache.set(dirName, resolved);
  return resolved;
}

// Normalize a git remote URL to canonical HTTPS form
function normalizeGitUrl(url) {
  url = url.trim();
  const sshMatch = url.match(/^git@([^:]+):(.+)$/);
  if (sshMatch) url = `https://${sshMatch[1]}/${sshMatch[2]}`;
  return url.replace(/\.git$/, '');
}

// Parse [remote "name"] sections from git config text
function parseGitRemotes(text) {
  const remotes = {};
  let current = null;
  for (const line of text.split('\n')) {
    const secMatch = line.match(/^\[remote\s+"([^"]+)"\]/);
    if (secMatch) { current = secMatch[1]; remotes[current] = {}; continue; }
    if (current && line.match(/^\[/)) current = null;
    if (current) {
      const kv = line.match(/^\s*(\w+)\s*=\s*(.+)$/);
      if (kv) remotes[current][kv[1]] = kv[2].trim();
    }
  }
  return remotes;
}

// Cache git repo info — remotes don't change mid-session
const repoInfoCache = new Map();

function getRepoInfo(projectPath) {
  if (repoInfoCache.has(projectPath)) return repoInfoCache.get(projectPath);
  const empty = { repoUrl: '', branch: '' };
  try {
    let gitDir = path.join(projectPath, '.git');
    let gitStat;
    try { gitStat = fs.statSync(gitDir); } catch { repoInfoCache.set(projectPath, empty); return empty; }

    // Worktree support: .git may be a file pointing to the real gitdir
    if (!gitStat.isDirectory()) {
      const content = fs.readFileSync(gitDir, 'utf-8').trim();
      const m = content.match(/^gitdir:\s*(.+)$/);
      if (!m) { repoInfoCache.set(projectPath, empty); return empty; }
      gitDir = path.resolve(projectPath, m[1]);
    }

    let branch = '';
    try {
      const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf-8').trim();
      const m = head.match(/^ref:\s*refs\/heads\/(.+)$/);
      if (m) branch = m[1];
    } catch {}

    let repoUrl = '';
    try {
      const configText = fs.readFileSync(path.join(gitDir, 'config'), 'utf-8');
      const remotes = parseGitRemotes(configText);
      const remote = remotes['origin'] || remotes[Object.keys(remotes)[0]];
      if (remote && remote.url) repoUrl = normalizeGitUrl(remote.url);
    } catch {}

    const result = { repoUrl, branch };
    repoInfoCache.set(projectPath, result);
    return result;
  } catch {
    repoInfoCache.set(projectPath, empty);
    return empty;
  }
}

// Per-project radar.json config cache
const radarConfigCache = new Map();

function readRadarConfig(projectPath) {
  const configPath = path.join(projectPath, '.claude', 'radar.json');
  try {
    const mtime = fs.statSync(configPath).mtimeMs;
    const cached = radarConfigCache.get(projectPath);
    if (cached && cached.mtime === mtime) return cached.config;
    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
    radarConfigCache.set(projectPath, { mtime, config });
    return config;
  } catch {
    return null;
  }
}

// System artifacts injected by Claude Code that aren't real user prompts
const ARTIFACT_PREFIXES = [
  '[Request interrupted',
  '<local-command-',
  '<command-name>',
  '<command-message>',
  '<ide_opened_file>',
];

function isArtifact(text) {
  const t = text.trimStart();
  return !t || ARTIFACT_PREFIXES.some(p => t.startsWith(p));
}

// Clean a title string: strip plan boilerplate, collapse whitespace, trim length
function cleanTitle(text) {
  let t = text.replace(/^Implement the following plan:\s*/i, '');
  t = t.replace(/^#\s*Plan:\s*/i, '');
  t = t.replace(/<[^>]+>/g, ''); // strip XML-like tags
  // Cut at markdown headers or section breaks
  t = t.split(/\s*##\s/)[0];
  t = t.split(/\s*\n\s*\n/)[0];
  // Strip leading markdown header markers (e.g. "# Title" → "Title")
  t = t.replace(/^#+\s*/, '');
  t = t.replace(/\s+/g, ' ').trim();
  // Skip system-injected boilerplate
  if (t.startsWith('Base directory for this skill:')) t = '';
  if (t.startsWith('This session is being continued')) t = '';
  return t.slice(0, 80) || '';
}

// Read first user prompt, parent session ID, and estimated message count from a
// .jsonl file.  Only reads the first ~32KB — enough for prompt/parent detection.
// Message count is estimated from file size (avg ~1.5KB per message turn) to avoid
// scanning potentially huge (100MB+) files.
// Uses cache to avoid re-reading unchanged files.
function parseSessionFile(filePath) {
  let stat;
  try {
    stat = fs.statSync(filePath);
  } catch {
    return null;
  }

  const mtimeMs = stat.mtimeMs;
  const cached = fileCache.get(filePath);
  if (cached && cached.mtime === mtimeMs) return cached.data;

  let firstPrompt = '';
  let parentSessionId = '';
  let messageCount = 0;

  const sessionId = path.basename(filePath, '.jsonl');

  let summary = '';

  try {
    const fd = fs.openSync(filePath, 'r');
    const fileSize = fs.fstatSync(fd).size;
    const headSize = Math.min(32768, fileSize);
    const headBuf = Buffer.alloc(headSize);
    fs.readSync(fd, headBuf, 0, headSize, 0);

    // Also read tail for blurb extraction
    const tailSize = Math.min(16384, fileSize);
    const tailBuf = Buffer.alloc(tailSize);
    fs.readSync(fd, tailBuf, 0, tailSize, fileSize - tailSize);
    fs.closeSync(fd);

    const head = headBuf.toString('utf-8');
    const headLines = head.split('\n');

    let hasMessages = false;
    for (const line of headLines) {
      if (!line.trim()) continue;
      let obj;
      try { obj = JSON.parse(line); } catch { continue; }
      if (obj.type === 'user' || obj.type === 'assistant') hasMessages = true;
      if (obj.type === 'user') {
        if (!parentSessionId && obj.sessionId && obj.sessionId !== sessionId) {
          parentSessionId = obj.sessionId;
        }
        if (!firstPrompt) {
          const msg = obj.message;
          if (msg && typeof msg === 'object') {
            const ct = msg.content;
            if (Array.isArray(ct)) {
              for (const c of ct) {
                if (c && c.type === 'text' && c.text && !isArtifact(c.text)) {
                  firstPrompt = c.text.slice(0, 200);
                  break;
                }
              }
            } else if (typeof ct === 'string' && !isArtifact(ct)) {
              firstPrompt = ct.slice(0, 200);
            }
          }
        }
      }
      if (firstPrompt && parentSessionId) break;
    }

    // Extract summary from the tail
    const tailLines = tailBuf.toString('utf-8').split('\n').filter(l => l.trim());
    for (let i = tailLines.length - 1; i >= 0; i--) {
      try {
        const obj = JSON.parse(tailLines[i]);
        if (obj.type === 'summary' && obj.summary) {
          summary = obj.summary;
          break;
        }
      } catch { /* partial line */ }
    }

    // Estimate message count from file size (~1.5KB per message turn on average)
    // Mark as 0 if the head contained no user/assistant messages (empty session)
    messageCount = hasMessages ? Math.max(1, Math.round(fileSize / 1500)) : 0;
  } catch {
    // Unreadable file
  }

  const data = { firstPrompt, messageCount, parentSessionId, summary };
  fileCache.set(filePath, { mtime: mtimeMs, data });
  return data;
}

app.get('/api/sessions', (req, res) => {
  const projects = [];

  let dirEntries;
  try {
    dirEntries = fs.readdirSync(PROJECTS_DIR, { withFileTypes: true });
  } catch {
    return res.json({ projects: [] });
  }

  for (const dirent of dirEntries) {
    if (!dirent.isDirectory()) continue;

    const projectDir = path.join(PROJECTS_DIR, dirent.name);

    // Read the index if it exists
    let indexData = { entries: [] };
    try {
      const raw = fs.readFileSync(path.join(projectDir, 'sessions-index.json'), 'utf-8');
      indexData = JSON.parse(raw);
    } catch {
      // No index — we'll still scan for .jsonl files
    }

    // Build a map of indexed sessions by ID
    const indexedById = new Map();
    for (const entry of (indexData.entries || [])) {
      indexedById.set(entry.sessionId, entry);
    }

    // Scan for all .jsonl session files in this project directory
    let files;
    try {
      files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
    } catch {
      continue;
    }

    if (files.length === 0 && indexedById.size === 0) continue;

    const rawSessions = [];
    let projectPath = '';
    let mostRecent = 0;

    for (const file of files) {
      const sessionId = path.basename(file, '.jsonl');
      const filePath = path.join(projectDir, file);

      // Get actual file timestamps
      let stat;
      try {
        stat = fs.statSync(filePath);
      } catch {
        continue;
      }

      const lastActivity = stat.mtimeMs;
      const fileCreated = stat.birthtimeMs || stat.ctimeMs;

      // Always parse the file for parentSessionId and message count
      const parsed = parseSessionFile(filePath);
      const parentSessionId = parsed ? parsed.parentSessionId : '';

      const indexed = indexedById.get(sessionId);

      let title, firstPrompt, messageCount, gitBranch, created, isSidechain, status;
      const blurbEntry = blurbCache.get(sessionId);
      const blurb = blurbEntry ? blurbEntry.value : '';
      const parsedSummary = parsed ? parsed.summary : '';

      const titleEntry = titleCache.get(sessionId);
      const cachedTitle = titleEntry ? titleEntry.value : '';

      if (indexed) {
        title = indexed.summary || cachedTitle || parsedSummary || '';
        firstPrompt = indexed.firstPrompt || '';
        messageCount = indexed.messageCount || (parsed ? parsed.messageCount : 0);
        gitBranch = indexed.gitBranch || '';
        created = indexed.created;
        isSidechain = indexed.isSidechain || false;
        status = detectSessionStatus(sessionId, filePath, lastActivity);
        if (!projectPath) projectPath = indexed.projectPath || '';
      } else {
        firstPrompt = parsed ? parsed.firstPrompt : '';
        messageCount = parsed ? parsed.messageCount : 0;
        status = detectSessionStatus(sessionId, filePath, lastActivity);
        title = cachedTitle || parsedSummary || '';
        gitBranch = '';
        created = new Date(fileCreated).toISOString();
        isSidechain = false;
      }

      // Skip empty sessions (e.g. started and immediately abandoned)
      if (messageCount === 0 && !firstPrompt) continue;

      if (lastActivity > mostRecent) mostRecent = lastActivity;

      rawSessions.push({
        sessionId,
        dirName: dirent.name,
        username: currentUsername,
        avatarUrl,
        parentSessionId,
        title: cleanTitle(title || firstPrompt) || '(no title)',
        blurb: blurb || '',
        firstPrompt: firstPrompt || '',
        messageCount,
        gitBranch,
        status,
        created: created || new Date(fileCreated).toISOString(),
        modified: new Date(lastActivity).toISOString(),
        isSidechain,
      });
    }

    // Merge continuation chains: collapse parent→child sequences into one entry.
    // The latest session in each chain inherits the root's created time and
    // accumulates message counts. Previous sessions are kept in an array.
    const byId = new Map();
    for (const s of rawSessions) byId.set(s.sessionId, s);

    // Find which sessions are parents (have a child pointing to them)
    const isParent = new Set();
    for (const s of rawSessions) {
      if (s.parentSessionId && byId.has(s.parentSessionId)) {
        isParent.add(s.parentSessionId);
      }
    }

    const sessions = [];
    for (const s of rawSessions) {
      if (isParent.has(s.sessionId)) continue; // skip — will be folded into child

      // Walk back through parent chain
      const chain = [];
      let cur = s;
      while (cur.parentSessionId && byId.has(cur.parentSessionId)) {
        const parent = byId.get(cur.parentSessionId);
        chain.unshift(parent);
        cur = parent;
      }

      if (chain.length > 0) {
        // Use root session's created time
        s.created = chain[0].created;
        // Aggregate message counts
        s.messageCount = chain.reduce((sum, p) => sum + p.messageCount, 0) + s.messageCount;
        // Use root's title/firstPrompt if current one is generic
        if (chain[0].firstPrompt && (!s.firstPrompt || s.title === '(no title)')) {
          s.firstPrompt = chain[0].firstPrompt;
          s.title = chain[0].title;
        }
        // Attach previous sessions for the UI
        s.previousSessions = chain.map(p => ({
          sessionId: p.sessionId,
          created: p.created,
          modified: p.modified,
          messageCount: p.messageCount,
          title: p.title,
        }));
      }

      delete s.parentSessionId;
      sessions.push(s);
    }

    if (sessions.length === 0) continue;

    // Derive projectPath from dirName if not set from sessions-index.json
    if (!projectPath) {
      projectPath = resolveProjectPath(dirent.name);
    }

    let { repoUrl, branch } = getRepoInfo(projectPath);
    // If no git in this dir, check parent wip/worktrees.json (for topic-level worktree dirs)
    if (!branch) {
      try {
        const wipJson = path.join(projectPath, '..', 'worktrees.json');
        const wipData = JSON.parse(fs.readFileSync(wipJson, 'utf-8'));
        const topicId = path.basename(projectPath);
        const entry = wipData.worktrees?.find(w => w.id === topicId);
        if (entry?.branch) branch = entry.branch;
      } catch {}
    }
    const radarConfig = readRadarConfig(projectPath);
    const folderName = path.basename(projectPath);
    const repoBasename = repoUrl ? repoUrl.split('/').pop() : '';
    const projectName = radarConfig?.swimlane?.name || repoBasename || folderName;
    const slug = radarConfig?.swimlane?.slug || makeSlug(projectName, branch);
    const swimlaneKey = repoUrl ? `${repoUrl}#${branch}` : dirent.name;
    const swimlaneUrl = radarConfig?.swimlane?.url
      || (repoUrl && branch ? `${repoUrl}/tree/${branch}` : repoUrl || '');

    let swimlaneTitle;
    if (radarConfig?.swimlane?.title) {
      swimlaneTitle = radarConfig.swimlane.title.replace(/\{branch\}/g, branch || '').replace(/\/(\s|$)/g, '$1').trim();
    } else if (swimlaneUrl) {
      const label = projectName + (branch ? '/' + branch : '');
      swimlaneTitle = '[' + label + '](' + swimlaneUrl + ')';
    } else {
      swimlaneTitle = projectPath;
    }

    const valkeyPush = (radarConfig?.push || [])
      .filter(p => p?.valkey?.url)
      .map(p => ({
        url: p.valkey.url,
        swimlane: p.swimlane || 'default',
        connected: isValkeyReady(p.valkey.url, p.valkey.password || ''),
      }));
    const valkeyConfigured = valkeyPush.length > 0;
    const valkeyConnected = valkeyPush.some(p => p.connected);

    projects.push({
      dirName: dirent.name,
      swimlaneKey,
      slug,
      projectName,
      projectPath,
      repoUrl,
      branch,
      swimlaneUrl,
      swimlaneTitle,
      valkeyPush,
      valkeyConfigured,
      valkeyConnected,
      mostRecent: new Date(mostRecent).toISOString(),
      sessions,
    });
  }

  // Merge projects that share the same swimlaneKey (same repo + branch)
  const mergedMap = new Map();
  for (const p of projects) {
    if (mergedMap.has(p.swimlaneKey)) {
      const existing = mergedMap.get(p.swimlaneKey);
      existing.sessions.push(...p.sessions);
      existing.projectPaths.push(p.projectPath);
      if (p.mostRecent > existing.mostRecent) existing.mostRecent = p.mostRecent;
      // Union push targets, deduplicate by url+swimlane
      for (const t of p.valkeyPush) {
        if (!existing.valkeyPush.some(e => e.url === t.url && e.swimlane === t.swimlane)) {
          existing.valkeyPush.push(t);
        }
      }
      existing.valkeyConfigured = existing.valkeyPush.length > 0;
      existing.valkeyConnected = existing.valkeyPush.some(t => t.connected);
    } else {
      mergedMap.set(p.swimlaneKey, { ...p, projectPaths: [p.projectPath], sessions: [...p.sessions] });
    }
  }
  const mergedProjects = [...mergedMap.values()];

  // Merge remote sessions from subscription cache
  const remoteBySlug = new Map();
  for (const sessions of remoteSessionsCache.values()) {
    for (const s of sessions) {
      const slug = s.slug || 'remote';
      if (!remoteBySlug.has(slug)) remoteBySlug.set(slug, []);
      remoteBySlug.get(slug).push(s);
    }
  }
  const nowMs = Date.now();
  for (const [slug, remoteSessions] of remoteBySlug) {
    for (const s of remoteSessions) {
      if (s.status === 'working' && nowMs - s.pushedAt > 60000) s.status = 'idle';
      if (s.status === 'waiting' && nowMs - s.pushedAt > 3600000) s.status = 'idle';
    }
    const local = mergedProjects.find(p => p.slug === slug);
    if (local) {
      const existingIds = new Set(local.sessions.map(s => s.sessionId));
      for (const s of remoteSessions) {
        if (!existingIds.has(s.sessionId)) {
          local.sessions.push(s);
          if (s.modified > local.mostRecent) local.mostRecent = s.modified;
        }
      }
    } else {
      const first = remoteSessions[0];
      mergedProjects.push({
        dirName: `remote:${slug}`, swimlaneKey: `remote:${slug}`, slug,
        projectName: first?.projectName || slug,
        projectPath: '', projectPaths: [], repoUrl: first?.repoUrl || '',
        branch: first?.branch || '', swimlaneUrl: '', swimlaneTitle: first?.swimlaneTitle || slug,
        valkeyPush: [], valkeyConfigured: false, valkeyConnected: false,
        mostRecent: remoteSessions.reduce((m, s) => s.modified > m ? s.modified : m, remoteSessions[0]?.modified || ''),
        sessions: remoteSessions, isRemote: true,
      });
    }
  }

  maybePushSessionsToValkey(mergedProjects);

  const now = new Date();
  const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
  const startOfWeek = new Date(startOfToday);
  startOfWeek.setDate(startOfWeek.getDate() - startOfWeek.getDay());

  function swimlaneBucket(p) {
    const t = new Date(p.mostRecent);
    if (t >= startOfToday) return 0;
    if (t >= startOfWeek) return 1;
    // Older: bucket by weeks ago (2 = most recent older week, higher = further back)
    const msPerWeek = 7 * 24 * 60 * 60 * 1000;
    return 2 + Math.floor((startOfWeek - t) / msPerWeek);
  }

  mergedProjects.sort((a, b) => {
    const bucketDiff = swimlaneBucket(a) - swimlaneBucket(b);
    if (bucketDiff !== 0) return bucketDiff;
    const aPath = a.swimlaneTitle.startsWith('/');
    const bPath = b.swimlaneTitle.startsWith('/');
    if (aPath !== bPath) return aPath ? 1 : -1;
    return a.projectName.localeCompare(b.projectName);
  });

  // Rebuild swimlaneProjectPaths for the config endpoint
  swimlaneProjectPaths.clear();
  for (const p of mergedProjects) swimlaneProjectPaths.set(p.swimlaneKey, p.projectPaths);

  const totalProjects = mergedProjects.length;
  const totalSessions = mergedProjects.reduce((sum, p) => sum + p.sessions.length, 0);

  res.json({ currentUsername, totalProjects, totalSessions, projects: mergedProjects });
});

// Return parsed conversation for a single session
app.get('/api/session/:dirName/:sessionId', (req, res) => {
  const { dirName, sessionId } = req.params;
  const filePath = path.join(PROJECTS_DIR, dirName, sessionId + '.jsonl');

  let raw;
  try {
    raw = fs.readFileSync(filePath, 'utf-8');
  } catch {
    return res.status(404).json({ error: 'Session not found' });
  }

  const messages = [];
  const lines = raw.split('\n');
  for (const line of lines) {
    if (!line.trim()) continue;
    let obj;
    try { obj = JSON.parse(line); } catch { continue; }

    const type = obj.type;
    if (type !== 'user' && type !== 'assistant') continue;

    const msg = obj.message;
    if (!msg) continue;

    const role = msg.role || type;
    const content = msg.content;
    const parts = [];

    if (typeof content === 'string') {
      if (content) parts.push({ type: 'text', text: content });
    } else if (Array.isArray(content)) {
      for (const c of content) {
        if (!c || typeof c !== 'object') continue;
        if (c.type === 'text' && c.text) {
          parts.push({ type: 'text', text: c.text });
        } else if (c.type === 'tool_use') {
          parts.push({ type: 'tool_use', name: c.name || '', id: c.id || '', input: c.input || {} });
        } else if (c.type === 'tool_result') {
          // Extract text from tool results
          let resultText = '';
          if (typeof c.content === 'string') {
            resultText = c.content;
          } else if (Array.isArray(c.content)) {
            for (const r of c.content) {
              if (r && r.type === 'text' && r.text) resultText += r.text + '\n';
            }
          }
          if (resultText) {
            parts.push({ type: 'tool_result', name: c.tool_use_id || '', text: resultText.slice(0, 2000) });
          }
        }
        // Skip thinking blocks
      }
    }

    if (parts.length > 0) {
      messages.push({ role, parts });
    }
  }

  res.json({ messages });
});

// Return recent messages from the tail of a session (lightweight)
app.get('/api/session/:dirName/:sessionId/recent', (req, res) => {
  const { dirName, sessionId } = req.params;
  const filePath = path.join(PROJECTS_DIR, dirName, sessionId + '.jsonl');

  let stat;
  try { stat = fs.statSync(filePath); } catch {
    return res.status(404).json({ error: 'Session not found' });
  }

  try {
    const fd = fs.openSync(filePath, 'r');
    const tailSize = Math.min(32768, stat.size);
    const buf = Buffer.alloc(tailSize);
    fs.readSync(fd, buf, 0, tailSize, stat.size - tailSize);
    fs.closeSync(fd);

    const lines = buf.toString('utf-8').split('\n').filter(l => l.trim());
    const messages = [];

    for (const line of lines) {
      let obj;
      try { obj = JSON.parse(line); } catch { continue; }
      if (obj.type !== 'user' && obj.type !== 'assistant') continue;
      const msg = obj.message;
      if (!msg) continue;

      const role = msg.role || obj.type;
      const content = msg.content;
      const parts = [];

      if (typeof content === 'string') {
        if (content.trim()) parts.push({ type: 'text', text: content.slice(0, 1000) });
      } else if (Array.isArray(content)) {
        for (const c of content) {
          if (!c || typeof c !== 'object') continue;
          if (c.type === 'text' && c.text && !isArtifact(c.text)) {
            parts.push({ type: 'text', text: c.text.slice(0, 1000) });
          } else if (c.type === 'tool_use') {
            parts.push({ type: 'tool_use', name: c.name || '' });
          }
        }
      }

      if (parts.length > 0) messages.push({ role, parts });
    }

    // Return last 10 messages
    res.json({ messages: messages.slice(-10) });
  } catch {
    res.status(500).json({ error: 'Failed to read session' });
  }
});

// Update per-swimlane radar.json config (name, slug, and/or push targets array)
app.post('/api/swimlane-config', async (req, res) => {
  const { swimlaneKey, name, slug, push } = req.body || {};
  if (!swimlaneKey) return res.status(400).json({ error: 'missing swimlaneKey' });

  const projectPaths = swimlaneProjectPaths.get(swimlaneKey);
  if (!projectPaths || projectPaths.length === 0) return res.status(404).json({ error: 'swimlane not found' });

  for (const projectPath of projectPaths) {
    const configPath = path.join(projectPath, '.claude', 'radar.json');
    let config = {};
    try { config = JSON.parse(fs.readFileSync(configPath, 'utf-8')); } catch {}
    if (!config.swimlane) config.swimlane = {};

    if (name !== undefined) config.swimlane.name = name;
    if (slug !== undefined) {
      if (slug) config.swimlane.slug = slug;
      else delete config.swimlane.slug;
    }
    if (push !== undefined) {
      // Replace push array entirely (null or empty = clear all targets)
      if (!push || push.length === 0) {
        delete config.push;
      } else {
        config.push = push
          .filter(p => p?.url)
          .map(p => ({
            valkey: { url: p.url, ...(p.password ? { password: p.password } : {}) },
            swimlane: p.swimlane || 'default',
          }));
      }
    }

    try {
      fs.mkdirSync(path.join(projectPath, '.claude'), { recursive: true });
      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
      radarConfigCache.delete(projectPath);
    } catch (err) {
      return res.status(500).json({ error: `Failed to write ${configPath}: ${err.message}` });
    }
  }

  // Test each new push target and return status
  const valkeyPush = [];
  for (const p of (push || [])) {
    if (!p?.url) continue;
    let connected = false;
    try {
      const client = getValkeyClient(p.url, p.password || '');
      await Promise.race([
        new Promise(r => client.status === 'ready' ? r() : client.once('ready', r)),
        new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 5000)),
      ]);
      connected = true;
    } catch {}
    valkeyPush.push({ url: p.url, swimlane: p.swimlane || 'default', connected });
  }

  res.json({ ok: true, valkeyPush });
});

// Focus a terminal window matching project + session title
app.post('/api/focus-terminal', (req, res) => {
  const { projectName, title } = req.body || {};
  if (!projectName || !title) return res.status(400).json({ error: 'missing projectName or title' });

  const titleSnippet = title.slice(0, 40).replace(/[\\"`]/g, '');
  const projName = projectName.replace(/[\\"`]/g, '');

  // AppleScript: search windows in Terminal.app, then iTerm2
  const script = `
    on findWindow(appName, proj, snippet)
      try
        tell application "System Events"
          if not (exists process appName) then return false
        end tell
        tell application appName
          repeat with w in windows
            set t to name of w
            if t contains proj and t contains snippet then
              set index of w to 1
              activate
              return true
            end if
          end repeat
        end tell
      end try
      return false
    end findWindow

    if findWindow("Terminal", "${projName}", "${titleSnippet}") then return "found"
    if findWindow("iTerm2", "${projName}", "${titleSnippet}") then return "found"
    return "not_found"
  `;

  execFile('osascript', ['-e', script], { timeout: 5000 }, (err, stdout) => {
    const found = (stdout || '').trim() === 'found';
    res.json({ found });
  });
});

// SPA fallback: serve index.html for non-API routes
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// On startup, refresh titles and blurbs for sessions that need them.
// Processes sequentially with a small delay to avoid hammering Bedrock.
async function refreshCaches() {
  let dirEntries;
  try {
    dirEntries = fs.readdirSync(PROJECTS_DIR, { withFileTypes: true });
  } catch { return; }

  const titleQueue = [];
  const blurbQueue = [];

  for (const dirent of dirEntries) {
    if (!dirent.isDirectory()) continue;
    const projectDir = path.join(PROJECTS_DIR, dirent.name);

    // Check for indexed summaries (title not needed for these)
    let indexedSummaries = new Map();
    try {
      const raw = fs.readFileSync(path.join(projectDir, 'sessions-index.json'), 'utf-8');
      const indexData = JSON.parse(raw);
      for (const entry of (indexData.entries || [])) {
        if (entry.summary) indexedSummaries.set(entry.sessionId, true);
      }
    } catch {}

    let files;
    try {
      files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
    } catch { continue; }

    for (const file of files) {
      const sessionId = path.basename(file, '.jsonl');
      const filePath = path.join(projectDir, file);

      const parsed = parseSessionFile(filePath);
      if (!parsed || parsed.messageCount === 0) continue; // empty session

      const needsTitleRefresh = !indexedSummaries.has(sessionId)
        && !(parsed && parsed.summary)
        && needsTitle(sessionId, filePath);
      if (needsTitleRefresh) titleQueue.push(sessionId);

      if (blurbCache.needsRefresh(sessionId, filePath)) blurbQueue.push(sessionId);
    }
  }

  if (titleQueue.length > 0) {
    console.log(`Generating titles for ${titleQueue.length} sessions...`);
    for (const sessionId of titleQueue) {
      try { await generateTitle(sessionId); } catch {}
      await new Promise(r => setTimeout(r, 200));
    }
    console.log(`Title generation complete.`);
  }

  if (blurbQueue.length > 0) {
    console.log(`Generating blurbs for ${blurbQueue.length} sessions...`);
    for (const sessionId of blurbQueue) {
      try { await generateBlurb(sessionId); } catch {}
      await new Promise(r => setTimeout(r, 200));
    }
    console.log(`Blurb generation complete.`);
  }

  // Background compaction pass: build/extend compactions for large sessions.
  // Runs after titles and blurbs so it doesn't delay the visible results.
  const compactQueue = [];
  for (const dirent of dirEntries) {
    if (!dirent.isDirectory()) continue;
    const projectDir = path.join(PROJECTS_DIR, dirent.name);
    let files;
    try { files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl')); } catch { continue; }
    for (const file of files) {
      const sessionId = path.basename(file, '.jsonl');
      const filePath = path.join(projectDir, file);
      try {
        const size = fs.statSync(filePath).size;
        if (size <= CHUNK) continue;
        const dirName = dirent.name;
        const tailStart = size - CHUNK;
        const existing = readCompaction(dirName, sessionId);
        if (!existing || existing.coveredUpToBytes < tailStart) compactQueue.push({ sessionId, filePath });
      } catch {}
    }
  }

  if (compactQueue.length > 0) {
    console.log(`Building compactions for ${compactQueue.length} sessions...`);
    for (const { sessionId, filePath } of compactQueue) {
      try { await buildSessionCompaction(sessionId, filePath); } catch {}
      await new Promise(r => setTimeout(r, 200));
    }
    console.log(`Compaction complete.`);
  }
}

// At startup: scan all projects, connect any configured Valkeys, load their caches.
// Migrate old numbered compaction files ({sessionId}-{N}.json) to the new single-file
// format ({sessionId}.json). Picks the highest-numbered file per session as the
// best available summary, writes the new format, then deletes the old files.
function migrateCompactions() {
  try {
    for (const dirEntry of fs.readdirSync(COMPACT_BASE, { withFileTypes: true })) {
      if (!dirEntry.isDirectory()) continue;
      const dirPath = path.join(COMPACT_BASE, dirEntry.name);
      const bySession = new Map(); // sessionId → [{ index, file }]
      for (const f of fs.readdirSync(dirPath)) {
        const m = f.match(/^(.+)-(\d+)\.json$/);
        if (!m) continue;
        const [, sid, idx] = m;
        if (!bySession.has(sid)) bySession.set(sid, []);
        bySession.get(sid).push({ index: parseInt(idx), file: path.join(dirPath, f) });
      }
      for (const [sid, entries] of bySession) {
        entries.sort((a, b) => b.index - a.index); // highest first
        try {
          const best = JSON.parse(fs.readFileSync(entries[0].file, 'utf-8'));
          const newPath = path.join(dirPath, `${sid}.json`);
          if (!fs.existsSync(newPath)) {
            fs.writeFileSync(newPath, JSON.stringify({
              summary: best.summary,
              coveredUpToBytes: best.chunkIndex * CHUNK,
              generatedAt: best.generatedAt || Date.now(),
            }), 'utf-8');
          }
        } catch {}
        // Delete all old numbered files
        for (const e of entries) { try { fs.unlinkSync(e.file); } catch {} }
      }
    }
  } catch {}
}

async function initPerProjectValkeys() {
  let dirs;
  try { dirs = fs.readdirSync(PROJECTS_DIR, { withFileTypes: true }).filter(d => d.isDirectory()); }
  catch { return; }

  const seen = new Set(); // dedupe by url:password:swimlane so we only load each once
  for (const dirent of dirs) {
    try {
      const raw = fs.readFileSync(path.join(PROJECTS_DIR, dirent.name, 'sessions-index.json'), 'utf-8');
      const projectPath = JSON.parse(raw).entries?.[0]?.projectPath;
      if (!projectPath) continue;
      const pushList = readRadarConfig(projectPath)?.push || [];
      for (const p of pushList) {
        if (!p?.valkey?.url) continue;
        const swimlane = p.swimlane || 'default';
        const dedupeKey = `${p.valkey.url}:${p.valkey.password || ''}:${swimlane}`;
        if (seen.has(dedupeKey)) continue;
        seen.add(dedupeKey);
        try {
          const client = getValkeyClient(p.valkey.url, p.valkey.password || '');
          await Promise.race([
            new Promise(r => client.status === 'ready' ? r() : client.once('ready', r)),
            new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 5000)),
          ]);
          const [titles, blurbs] = await Promise.all([
            client.hgetall(`radar:${swimlane}:titles`),
            client.hgetall(`radar:${swimlane}:blurbs`),
          ]);
          if (titles) for (const [id, json] of Object.entries(titles)) try { titleCache.loadEntry(id, JSON.parse(json)); } catch {}
          if (blurbs) for (const [id, json] of Object.entries(blurbs)) try { blurbCache.loadEntry(id, JSON.parse(json)); } catch {}
          const activityKeys = await client.keys(`radar:${swimlane}:activity:*`);
          if (activityKeys.length > 0) {
            const vals = await Promise.all(activityKeys.map(k => client.get(k)));
            for (let i = 0; i < activityKeys.length; i++) {
              if (vals[i]) try { activityMap.set(activityKeys[i].replace(`radar:${swimlane}:activity:`, ''), JSON.parse(vals[i])); } catch {}
            }
          }
          console.log(`Valkey caches loaded from ${p.valkey.url} (${swimlane})`);
        } catch (err) {
          if (err.message !== 'timeout') console.error(`initPerProjectValkeys ${p.valkey.url}: ${err.message}`);
        }
      }
    } catch (err) {
      if (err.code !== 'ENOENT') console.error(`initPerProjectValkeys(${dirent.name}): ${err.message}`);
    }
  }
}

app.listen(PORT, () => {
  console.log(`Claude Radar → http://localhost:${PORT}`);
  migrateCompactions();
  pullSubscriptions().catch(() => {});
  setInterval(() => pullSubscriptions().catch(() => {}), 30000);
  initPerProjectValkeys()
    .then(() => refreshCaches())
    .catch(err => console.error('startup failed:', err.message));
});