claude-code-session-manager 0.98.0 → 0.101.0

package/src/main/bilkoHost.cjs

@@ -1,314 +0,0 @@
-'use strict';
-
-/**
- * bilkoHost.cjs — Stage A (deterministic bundle prep) for the "Host on
- * Bilko.run" tab. See session-manager-operations/architecture/
- * bilko-host-integration.md for the full design.
- *
- * Model: ONE Bilko project (slug) hosts a LIST of documents — a root
- * document (subpath '', dist/index.html — "the project itself") plus any
- * number of sub-path documents (subpath 'special-doc/01',
- * dist/special-doc/01/index.html → bilko.run/projects/<slug>/special-doc/01/).
- * `documents.json` is the list; `dist/` is always rebuilt wholesale from it
- * (rm + rewrite) so it can never drift from the list — the same "full
- * replace" semantics Bilko's own publish_static_project already uses, which
- * is exactly what makes local deletion reliably propagate live (see
- * bilkoHostCore.cjs's header comment).
- *
- * This module owns `session-manager-operations/bilko-host/documents.json` +
- * `dist/{**,manifest.json}` (writer id `bilko-host`, OWNERS-enforced via
- * config.cjs's write helpers). It never talks to the bilko-host MCP itself
- * and never writes publish-state.json — that's Stage B, run by the
- * bilko-host-publisher Epic's own session with its own Write tool
- * (agent-authored artifact, same as project-pages/output/*.html; not
- * enforceable by OWNERS). Directory removal (rm -rf of dist/ before a
- * rebuild) uses raw fs directly, same precedent as epicMint.cjs/
- * queueStore.cjs using raw fs for their own owned namespace — this module
- * IS the declared owner of `bilko-host`, so there is no foreign-writer risk
- * to guard against here.
- */
-
-const { ipcMain } = require('electron');
-const { opsPath } = require('./lib/opsOwnership.cjs');
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const { execFileSync } = require('node:child_process');
-const { gzipSync } = require('node:zlib');
-const config = require('./config.cjs');
-const {
-  validateSubpath,
-  validateDocumentSet,
-  documentDistRelPath,
-  documentUrl,
-} = require('./bilkoHostCore.cjs');
-
-const WRITER = 'bilko-host';
-const PROJECT_PAGE_LENSES = new Set(['home', 'marketing', 'feature', 'architecture']);
-
-function homePagePath(cwd) {
-  return opsPath(cwd, 'project-pages', 'home.html');
-}
-
-function bilkoHostDir(cwd) {
-  return opsPath(cwd, 'bilko-host');
-}
-
-function distDir(cwd) {
-  return path.join(bilkoHostDir(cwd), 'dist');
-}
-
-function documentsPath(cwd) {
-  return path.join(bilkoHostDir(cwd), 'documents.json');
-}
-
-/** Kebab-case a project name into a slug candidate. Pure. */
-function deriveSlug(projectDirName) {
-  return String(projectDirName)
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-    .slice(0, 64) || 'project';
-}
-
-function gitInfo(cwd) {
-  const run = (args, fallback) => {
-    try {
-      return execFileSync('git', args, { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    } catch {
-      return fallback;
-    }
-  };
-  return {
-    gitSha: run(['rev-parse', '--short', 'HEAD'], '0000000'),
-    gitBranch: run(['rev-parse', '--abbrev-ref', 'HEAD'], 'main'),
-  };
-}
-
-async function readDocuments(cwd) {
-  const result = await config.readJson(documentsPath(cwd));
-  if (result.exists && !result.parseError && Array.isArray(result.data?.documents)) {
-    return result.data.documents;
-  }
-  return null;
-}
-
-async function writeDocuments(cwd, documents) {
-  await config.writeJson(documentsPath(cwd), { documents }, { writer: WRITER });
-}
-
-/**
- * Reads everything the tab needs to render its status card: whether a
- * Project Page exists to seed a root document from, the project's
- * package.json (for the compatibility gate + default slug/version), the
- * current document list, and any bundle/publish state already on disk.
- */
-async function get({ cwd }) {
-  const realCwd = config.validatePath(cwd);
-
-  // The single Project Home page (project-pages/home.html) seeds the root
-  // document. `hasMarketingPage` is the renderer's legacy field name for
-  // "a root-document source page exists".
-  const marketingResult = await config.readText(homePagePath(realCwd));
-  const pkgResult = await config.readJson(path.join(realCwd, 'package.json'));
-  const pkg = pkgResult.exists && !pkgResult.parseError ? pkgResult.data : null;
-
-  const documents = (await readDocuments(realCwd)) ?? [];
-
-  const bundleManifestResult = await config.readJson(path.join(distDir(realCwd), 'manifest.json'));
-  const bundleManifest = bundleManifestResult.exists && !bundleManifestResult.parseError
-    ? bundleManifestResult.data
-    : null;
-
-  const publishStateResult = await config.readJson(path.join(bilkoHostDir(realCwd), 'publish-state.json'));
-  const publishState = publishStateResult.exists && !publishStateResult.parseError
-    ? publishStateResult.data
-    : null;
-
-  const slug = bundleManifest?.slug
-    ?? deriveSlug(pkg && typeof pkg.name === 'string' ? pkg.name : path.basename(realCwd));
-
-  return {
-    hasMarketingPage: marketingResult.exists,
-    projectName: pkg && typeof pkg.name === 'string' ? pkg.name : path.basename(realCwd),
-    packagePrivate: pkg ? pkg.private === true : false,
-    packageHomepage: pkg && typeof pkg.homepage === 'string' ? pkg.homepage : null,
-    packageVersion: pkg && typeof pkg.version === 'string' ? pkg.version : '0.0.0',
-    defaultSlug: deriveSlug(pkg && typeof pkg.name === 'string' ? pkg.name : path.basename(realCwd)),
-    documents: documents.map((d) => ({ ...d, url: documentUrl(slug, d.subpath) })),
-    // A rebuild is owed whenever the bundle on disk doesn't reflect the
-    // current document list — the tab uses this to gray out "up to date"
-    // vs. prompt "Prepare Bundle" again, and (post-publish) to warn that a
-    // removed document is still live until the next Publish.
-    bundleStale: bundleManifest ? bundleManifest.documentCount !== documents.length : documents.length > 0,
-    bundleManifest,
-    publishState,
-  };
-}
-
-/** Seeds documents.json with a single root document (the Project Home page, home.html) if it doesn't exist yet. */
-async function ensureSeededDocuments(cwd) {
-  const existing = await readDocuments(cwd);
-  if (existing) return existing;
-  const seeded = [{
-    id: crypto.randomUUID(),
-    subpath: '',
-    title: 'Project (Home)',
-    source: { kind: 'project-page-lens', lens: 'home' },
-    addedAt: new Date().toISOString(),
-  }];
-  await writeDocuments(cwd, seeded);
-  return seeded;
-}
-
-/**
- * Add a hosted document. `source` is either
- * `{ kind: 'project-page-lens', lens: 'home'|'marketing'|'feature'|'architecture' }`
- * (reuses an already-generated Project Page lens) or
- * `{ kind: 'file', path: <repo-relative path> }` (any other local HTML —
- * e.g. a HUMAN_LEARN page or a hand-authored explainer).
- */
-async function addDocument({ cwd, subpath, title, source }) {
-  const realCwd = config.validatePath(cwd);
-  const subpathCheck = validateSubpath(subpath);
-  if (!subpathCheck.ok) throw new Error(subpathCheck.error);
-  if (source.kind === 'project-page-lens' && !PROJECT_PAGE_LENSES.has(source.lens)) {
-    throw new Error(`unknown Project Page lens: ${source.lens}`);
-  }
-
-  const documents = (await readDocuments(realCwd)) ?? await ensureSeededDocuments(realCwd);
-  if (subpath === '') {
-    throw new Error('the root document (subpath "") always exists — edit it instead of adding a second one');
-  }
-  if (documents.some((d) => d.subpath === subpath)) {
-    throw new Error(`a document already uses subpath "${subpath}"`);
-  }
-
-  const next = [...documents, {
-    id: crypto.randomUUID(),
-    subpath,
-    title,
-    source,
-    addedAt: new Date().toISOString(),
-  }];
-  const setCheck = validateDocumentSet(next);
-  if (!setCheck.ok) throw new Error(setCheck.error);
-
-  await writeDocuments(realCwd, next);
-  return { documents: next };
-}
-
-/**
- * Remove a hosted document (never the root). This only updates
- * documents.json — the file stays in `dist/` (and, if already published,
- * live on bilko.run) until the next Prepare Bundle + Publish, which is the
- * confirmed mechanism that actually removes it (Bilko's publish tool
- * rm -rf's + rebuilds the whole slug directory every publish).
- */
-async function removeDocument({ cwd, id }) {
-  const realCwd = config.validatePath(cwd);
-  const documents = (await readDocuments(realCwd)) ?? [];
-  const target = documents.find((d) => d.id === id);
-  if (!target) throw new Error(`no document with id ${id}`);
-  if (target.subpath === '') throw new Error('cannot remove the root document');
-
-  const next = documents.filter((d) => d.id !== id);
-  await writeDocuments(realCwd, next);
-  return { documents: next };
-}
-
-async function resolveDocumentHtml(cwd, doc) {
-  if (doc.source.kind === 'project-page-lens') {
-    // Only `home` is generated now (one home.html); other lens names are
-    // retired and have no output anywhere — fail loudly rather than fall back.
-    if (doc.source.lens !== 'home') {
-      throw new Error(`document "${doc.title}" points at the retired "${doc.source.lens}" Project Page lens; only the single home.html page is generated now`);
-    }
-    const result = await config.readText(homePagePath(cwd));
-    if (!result.exists) {
-      throw new Error(`document "${doc.title}" points at the ${doc.source.lens} Project Page, but it hasn't been generated yet`);
-    }
-    return result.text;
-  }
-  if (doc.source.kind === 'file') {
-    const abs = config.validatePath(path.join(cwd, doc.source.path));
-    const result = await config.readText(abs);
-    if (!result.exists) throw new Error(`document "${doc.title}"'s source file is missing: ${doc.source.path}`);
-    return result.text;
-  }
-  throw new Error(`unknown document source kind: ${doc.source.kind}`);
-}
-
-/**
- * Stage A: rebuild the ENTIRE dist/ tree from documents.json (rm + rewrite,
- * mirroring Bilko's own full-replace publish semantics so local state can
- * never lag the document list) + dist/manifest.json (host-contract manifest
- * schema, one per bundle — golden.path/expect always point at the root
- * document). Idempotent.
- */
-async function prepareBundle({ cwd, slug }) {
-  const realCwd = config.validatePath(cwd);
-  const documents = await ensureSeededDocuments(realCwd);
-
-  const setCheck = validateDocumentSet(documents);
-  if (!setCheck.ok) throw new Error(setCheck.error);
-
-  const pkgResult = await config.readJson(path.join(realCwd, 'package.json'));
-  const pkg = pkgResult.exists && !pkgResult.parseError ? pkgResult.data : {};
-  const version = typeof pkg.version === 'string' ? pkg.version : '0.0.0';
-
-  const dist = distDir(realCwd);
-  await fsp.rm(dist, { recursive: true, force: true });
-
-  let totalGz = 0;
-  for (const doc of documents) {
-    const html = await resolveDocumentHtml(realCwd, doc);
-    const relPath = documentDistRelPath(doc.subpath);
-    await config.writeTextAtomic(path.join(dist, relPath), html, { writer: WRITER });
-    totalGz += gzipSync(Buffer.from(html, 'utf8')).length;
-  }
-
-  const { gitSha, gitBranch } = gitInfo(realCwd);
-  const goldenExpect = pkg && typeof pkg.name === 'string' ? pkg.name : slug;
-
-  const manifest = {
-    schemaVersion: 1,
-    slug,
-    version,
-    builtAt: new Date().toISOString(),
-    gitSha,
-    gitBranch,
-    hostKit: { version: '0.0.0' },
-    golden: { path: `/projects/${slug}/`, expect: goldenExpect },
-    health: {},
-    bundle: { sizeBytesGz: totalGz, fileCount: documents.length },
-    // Not part of the host-contract schema itself — this app's own staleness
-    // check (get()'s bundleStale) compares this against documents.length.
-    documentCount: documents.length,
-    documents: documents.map((d) => ({ subpath: d.subpath, title: d.title })),
-  };
-
-  await config.writeJson(path.join(dist, 'manifest.json'), manifest, { writer: WRITER });
-
-  return { distPath: dist, manifest };
-}
-
-function registerBilkoHostIpc() {
-  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
-  ipcMain.handle('bilko-host:get', v(s.bilkoHostCwd, get));
-  ipcMain.handle('bilko-host:prepare-bundle', v(s.bilkoHostPrepareBundle, prepareBundle));
-  ipcMain.handle('bilko-host:add-document', v(s.bilkoHostAddDocument, addDocument));
-  ipcMain.handle('bilko-host:remove-document', v(s.bilkoHostRemoveDocument, removeDocument));
-}
-
-module.exports = {
-  registerBilkoHostIpc,
-  get,
-  prepareBundle,
-  addDocument,
-  removeDocument,
-  deriveSlug,
-  bilkoHostDir,
-  distDir,
-};

package/src/main/bilkoHostCore.cjs

@@ -1,89 +0,0 @@
-'use strict';
-
-/**
- * bilkoHostCore.cjs — pure logic for the "Host on Bilko.run" tab's
- * multi-document bundle model. No fs/IPC here (that's bilkoHost.cjs) so
- * this stays unit-testable without a real project directory.
- *
- * Model: ONE Bilko project (one registry slug, one `dist/` tree) can host
- * MANY documents — exactly one root document (subpath `''`, becomes
- * dist/index.html — "the project itself") plus any number of sub-path
- * documents (subpath 'special-doc/01', becomes dist/special-doc/01/
- * index.html → bilko.run/projects/<slug>/special-doc/01/). This mirrors how
- * Bilko's own publish_static_project already works: it `rm -rf`s then
- * `cp -r`s the WHOLE public/projects/<slug>/ tree on every publish, so
- * removing a document locally and re-publishing is guaranteed to remove it
- * live too — no separate per-document delete API needed on Bilko's side.
- */
-
-const SUBPATH_SEGMENT = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const MAX_SEGMENTS = 6;
-const MAX_SUBPATH_LENGTH = 200;
-
-/**
- * Validates a document's subpath. `''` (root) is always valid. Otherwise
- * every '/'-separated segment must be lowercase kebab-case, no '.'/'..',
- * no leading/trailing/double slashes, bounded depth and length.
- */
-function validateSubpath(subpath) {
-  if (typeof subpath !== 'string') return { ok: false, error: 'subpath must be a string' };
-  if (subpath === '') return { ok: true, error: null };
-  if (subpath.length > MAX_SUBPATH_LENGTH) return { ok: false, error: 'subpath is too long' };
-  if (subpath.startsWith('/') || subpath.endsWith('/')) {
-    return { ok: false, error: 'subpath must not start or end with /' };
-  }
-  const segments = subpath.split('/');
-  if (segments.length > MAX_SEGMENTS) return { ok: false, error: `subpath has more than ${MAX_SEGMENTS} segments` };
-  for (const seg of segments) {
-    if (!SUBPATH_SEGMENT.test(seg)) {
-      return { ok: false, error: `invalid subpath segment "${seg}" — use lowercase kebab-case` };
-    }
-  }
-  return { ok: true, error: null };
-}
-
-/**
- * Validates a full document list: subpaths individually valid, exactly one
- * root document, no duplicate subpaths. Pure — takes the array shape
- * documents.json stores, `[{ id, subpath, ... }]`.
- */
-function validateDocumentSet(documents) {
-  if (!Array.isArray(documents) || documents.length === 0) {
-    return { ok: false, error: 'at least one document (the root) is required' };
-  }
-  const seen = new Set();
-  let rootCount = 0;
-  for (const doc of documents) {
-    const v = validateSubpath(doc.subpath);
-    if (!v.ok) return { ok: false, error: `document "${doc.id}": ${v.error}` };
-    if (seen.has(doc.subpath)) return { ok: false, error: `duplicate subpath "${doc.subpath}"` };
-    seen.add(doc.subpath);
-    if (doc.subpath === '') rootCount += 1;
-  }
-  if (rootCount !== 1) return { ok: false, error: 'exactly one document must have subpath "" (the project root)' };
-  return { ok: true, error: null };
-}
-
-/** Where a document's rendered HTML lands inside dist/. Pure path math. */
-function documentDistRelPath(subpath) {
-  return subpath === '' ? 'index.html' : `${subpath}/index.html`;
-}
-
-/**
- * The bilko.run URL a document resolves to once published, given the
- * project's slug. Pure — used by the tab to render "will be live at" links
- * before anything is actually published.
- */
-function documentUrl(slug, subpath) {
-  return subpath === '' ? `https://bilko.run/projects/${slug}/` : `https://bilko.run/projects/${slug}/${subpath}/`;
-}
-
-module.exports = {
-  SUBPATH_SEGMENT,
-  MAX_SEGMENTS,
-  MAX_SUBPATH_LENGTH,
-  validateSubpath,
-  validateDocumentSet,
-  documentDistRelPath,
-  documentUrl,
-};

package/src/main/lib/__tests__/active-sessions.test.cjs

@@ -1,251 +0,0 @@
-'use strict';
-
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/active-sessions.test.cjs
-
-import { vi } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { activeProjectCwds, allProjectCwds, bustProjectCwdCache } = require('../activeSessions.cjs');
-
-function tmpDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'active-sessions-test-'));
-}
-
-function writeTranscript(projectsDir, slug, fileName, cwd, mtimeMsAgo) {
-  const projDir = path.join(projectsDir, slug);
-  fs.mkdirSync(projDir, { recursive: true });
-  const fp = path.join(projDir, fileName);
-  fs.writeFileSync(fp, JSON.stringify({ cwd }) + '\n');
-  const mtime = new Date(Date.now() - mtimeMsAgo);
-  fs.utimesSync(fp, mtime, mtime);
-  return fp;
-}
-
-test('two recent + one stale + one nonexistent → returns exactly the two recent existing cwds', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-a');
-    const cwdB = path.join(base, 'proj-b');
-    const cwdC = path.join(base, 'proj-c');       // stale — exists on disk
-    const cwdMissing = path.join(base, 'proj-missing'); // never created
-    fs.mkdirSync(cwdA);
-    fs.mkdirSync(cwdB);
-    fs.mkdirSync(cwdC);
-
-    const MAX_AGE_MIN = 90;
-    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 10 * 60 * 1000);
-    writeTranscript(projectsDir, 'slug-b', 'b.jsonl', cwdB, 10 * 60 * 1000);
-    writeTranscript(projectsDir, 'slug-c', 'c.jsonl', cwdC, 120 * 60 * 1000);
-    writeTranscript(projectsDir, 'slug-missing', 'm.jsonl', cwdMissing, 10 * 60 * 1000);
-
-    const result = activeProjectCwds(MAX_AGE_MIN, { projectsDir });
-
-    assert.equal(
-      result.length, 2,
-      `expected 2 cwds, got ${result.length}: ${JSON.stringify(result)}`,
-    );
-    assert.ok(result.includes(cwdA), `cwdA must be in result`);
-    assert.ok(result.includes(cwdB), `cwdB must be in result`);
-    assert.ok(!result.includes(cwdC),       'stale cwdC must not appear');
-    assert.ok(!result.includes(cwdMissing), 'nonexistent path must not appear');
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('duplicate cwd across two project dirs → deduped to one entry', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-a');
-    fs.mkdirSync(cwdA);
-
-    writeTranscript(projectsDir, 'slug-1', 'a.jsonl', cwdA, 5 * 60 * 1000);
-    writeTranscript(projectsDir, 'slug-2', 'b.jsonl', cwdA, 5 * 60 * 1000);
-
-    const result = activeProjectCwds(90, { projectsDir });
-    assert.equal(result.length, 1, 'duplicate cwd must be deduped');
-    assert.equal(result[0], cwdA);
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('missing projects dir → empty result', () => {
-  const base = tmpDir();
-  try {
-    const result = activeProjectCwds(90, { projectsDir: path.join(base, 'no-such-dir') });
-    assert.deepEqual(result, []);
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('prompts.jsonl absent → transcripts still detected (sole detection path)', () => {
-  const base = tmpDir();
-  try {
-    // No knowledge-log / prompts.jsonl anywhere in this tmp tree — the
-    // function must not need it. logPath, if passed, is a harmless no-op.
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-a');
-    fs.mkdirSync(cwdA);
-
-    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
-
-    const missingLogPath = path.join(base, 'knowledge-log', 'prompts.jsonl');
-    assert.ok(!fs.existsSync(missingLogPath), 'sanity: log path must not exist');
-
-    const result = activeProjectCwds(90, { projectsDir, logPath: missingLogPath });
-    assert.deepEqual(result, [cwdA]);
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('fresh transcript mtime with no prompt log present → cwd is returned', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-fresh');
-    fs.mkdirSync(cwdA);
-
-    writeTranscript(projectsDir, 'slug-fresh', 'fresh.jsonl', cwdA, 60 * 1000); // 1 min ago
-
-    const result = activeProjectCwds(90, { projectsDir });
-    assert.equal(result.length, 1);
-    assert.equal(result[0], cwdA);
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('garbage lines in transcript are skipped, cwd read from last parseable line', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-a');
-    fs.mkdirSync(cwdA);
-
-    const projDir = path.join(projectsDir, 'slug-a');
-    fs.mkdirSync(projDir, { recursive: true });
-    const fp = path.join(projDir, 'a.jsonl');
-    fs.writeFileSync(fp, [
-      JSON.stringify({ cwd: cwdA }),
-      'not json at all!!!',
-      '{ broken',
-    ].join('\n') + '\n');
-    const mtime = new Date(Date.now() - 5 * 60 * 1000);
-    fs.utimesSync(fp, mtime, mtime);
-
-    const result = activeProjectCwds(90, { projectsDir });
-    assert.equal(result.length, 1);
-    assert.equal(result[0], cwdA);
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('5 consecutive allProjectCwds() calls with the same args perform ONE directory scan', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-a');
-    fs.mkdirSync(cwdA);
-    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
-
-    bustProjectCwdCache();
-    const readdirSpy = vi.spyOn(fs, 'readdirSync');
-
-    const first = allProjectCwds({ projectsDir });
-    const callsAfterFirst = readdirSpy.mock.calls.length;
-    assert.ok(callsAfterFirst > 0, 'first call must actually scan');
-
-    for (let i = 0; i < 4; i++) {
-      const again = allProjectCwds({ projectsDir });
-      assert.deepEqual(again, first);
-    }
-
-    assert.equal(
-      readdirSpy.mock.calls.length, callsAfterFirst,
-      'the 4 repeat calls must not perform any additional directory scan',
-    );
-  } finally {
-    vi.restoreAllMocks();
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('bustProjectCwdCache() forces the very next call to rescan', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdA = path.join(base, 'proj-a');
-    fs.mkdirSync(cwdA);
-    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
-
-    bustProjectCwdCache();
-    allProjectCwds({ projectsDir }); // warm the cache
-
-    const readdirSpy = vi.spyOn(fs, 'readdirSync');
-    allProjectCwds({ projectsDir });
-    assert.equal(readdirSpy.mock.calls.length, 0, 'a cache hit must not scan');
-
-    bustProjectCwdCache();
-    allProjectCwds({ projectsDir });
-    assert.ok(readdirSpy.mock.calls.length > 0, 'a bust must force a rescan on the next call');
-  } finally {
-    vi.restoreAllMocks();
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('allProjectCwds() and activeProjectCwds(90) do not share a cache entry', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    const cwdFresh = path.join(base, 'proj-fresh');
-    const cwdStale = path.join(base, 'proj-stale');
-    fs.mkdirSync(cwdFresh);
-    fs.mkdirSync(cwdStale);
-    writeTranscript(projectsDir, 'slug-fresh', 'fresh.jsonl', cwdFresh, 5 * 60 * 1000);
-    writeTranscript(projectsDir, 'slug-stale', 'stale.jsonl', cwdStale, 120 * 60 * 1000);
-
-    bustProjectCwdCache();
-    // allProjectCwds (maxAgeMin Infinity, maxCwds 500) sees both — cached
-    // first under its own key.
-    const all = allProjectCwds({ projectsDir });
-    assert.ok(all.includes(cwdFresh) && all.includes(cwdStale));
-
-    // activeProjectCwds(90) must recompute under its OWN key, not return
-    // allProjectCwds' cached (Infinity, 500) result — proving the cache key
-    // includes maxAgeMin/maxCwds, not just projectsDir.
-    const active = activeProjectCwds(90, { projectsDir });
-    assert.ok(active.includes(cwdFresh), 'fresh cwd must be present');
-    assert.ok(!active.includes(cwdStale), 'stale cwd must be excluded by the 90-min filter');
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test('missing projectsDir returns [] and does not poison the cache once the dir appears', () => {
-  const base = tmpDir();
-  try {
-    const projectsDir = path.join(base, 'projects');
-    bustProjectCwdCache();
-
-    assert.deepEqual(activeProjectCwds(90, { projectsDir }), []);
-    assert.deepEqual(activeProjectCwds(90, { projectsDir }), []);
-
-    const cwdA = path.join(base, 'proj-a');
-    fs.mkdirSync(cwdA);
-    writeTranscript(projectsDir, 'slug-a', 'a.jsonl', cwdA, 5 * 60 * 1000);
-
-    const result = activeProjectCwds(90, { projectsDir });
-    assert.deepEqual(result, [cwdA], 'the dir appearing later must be visible, not stuck on a cached []');
-  } finally {
-    fs.rmSync(base, { recursive: true, force: true });
-  }
-});