claude-session-skill 1.1.0

package/dist/session.js

@@ -0,0 +1,983 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// lib/search.ts
+var exports_search = {};
+__export(exports_search, {
+  searchSessions: () => searchSessions
+});
+function searchSessions(sessions, query) {
+  const now = Date.now();
+  const ONE_DAY = 86400000;
+  const ONE_WEEK = 7 * ONE_DAY;
+  const phrases = [];
+  const stripped = query.replace(/"([^"]+)"/g, (_, phrase) => {
+    phrases.push(phrase.toLowerCase());
+    return "";
+  });
+  const tokens = stripped.toLowerCase().split(/\s+/).filter((t) => t.length > 1);
+  if (tokens.length === 0 && phrases.length === 0)
+    return sessions;
+  const scored = [];
+  for (const session of sessions) {
+    let score = 0;
+    const nameLower = (session.name || "").toLowerCase();
+    const topicLower = (session.topic || session.firstMessage || "").toLowerCase();
+    const firstLower = session.firstMessage.toLowerCase();
+    const lastLower = session.lastMessage.toLowerCase();
+    const allLower = session.allMessages.toLowerCase();
+    const projectLower = session.project.toLowerCase();
+    const cwdLower = session.cwd.toLowerCase();
+    for (const token of tokens) {
+      if (nameLower.includes(token))
+        score += 15;
+      if (topicLower.includes(token))
+        score += 12;
+      if (firstLower.includes(token))
+        score += 10;
+      if (lastLower.includes(token))
+        score += 5;
+      if (allLower.includes(token))
+        score += 2;
+      if (projectLower.includes(token) || cwdLower.includes(token))
+        score += 3;
+    }
+    for (const phrase of phrases) {
+      if (nameLower.includes(phrase))
+        score += 30;
+      if (topicLower.includes(phrase))
+        score += 24;
+      if (firstLower.includes(phrase))
+        score += 20;
+      if (lastLower.includes(phrase))
+        score += 10;
+      if (allLower.includes(phrase))
+        score += 4;
+      if (projectLower.includes(phrase) || cwdLower.includes(phrase))
+        score += 6;
+    }
+    if (score === 0)
+      continue;
+    const age = now - session.lastTimestamp;
+    if (age < ONE_DAY) {
+      score *= 1.5;
+    } else if (age < ONE_WEEK) {
+      score *= 1.2;
+    }
+    scored.push({ session, score });
+  }
+  scored.sort((a, b) => b.score - a.score || b.session.lastTimestamp - a.session.lastTimestamp);
+  return scored.map((s) => s.session);
+}
+
+// lib/indexer.ts
+import { readdir, stat, mkdir, rename, unlink, readFile, writeFile, open } from "fs/promises";
+import { join, basename } from "path";
+var HOME = process.env.HOME;
+if (!HOME) {
+  throw new Error("HOME environment variable is not set");
+}
+var SUMMARY_MODEL = process.env.SESSION_SUMMARY_MODEL || "claude-haiku-4-5-20251001";
+var DEBUG = Boolean(process.env.SESSION_DEBUG);
+function debug(msg) {
+  if (DEBUG)
+    process.stderr.write(`[session] ${msg}
+`);
+}
+var CLAUDE_DIR = join(HOME, ".claude");
+var HISTORY_FILE = join(CLAUDE_DIR, "history.jsonl");
+var PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+var DATA_DIR = join(CLAUDE_DIR, "skills", "session", "data");
+var CACHE_FILE = join(DATA_DIR, "index.json");
+var SUMMARIES_FILE = join(DATA_DIR, "summaries.json");
+var NAMES_FILE = join(DATA_DIR, "names.json");
+var dataDirReady = false;
+async function ensureDataDir() {
+  if (dataDirReady)
+    return;
+  await mkdir(DATA_DIR, { recursive: true });
+  dataDirReady = true;
+}
+function shortProject(project) {
+  if (!project || project === HOME)
+    return "~";
+  const p = project.startsWith(HOME) ? project.slice(HOME.length + 1) : project;
+  return p || "~";
+}
+function decodeProjectDir(dirName) {
+  return "/" + dirName.replace(/^-/, "").replace(/-/g, "/");
+}
+function isTopical(msg) {
+  if (msg.length < 5)
+    return false;
+  if (msg.startsWith("/"))
+    return false;
+  if (msg.startsWith("<"))
+    return false;
+  if (msg.startsWith("[MEMORY]"))
+    return false;
+  return true;
+}
+function isGarbageSummary(s) {
+  if (!s)
+    return true;
+  const lower = s.toLowerCase();
+  return lower.startsWith("i don't have") || lower.startsWith("i don't see") || lower.startsWith("i'm afraid") || lower.startsWith("i cannot") || lower.startsWith("(80 chars max)") || lower.includes("don't have a transcript") || lower.includes("don't have access");
+}
+function resolveSession(sessions, id) {
+  const matches = sessions.filter((s) => s.id === id || s.id.startsWith(id));
+  if (matches.length === 0) {
+    return { ok: false, error: `No session found matching "${id}"` };
+  }
+  const exact = matches.find((s) => s.id === id);
+  if (exact)
+    return { ok: true, match: exact };
+  if (matches.length > 1) {
+    return { ok: false, error: `Ambiguous prefix "${id}" matches ${matches.length} sessions. Provide more characters.` };
+  }
+  return { ok: true, match: matches[0] };
+}
+async function getHistoryMtime() {
+  try {
+    return (await stat(HISTORY_FILE)).mtimeMs;
+  } catch (e) {
+    debug(`Cannot stat history file: ${e.message}`);
+    return 0;
+  }
+}
+async function getSessionFilesFingerprint() {
+  let count = 0;
+  let maxMtime = 0;
+  try {
+    const dirs = await readdir(PROJECTS_DIR);
+    for (const dir of dirs) {
+      try {
+        const dirPath = join(PROJECTS_DIR, dir);
+        const files = await readdir(dirPath);
+        for (const f of files) {
+          if (!f.endsWith(".jsonl"))
+            continue;
+          count++;
+          try {
+            const info = await stat(join(dirPath, f));
+            if (info.mtimeMs > maxMtime)
+              maxMtime = info.mtimeMs;
+          } catch (e) {
+            debug(`Cannot stat ${dir}/${f}: ${e.message}`);
+          }
+        }
+      } catch (e) {
+        debug(`Cannot read project dir ${dir}: ${e.message}`);
+      }
+    }
+  } catch (e) {
+    debug(`Cannot read projects dir: ${e.message}`);
+  }
+  return { count, maxMtime };
+}
+async function loadCache() {
+  try {
+    const raw = JSON.parse(await readFile(CACHE_FILE, "utf-8"));
+    if (!raw?.meta || !Array.isArray(raw?.sessions))
+      return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+async function atomicWrite(path, data) {
+  const tmp = path + ".tmp";
+  await writeFile(tmp, data);
+  await rename(tmp, path);
+}
+async function saveCache(data) {
+  await ensureDataDir();
+  await atomicWrite(CACHE_FILE, JSON.stringify(data));
+}
+async function loadSummaries() {
+  try {
+    return JSON.parse(await readFile(SUMMARIES_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function saveSummaries(summaries) {
+  await ensureDataDir();
+  await atomicWrite(SUMMARIES_FILE, JSON.stringify(summaries));
+}
+var _namesCache = null;
+var _namesMtime = 0;
+async function loadNames() {
+  try {
+    const currentMtime = (await stat(NAMES_FILE)).mtimeMs;
+    if (_namesCache && currentMtime === _namesMtime)
+      return { ..._namesCache };
+    const raw = JSON.parse(await readFile(NAMES_FILE, "utf-8"));
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+      return {};
+    const cleaned = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (typeof v === "string")
+        cleaned[k] = v;
+    }
+    _namesCache = cleaned;
+    _namesMtime = currentMtime;
+    return { ...cleaned };
+  } catch {
+    return {};
+  }
+}
+async function saveNames(names) {
+  await ensureDataDir();
+  await atomicWrite(NAMES_FILE, JSON.stringify(names));
+  _namesCache = null;
+  _namesMtime = 0;
+}
+var LOCK_FILE = NAMES_FILE + ".lock";
+var LOCK_TIMEOUT = 5000;
+async function acquireLock() {
+  const start = Date.now();
+  while (Date.now() - start < LOCK_TIMEOUT) {
+    try {
+      const fh = await open(LOCK_FILE, "wx");
+      await fh.write(String(process.pid));
+      await fh.close();
+      return true;
+    } catch {
+      try {
+        const lockStat = await stat(LOCK_FILE);
+        if (Date.now() - lockStat.mtimeMs > 1e4) {
+          await unlink(LOCK_FILE).catch(() => {});
+          continue;
+        }
+      } catch {}
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  return false;
+}
+async function releaseLock() {
+  await unlink(LOCK_FILE).catch(() => {});
+}
+async function nameSession(sessionId, name) {
+  const trimmed = name.trim();
+  if (!trimmed)
+    return { ok: false, error: "Name cannot be empty." };
+  if (trimmed.length > 50)
+    return { ok: false, error: `Name too long (${trimmed.length} chars, max 50).` };
+  const cache = await loadCache();
+  if (!cache)
+    return { ok: false, error: "No index found. Run `/session list` first." };
+  const resolved = resolveSession(cache.sessions, sessionId);
+  if (!resolved.ok)
+    return { ok: false, error: resolved.error };
+  const match = resolved.match;
+  const locked = await acquireLock();
+  if (!locked)
+    return { ok: false, error: "Could not acquire lock. Another naming operation may be in progress." };
+  try {
+    const names = await loadNames();
+    names[match.id] = trimmed;
+    await saveNames(names);
+    return { ok: true, fullId: match.id };
+  } finally {
+    await releaseLock();
+  }
+}
+async function clearSessionName(sessionId) {
+  const cache = await loadCache();
+  if (!cache)
+    return { ok: false, error: "No index found. Run `/session list` first." };
+  const resolved = resolveSession(cache.sessions, sessionId);
+  if (!resolved.ok)
+    return { ok: false, error: resolved.error };
+  const match = resolved.match;
+  const locked = await acquireLock();
+  if (!locked)
+    return { ok: false, error: "Could not acquire lock." };
+  try {
+    const names = await loadNames();
+    if (!names[match.id])
+      return { ok: false, error: `Session ${match.id.slice(0, 8)}... has no name to clear.` };
+    delete names[match.id];
+    await saveNames(names);
+    return { ok: true, fullId: match.id };
+  } finally {
+    await releaseLock();
+  }
+}
+function extractConversation(text, maxMessages = 40) {
+  const lines = text.split(`
+`).filter(Boolean);
+  const allMessages = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "user" && !entry.isMeta && entry.message?.role === "user" && typeof entry.message.content === "string") {
+        const content = entry.message.content;
+        if (isTopical(content)) {
+          allMessages.push(`USER: ${content.slice(0, 300)}`);
+        }
+      }
+      if (entry.type === "assistant" && entry.message?.role === "assistant") {
+        const content = entry.message.content;
+        if (typeof content === "string" && content.length > 20) {
+          allMessages.push(`ASSISTANT: ${content.slice(0, 400)}`);
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text" && block.text && block.text.length > 20) {
+              allMessages.push(`ASSISTANT: ${block.text.slice(0, 400)}`);
+              break;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      debug(`Malformed JSONL line: ${e.message}`);
+    }
+  }
+  if (allMessages.length <= maxMessages)
+    return allMessages;
+  return allMessages.slice(-maxMessages);
+}
+async function summarizeSession(project, conversation) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    debug("ANTHROPIC_API_KEY not set, skipping summarization");
+    return "";
+  }
+  const transcript = conversation.join(`
+`).slice(0, 6000);
+  if (transcript.length < 50)
+    return "";
+  try {
+    const res = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: SUMMARY_MODEL,
+        max_tokens: 250,
+        messages: [
+          {
+            role: "user",
+            content: `You are summarizing a Claude Code session transcript. Write exactly 5 bullet points (using "- " prefix) describing what was DONE in this session. Focus on concrete outcomes: what was built, fixed, configured, discussed, or decided. Each bullet should be 8-15 words. No intro text, no commentary — ONLY the 5 bullets.
+
+If the transcript is mostly commands like /session or slash commands with no real work, write "- Session management only (no substantive work)" as the single bullet.
+
+Project: ${project}
+
+Transcript:
+${transcript}`
+          }
+        ]
+      })
+    });
+    if (!res.ok) {
+      if (res.status === 429) {
+        process.stderr.write(`[session] Rate limited by Anthropic API, slowing down
+`);
+      } else if (res.status === 401) {
+        process.stderr.write(`[session] Invalid ANTHROPIC_API_KEY
+`);
+      } else {
+        debug(`API returned ${res.status}: ${res.statusText}`);
+      }
+      return "";
+    }
+    const data = await res.json();
+    let text = data.content?.[0]?.text?.trim() || "";
+    text = text.replace(/^\*\*(.+)\*\*$/gm, "$1");
+    text = text.replace(/^#+\s*/gm, "");
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/\*\*/g, "");
+    text = text.replace(/^[•●◦]\s*/gm, "- ");
+    text = text.replace(/^\d+\.\s+/gm, "- ");
+    const bullets = text.split(`
+`).map((l) => l.trim()).filter((l) => l.startsWith("- ")).slice(0, 5);
+    return bullets.join(`
+`) || "";
+  } catch (e) {
+    debug(`API call failed: ${e.message}`);
+    return "";
+  }
+}
+async function parseHistory() {
+  const sessions = new Map;
+  try {
+    const raw = await readFile(HISTORY_FILE, "utf-8");
+    const lines = raw.split(`
+`).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (!entry.sessionId || !entry.display)
+          continue;
+        const id = entry.sessionId;
+        const msg = entry.display.trim();
+        if (!msg)
+          continue;
+        const topical = isTopical(msg);
+        const existing = sessions.get(id);
+        if (existing) {
+          existing.messageCount++;
+          if (topical)
+            existing.lastMessage = msg;
+          if (topical && existing.firstMessage === existing.id) {
+            existing.firstMessage = msg;
+          }
+          existing.lastTimestamp = entry.timestamp;
+          if (existing.allMessages.length < 2000) {
+            existing.allMessages += " " + msg;
+          }
+        } else {
+          sessions.set(id, {
+            id,
+            name: "",
+            project: shortProject(entry.project || ""),
+            projectDir: "",
+            topic: "",
+            firstMessage: topical ? msg : id,
+            lastMessage: topical ? msg : "",
+            allMessages: msg,
+            messageCount: 1,
+            firstTimestamp: entry.timestamp,
+            lastTimestamp: entry.timestamp,
+            cwd: entry.project || "",
+            gitBranch: ""
+          });
+        }
+      } catch (e) {
+        debug(`Malformed history line: ${e.message}`);
+      }
+    }
+  } catch (e) {
+    debug(`Cannot read history file: ${e.message}`);
+  }
+  for (const [, session] of sessions) {
+    if (session.firstMessage === session.id) {
+      session.firstMessage = session.allMessages.trim().slice(0, 100) || "(no messages)";
+    }
+    if (!session.lastMessage) {
+      session.lastMessage = session.firstMessage;
+    }
+  }
+  return sessions;
+}
+async function enrichFromFiles(sessions, conversationMap) {
+  try {
+    const dirs = await readdir(PROJECTS_DIR);
+    for (const dir of dirs) {
+      const dirPath = join(PROJECTS_DIR, dir);
+      let files;
+      try {
+        files = (await readdir(dirPath)).filter((f) => f.endsWith(".jsonl"));
+      } catch (e) {
+        debug(`Cannot read ${dir}: ${e.message}`);
+        continue;
+      }
+      for (const file of files) {
+        const sessionId = basename(file, ".jsonl");
+        const filePath = join(dirPath, file);
+        try {
+          const fileInfo = await stat(filePath);
+          const fileSize = fileInfo.size;
+          let text;
+          if (fileSize <= 60000) {
+            text = await readFile(filePath, "utf-8");
+          } else {
+            const allText = await readFile(filePath, "utf-8");
+            const first = allText.slice(0, 1e4);
+            const last = allText.slice(-50000);
+            text = first + `
+` + last;
+          }
+          const conversation = extractConversation(text, 40);
+          if (conversation.length > 0) {
+            conversationMap.set(sessionId, conversation);
+          }
+          const lines = text.split(`
+`).filter(Boolean);
+          let cwd = "";
+          let gitBranch = "";
+          const userMessages = [];
+          let firstTs = Infinity;
+          let lastTs = 0;
+          for (const line of lines) {
+            try {
+              const entry = JSON.parse(line);
+              if (entry.type === "user" && entry.cwd) {
+                if (!cwd)
+                  cwd = entry.cwd;
+                if (entry.gitBranch && entry.gitBranch !== "HEAD") {
+                  gitBranch = entry.gitBranch;
+                }
+              }
+              if (entry.timestamp) {
+                const ts = typeof entry.timestamp === "string" ? new Date(entry.timestamp).getTime() : entry.timestamp;
+                if (ts < firstTs)
+                  firstTs = ts;
+                if (ts > lastTs)
+                  lastTs = ts;
+              }
+              if (entry.type === "user" && !entry.isMeta && entry.message?.role === "user" && typeof entry.message.content === "string") {
+                if (isTopical(entry.message.content)) {
+                  userMessages.push(entry.message.content.slice(0, 200));
+                }
+              }
+            } catch (e) {
+              debug(`Malformed session line in ${sessionId}: ${e.message}`);
+            }
+          }
+          const existing = sessions.get(sessionId);
+          if (existing) {
+            if (cwd)
+              existing.cwd = cwd;
+            if (gitBranch)
+              existing.gitBranch = gitBranch;
+            existing.projectDir = dir;
+            if (!existing.project || existing.project === "~") {
+              existing.project = shortProject(cwd || decodeProjectDir(dir));
+            }
+          } else if (userMessages.length > 0) {
+            sessions.set(sessionId, {
+              id: sessionId,
+              name: "",
+              project: shortProject(cwd || decodeProjectDir(dir)),
+              projectDir: dir,
+              topic: "",
+              firstMessage: userMessages[0] || "",
+              lastMessage: userMessages[userMessages.length - 1] || "",
+              allMessages: userMessages.join(" ").slice(0, 2000),
+              messageCount: userMessages.length,
+              firstTimestamp: firstTs === Infinity ? 0 : firstTs,
+              lastTimestamp: lastTs,
+              cwd,
+              gitBranch
+            });
+          }
+        } catch (e) {
+          debug(`Cannot process session ${sessionId}: ${e.message}`);
+        }
+      }
+    }
+  } catch (e) {
+    debug(`Cannot read projects dir: ${e.message}`);
+  }
+}
+async function generateSummaries(sessions, conversationMap, existingSummaries) {
+  const summaries = { ...existingSummaries };
+  for (const [id, summary] of Object.entries(summaries)) {
+    if (isGarbageSummary(summary)) {
+      delete summaries[id];
+    }
+  }
+  const needsSummary = sessions.filter((s) => !summaries[s.id] && conversationMap.has(s.id));
+  if (needsSummary.length === 0)
+    return summaries;
+  if (!process.env.ANTHROPIC_API_KEY) {
+    process.stderr.write(`[session] ${needsSummary.length} sessions need summaries but ANTHROPIC_API_KEY is not set
+`);
+    return summaries;
+  }
+  const total = needsSummary.length;
+  process.stderr.write(`Summarizing ${total} sessions with ${SUMMARY_MODEL}...
+`);
+  const BATCH_SIZE = 10;
+  let done = 0;
+  for (let i = 0;i < needsSummary.length; i += BATCH_SIZE) {
+    const batch = needsSummary.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(batch.map(async (session) => {
+      const conversation = conversationMap.get(session.id) || [];
+      const summary = await summarizeSession(session.project, conversation);
+      return { id: session.id, summary };
+    }));
+    for (const { id, summary } of results) {
+      if (summary && !isGarbageSummary(summary)) {
+        summaries[id] = summary;
+      }
+    }
+    done += batch.length;
+    process.stderr.write(`  ${done}/${total}
+`);
+  }
+  return summaries;
+}
+async function buildIndex(force = false) {
+  const [historyMtime, fingerprint] = await Promise.all([
+    getHistoryMtime(),
+    getSessionFilesFingerprint()
+  ]);
+  if (!force) {
+    const cache = await loadCache();
+    if (cache && cache.meta.historyMtime === historyMtime && cache.meta.sessionFileCount === fingerprint.count && cache.meta.maxSessionMtime === fingerprint.maxMtime) {
+      const names2 = await loadNames();
+      for (const s of cache.sessions) {
+        s.name = names2[s.id] || "";
+      }
+      return cache.sessions;
+    }
+  }
+  const existingSummaries = await loadSummaries();
+  const sessions = await parseHistory();
+  const conversationMap = new Map;
+  await enrichFromFiles(sessions, conversationMap);
+  const entries = Array.from(sessions.values()).filter((s) => s.messageCount > 0 && s.firstMessage.length > 0);
+  entries.sort((a, b) => b.lastTimestamp - a.lastTimestamp);
+  const summaries = await generateSummaries(entries, conversationMap, existingSummaries);
+  await saveSummaries(summaries);
+  const names = await loadNames();
+  for (const entry of entries) {
+    entry.topic = summaries[entry.id] || "";
+    entry.name = names[entry.id] || "";
+  }
+  await saveCache({
+    meta: {
+      historyMtime,
+      sessionFileCount: fingerprint.count,
+      maxSessionMtime: fingerprint.maxMtime,
+      builtAt: Date.now()
+    },
+    sessions: entries
+  });
+  return entries;
+}
+// lib/indexer.ts
+import { join as join2, basename as basename2 } from "path";
+var HOME2 = process.env.HOME;
+if (!HOME2) {
+  throw new Error("HOME environment variable is not set");
+}
+var SUMMARY_MODEL2 = process.env.SESSION_SUMMARY_MODEL || "claude-haiku-4-5-20251001";
+var DEBUG2 = Boolean(process.env.SESSION_DEBUG);
+var CLAUDE_DIR2 = join2(HOME2, ".claude");
+var HISTORY_FILE2 = join2(CLAUDE_DIR2, "history.jsonl");
+var PROJECTS_DIR2 = join2(CLAUDE_DIR2, "projects");
+var DATA_DIR2 = join2(CLAUDE_DIR2, "skills", "session", "data");
+var CACHE_FILE2 = join2(DATA_DIR2, "index.json");
+var SUMMARIES_FILE2 = join2(DATA_DIR2, "summaries.json");
+var NAMES_FILE2 = join2(DATA_DIR2, "names.json");
+function isGarbageSummary2(s) {
+  if (!s)
+    return true;
+  const lower = s.toLowerCase();
+  return lower.startsWith("i don't have") || lower.startsWith("i don't see") || lower.startsWith("i'm afraid") || lower.startsWith("i cannot") || lower.startsWith("(80 chars max)") || lower.includes("don't have a transcript") || lower.includes("don't have access");
+}
+var LOCK_FILE2 = NAMES_FILE2 + ".lock";
+
+// lib/format.ts
+function truncate(s, max) {
+  if (s.length <= max)
+    return s;
+  const chars = Array.from(s);
+  if (chars.length <= max)
+    return s;
+  return chars.slice(0, max - 3).join("") + "...";
+}
+function formatDate(ts) {
+  if (!ts)
+    return "unknown";
+  const d = new Date(ts);
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const month = months[d.getMonth()];
+  const day = d.getDate();
+  const hours = d.getHours();
+  const mins = d.getMinutes().toString().padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const h = hours % 12 || 12;
+  return `${month} ${day}, ${h}:${mins} ${ampm}`;
+}
+function displayLine(s) {
+  if (s.topic && !isGarbageSummary2(s.topic)) {
+    const lines = s.topic.split(`
+`).filter((l) => l.trim().length > 0);
+    const firstBullet = lines.find((l) => l.startsWith("- "));
+    if (firstBullet)
+      return firstBullet;
+    return lines[0] || s.topic;
+  }
+  if (s.lastMessage)
+    return s.lastMessage;
+  return s.firstMessage || "(no messages)";
+}
+function makeLabel(s, summary) {
+  if (!s.name)
+    return summary;
+  const clean = summary.startsWith("- ") ? summary.slice(2) : summary;
+  return `${s.name} — ${clean}`;
+}
+function fullSummary(s) {
+  if (s.topic && !isGarbageSummary2(s.topic))
+    return s.topic;
+  if (s.lastMessage)
+    return s.lastMessage;
+  return s.firstMessage || "(no messages)";
+}
+function formatSessionList(sessions, showAll) {
+  const list = showAll ? sessions : sessions.slice(0, 20);
+  const lines = [];
+  if (!showAll && sessions.length > 20) {
+    lines.push(`${sessions.length} sessions (showing 20, use --all for all)
+`);
+  } else {
+    lines.push(`${list.length} session(s)
+`);
+  }
+  for (const s of list) {
+    const date = formatDate(s.lastTimestamp);
+    const msgs = `${s.messageCount} msgs`;
+    const summary = displayLine(s);
+    const label = makeLabel(s, summary);
+    const lastMsg = s.lastMessage && s.lastMessage !== summary ? s.lastMessage : "";
+    lines.push(`${s.id}    ${msgs.padStart(7)} | ${date}`);
+    lines.push(`  ${truncate(label, 100)}`);
+    if (lastMsg) {
+      lines.push(`  Left off: "${truncate(lastMsg, 90)}"`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatSearchResults(sessions, query) {
+  if (sessions.length === 0) {
+    return `No sessions found matching "${query}"`;
+  }
+  const lines = [];
+  const shown = sessions.slice(0, 15);
+  lines.push(`${sessions.length} session(s) matching "${query}"${sessions.length > 15 ? " (showing 15)" : ""}:
+`);
+  for (const s of shown) {
+    const date = formatDate(s.lastTimestamp);
+    const msgs = `${s.messageCount} msgs`;
+    const summary = displayLine(s);
+    const label = makeLabel(s, summary);
+    const lastMsg = s.lastMessage && s.lastMessage !== summary ? s.lastMessage : "";
+    lines.push(`${s.id}    ${msgs.padStart(7)} | ${date}`);
+    lines.push(`  ${truncate(label, 100)}`);
+    if (lastMsg) {
+      lines.push(`  Left off: "${truncate(lastMsg, 90)}"`);
+    }
+    if (s.gitBranch) {
+      lines.push(`  Branch: ${s.gitBranch}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatSessionDetail(session) {
+  const s = session;
+  const lines = [];
+  lines.push(`${s.id}
+`);
+  if (s.name) {
+    lines.push(`Name:     ${s.name}`);
+  }
+  lines.push(`Project:  ${s.project}`);
+  lines.push(`CWD:      ${s.cwd}`);
+  if (s.gitBranch) {
+    lines.push(`Branch:   ${s.gitBranch}`);
+  }
+  lines.push(`Messages: ${s.messageCount}`);
+  lines.push(`Started:  ${formatDate(s.firstTimestamp)}`);
+  lines.push(`Last:     ${formatDate(s.lastTimestamp)}`);
+  lines.push("");
+  lines.push(`What was done:`);
+  lines.push(fullSummary(s));
+  lines.push("");
+  if (s.lastMessage) {
+    lines.push(`Left off: "${s.lastMessage.slice(0, 300)}"`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatStats(sessions) {
+  const byProject = new Map;
+  for (const s of sessions) {
+    const key = s.project || "~";
+    const existing = byProject.get(key);
+    if (existing) {
+      existing.count++;
+      existing.messages += s.messageCount;
+      if (s.lastTimestamp > existing.lastActivity) {
+        existing.lastActivity = s.lastTimestamp;
+      }
+    } else {
+      byProject.set(key, {
+        count: 1,
+        messages: s.messageCount,
+        lastActivity: s.lastTimestamp
+      });
+    }
+  }
+  const sorted = Array.from(byProject.entries()).sort((a, b) => b[1].count - a[1].count);
+  const lines = [];
+  lines.push(`${sessions.length} sessions across ${sorted.length} projects
+`);
+  lines.push(`  ${"Project".padEnd(30)}  ${"Sessions".padStart(8)}  ${"Messages".padStart(8)}  Last Activity`);
+  lines.push(`  ${"-".repeat(30)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(18)}`);
+  for (const [project, data] of sorted) {
+    const p = truncate(project, 30).padEnd(30);
+    lines.push(`  ${p}  ${data.count.toString().padStart(8)}  ${data.messages.toString().padStart(8)}  ${formatDate(data.lastActivity)}`);
+  }
+  return lines.join(`
+`);
+}
+
+// session.ts
+var args = process.argv.slice(2);
+var command = args[0] || "help";
+async function main() {
+  switch (command) {
+    case "list": {
+      const showAll = args.includes("--all");
+      const sessions = await buildIndex();
+      console.log(formatSessionList(sessions, showAll));
+      break;
+    }
+    case "show": {
+      const partial = args[1];
+      if (!partial) {
+        console.error("Usage: session show <session-id-or-prefix>");
+        process.exit(1);
+      }
+      const sessions = await buildIndex();
+      const resolved = resolveSession(sessions, partial);
+      if (!resolved.ok) {
+        console.error(resolved.error);
+        process.exit(1);
+      }
+      console.log(formatSessionDetail(resolved.match));
+      break;
+    }
+    case "rebuild": {
+      const t0 = performance.now();
+      const sessions = await buildIndex(true);
+      const elapsed = Math.round(performance.now() - t0);
+      console.log(`Index rebuilt: ${sessions.length} sessions in ${elapsed}ms`);
+      break;
+    }
+    case "stats": {
+      const sessions = await buildIndex();
+      console.log(formatStats(sessions));
+      break;
+    }
+    case "name": {
+      const rest = args.slice(1);
+      if (rest.length === 0) {
+        console.error(`Usage: session name <name>
+       session name <id> <name>`);
+        process.exit(1);
+      }
+      const first = rest[0];
+      const looksLikeId = /^[0-9a-f]{8}(-[0-9a-f]{4}(-[0-9a-f]{4}(-[0-9a-f]{4}(-[0-9a-f]{12})?)?)?)?$/i.test(first);
+      let sessionId;
+      let sessionName;
+      if (looksLikeId && rest.length > 1) {
+        sessionId = first;
+        sessionName = rest.slice(1).join(" ");
+      } else {
+        const sessions = await buildIndex();
+        if (sessions.length === 0) {
+          console.error("No sessions found.");
+          process.exit(1);
+        }
+        sessionId = sessions[0].id;
+        sessionName = rest.join(" ");
+      }
+      const result = await nameSession(sessionId, sessionName);
+      if (!result.ok) {
+        console.error(result.error);
+        process.exit(1);
+      }
+      console.log(`Named session ${(result.fullId ?? "").slice(0, 8)}... \u2192 "${sessionName.trim()}"`);
+      break;
+    }
+    case "unname":
+    case "clear-name": {
+      const rest = args.slice(1);
+      let sessionId;
+      if (rest.length === 0) {
+        const sessions = await buildIndex();
+        if (sessions.length === 0) {
+          console.error("No sessions found.");
+          process.exit(1);
+        }
+        sessionId = sessions[0].id;
+      } else {
+        const first = rest[0];
+        const looksLikeId = /^[0-9a-f]{8}(-[0-9a-f]{4}(-[0-9a-f]{4}(-[0-9a-f]{4}(-[0-9a-f]{12})?)?)?)?$/i.test(first);
+        if (looksLikeId) {
+          sessionId = first;
+        } else {
+          const sessions = await buildIndex();
+          const { searchSessions: search } = await Promise.resolve().then(() => exports_search);
+          const results = search(sessions, rest.join(" "));
+          if (results.length === 0) {
+            console.error(`No session found matching "${rest.join(" ")}"`);
+            process.exit(1);
+          }
+          sessionId = results[0].id;
+        }
+      }
+      const result = await clearSessionName(sessionId);
+      if (!result.ok) {
+        console.error(result.error);
+        process.exit(1);
+      }
+      console.log(`Cleared name from session ${(result.fullId ?? "").slice(0, 8)}...`);
+      break;
+    }
+    case "search": {
+      const query = args.slice(1).join(" ");
+      if (!query) {
+        console.error("Usage: session search <query>");
+        process.exit(1);
+      }
+      const sessions = await buildIndex();
+      const results = searchSessions(sessions, query);
+      console.log(formatSearchResults(results, query));
+      break;
+    }
+    case "help":
+    default: {
+      if (command !== "help" && command !== "--help" && command !== "-h") {
+        const query = args.join(" ");
+        const sessions = await buildIndex();
+        const results = searchSessions(sessions, query);
+        console.log(formatSearchResults(results, query));
+      } else {
+        console.log(`Usage:
+  session <query>          Search sessions by keyword
+  session list [--all]     Show recent sessions (default: 20)
+  session show <id>        Show session details (partial ID ok)
+  session name <name>      Name the most recent session
+  session name <id> <name> Name a specific session (partial ID ok)
+  session unname [<id>]    Clear a session's name
+  session search <query>   Search sessions by keyword
+  session rebuild          Force rebuild the index
+  session stats            Show index statistics`);
+      }
+      break;
+    }
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});