great-cto 3.59.1 → 3.61.0

package/board/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "great-cto",
   "description": "You already have the agent. This is everything around it. great_cto runs Claude Code as a pipeline of 72 specialist agents \u2014 an independent model checks each stage before the next builds on it, spending caps refuse rather than warn, and three decisions stay yours: what gets built, how, and whether it ships.",
-  "version": "3.59.1",
+  "version": "3.61.0",
   "author": {
     "name": "Alexander Velikiy",
     "url": "https://hashnode.com/@Greatcto"

package/board/packages/board/lib/projects.mjs

@@ -436,7 +436,8 @@ function resolveProjectInfo(slugOrPath) {
   // choose between candidates.
   const byDerived = reg.projects.filter((p) => {
     if (!p?.path) return false;
-    return path.basename(p.path) === slugOrPath;
+    try { return path.basename(p.path) === slugOrPath || readProjectMd(p.path)?.slug === slugOrPath; }
+    catch { return false; }
   });
   const derived = pickBestBySlug(byDerived);
   if (derived) return { cwd: derived.path, resolved: 'slug' };

package/board/packages/board/lib/routes.mjs

@@ -67,6 +67,7 @@ import { getAgentsFleet, getAgentProfile, retireAgent, restoreAgent, appendDecis
 import { getResume, getShareState, toggleShare } from './share.mjs';
 import { listSessions, readSession, editedFiles, searchSessions } from './transcripts.mjs';
 import { recordView, summarizeViews } from './view-counter.mjs';
+import { getSkillsInventory } from './skills-inventory.mjs';
 
 // ── HTTP router ────────────────────────────────────────────────────────────────
 // dispatch(req, res, url, cwd, projInfo) handles every /api/* route plus /api/sse.
@@ -91,6 +92,7 @@ function verdictHeaders(cwd, base = { 'Content-Type': 'application/json', 'Cache
 
 async function dispatch(req, res, url, cwd) {
   const pathname = url.pathname;
+  const serverCwd = cwd;
 
   // The selected project, resolved ONCE for every route below.
   //
@@ -117,6 +119,11 @@ async function dispatch(req, res, url, cwd) {
     }
   }
 
+  // These read models accept registered projects or the server's own root,
+  // never an arbitrary HOME directory supplied as a query parameter.
+  const scopedProject = ['/api/skills', '/api/usage', '/api/outcomes'].includes(pathname)
+    ? scopedReadProject(cwd, serverCwd, requestedProject) : null;
+
   if (pathname === '/api/work/publication') {
     const respond = (status, body) => { res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' }); res.end(JSON.stringify(body)); };
     if (requestedProject && resolveProjectInfo(requestedProject).resolved === 'fallback') { respond(404, { error: 'Unknown project' }); return true; }
@@ -171,6 +178,30 @@ async function dispatch(req, res, url, cwd) {
     return true;
   }
 
+  // Inventory is a read-only local observation. Query parameters cannot choose
+  // filesystem roots, install skills or ask for network/upstream checks.
+  if (pathname === '/api/skills') {
+    const headers = { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' };
+    if (req.method !== 'GET') {
+      res.writeHead(405, { ...headers, Allow: 'GET' });
+      res.end(JSON.stringify({ error: 'Skill inventory is read-only' }));
+      return true;
+    }
+    if (!scopedProject) {
+      res.writeHead(404, headers);
+      res.end(JSON.stringify({ error: 'Unknown project; skill inventory was not read' }));
+      return true;
+    }
+    try {
+      const snapshot = await getSkillsInventory(cwd);
+      res.writeHead(200, headers); res.end(JSON.stringify(snapshot));
+    } catch {
+      res.writeHead(503, headers);
+      res.end(JSON.stringify({ error: 'Skill inventory could not be read' }));
+    }
+    return true;
+  }
+
   // New read model refuses project fallback rather than relabeling another project.
   if (pathname === '/api/work') {
     if (requestedProject && resolveProjectInfo(requestedProject).resolved === 'fallback') {
@@ -1570,15 +1601,19 @@ async function dispatch(req, res, url, cwd) {
     return true;
   }
 
-  // What Claude Code and Codex consumed on this machine — tokens, models, the
+  // What Claude Code and Codex consumed in the selected project — tokens, models, the
   // heaviest conversations, tools, skills, agents, cache, Codex's plan window —
   // read from the hosts' own session logs (scripts/lib/session-usage.mjs).
-  // Machine-wide like /api/agent-usage: the logs are one history. Served on the
+  // Filter before aggregation, including linked worktrees. Served on the
   // board's own host only; nothing here is sent anywhere.
   if (pathname === '/api/usage') {
+    if (!scopedProject) {
+      res.writeHead(404, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ error: 'Unknown project', state: 'unavailable' })); return true;
+    }
     const rawDays = parseInt(url.searchParams.get('days') || '30', 10);
     const days = Number.isFinite(rawDays) && rawDays > 0 ? Math.min(rawDays, 365) : 30;
-    const snap = boardSessionUsage().get(days);
+    const snap = boardSessionUsage().get(days, cwd);
     let body;
     if (snap.state !== 'counted') {
       body = { state: snap.state, why: snap.why };
@@ -1603,15 +1638,19 @@ async function dispatch(req, res, url, cwd) {
     return true;
   }
 
-  // What the agents concluded and what reviews found, across every registered
-  // project (scripts/lib/outcomes.mjs): verdicts per agent, Beads bugs by
+  // What the agents concluded and what reviews found in this project
+  // (scripts/lib/outcomes.mjs): verdicts per agent, Beads bugs by
   // priority. Counts only — no bug title leaves the server. Answers at once:
-  // `computing` until the first read of every project's Beads lands.
+  // `computing` until the first read of this project's Beads lands.
   if (pathname === '/api/outcomes') {
+    if (!scopedProject) {
+      res.writeHead(404, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify({ error: 'Unknown project', state: 'unavailable' })); return true;
+    }
     const rawDays = parseInt(url.searchParams.get('days') || '30', 10);
     const days = Number.isFinite(rawDays) && rawDays > 0 ? Math.min(rawDays, 365) : 30;
     res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
-    res.end(JSON.stringify(boardOutcomes(days)));
+    res.end(JSON.stringify(boardOutcomes(days, scopedProject)));
     return true;
   }
 
@@ -2304,16 +2343,45 @@ function boardHookNames() {
 
 const _outcomes = new Map();
 const OUTCOMES_TTL = 5 * 60 * 1000;
-function boardOutcomes(days) {
-  const slot = _outcomes.get(days) || {};
+function scopedReadProject(cwd, serverCwd, requested) {
+  const canonical = dir => { try { return fs.realpathSync(dir); } catch { return path.resolve(dir); } };
+  const projectPath = canonical(cwd);
+  const entries = (readProjectsRegistry().projects || []).filter(p => p?.path);
+  const own = entries.filter(p => canonical(p.path) === projectPath);
+  if (requested && (resolveProjectInfo(requested).resolved === 'fallback'
+    || (!own.length && projectPath !== canonical(serverCwd)))) return null;
+  const labels = p => {
+    const result = [p.slug, p.name, p.path, path.basename(p.path)];
+    let fd;
+    try {
+      fd = fs.openSync(path.join(p.path, '.great_cto', 'PROJECT.md'), 'r');
+      const bytes = Buffer.alloc(65536);
+      const text = bytes.subarray(0, fs.readSync(fd, bytes, 0, bytes.length, 0)).toString('utf8');
+      for (const key of ['slug', 'project', 'name']) result.push(text.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'))?.[1]?.trim());
+    } catch { /* aliases absent; canonical path still identifies the root */ }
+    finally { if (fd !== undefined) fs.closeSync(fd); }
+    return result.filter(Boolean);
+  };
+  const foreign = new Set(entries.filter(p => canonical(p.path) !== projectPath).flatMap(labels));
+  const aliases = [...new Set([...own, { path: projectPath }].flatMap(labels))].filter(label => !foreign.has(label)).sort();
+  return { name: own[0]?.slug || own[0]?.name || path.basename(projectPath), path: projectPath, aliases };
+}
+function boardOutcomes(days, project) {
+  const projectPath = project.path;
+  const key = JSON.stringify([days, projectPath, project.aliases]);
+  const slot = _outcomes.get(key) || {};
   const fresh = slot.value && Date.now() - slot.at < OUTCOMES_TTL;
   if (!fresh && !slot.running) {
-    slot.running = computeOutcomes({ days, roster: boardAgentNames() })
-      .then((v) => { slot.value = v; }, (e) => { slot.value = slot.value || { state: 'unavailable', why: `outcomes could not be read: ${e?.message || e}` }; })
+    slot.running = computeOutcomes({ days, roster: boardAgentNames(), projects: [project], projectScope: true })
+      .then((v) => { slot.value = { ...v, scope: { kind: 'project', path: projectPath } }; }, () => { slot.value = slot.value || { state: 'unavailable', why: 'Outcomes could not be read.' }; })
       .finally(() => { slot.at = Date.now(); slot.running = null; });
-    _outcomes.set(days, slot);
+    if (_outcomes.size >= 32 && !_outcomes.has(key)) {
+      const evict = [..._outcomes].find(([, s]) => !s.running);
+      if (evict) _outcomes.delete(evict[0]);
+    }
+    _outcomes.set(key, slot);
   }
-  return slot.value || { state: 'computing', why: 'reading every project\'s verdicts and Beads' };
+  return slot.value || { state: 'computing', why: 'reading this project\'s verdicts and Beads' };
 }
 
 let _sessionUsageSnap = null;

package/board/packages/board/lib/skills-inventory.mjs

@@ -0,0 +1,228 @@
+import fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createHash } from 'node:crypto';
+import { parseFrontmatter, strictYamlIssues, SIZE_BUDGET, DESC_MIN, DESC_MAX } from '../../../scripts/skill-lint.mjs';
+
+// Discovery is not host activation, trust verification or a quality evaluation.
+// Never execute a discovered script or fetch its upstream. No caller-supplied
+// roots: only HOME, the server-resolved project, and fixed local registry tiers.
+export const INVENTORY_LIMITS = Object.freeze({
+  entries: 12000, skills: 2000, depth: 10, fileBytes: 128 * 1024,
+  totalBytes: 8 * 1024 * 1024, registryBytes: 2 * 1024 * 1024, milliseconds: 1500,
+  cacheEntries: 2500, cacheSkills: 300, cacheMilliseconds: 450,
+});
+const inside = (root, file) => file === root || file.startsWith(root + path.sep);
+const digest = bytes => createHash('sha256').update(bytes).digest('hex');
+const safeDeclaration = value => typeof value === 'string' && !/\/(?:Users|home)\//.test(value)
+  ? value.slice(0, 160) : null;
+
+async function readBounded(file, max, root) {
+  let handle;
+  try {
+    if (!inside(root, await fs.realpath(file))) return { state: 'outside-root' };
+    handle = await fs.open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const before = await handle.stat();
+    if (!before.isFile()) return { state: 'unreadable' };
+    if (before.size > max) return { state: 'too-large' };
+    const bytes = Buffer.alloc(max + 1);
+    let size = 0;
+    while (size <= max) {
+      const read = await handle.read(bytes, size, bytes.length - size, null);
+      if (!read.bytesRead) break;
+      size += read.bytesRead;
+    }
+    const after = await handle.stat();
+    if (size > max) return { state: 'too-large' };
+    if (before.size !== size || before.size !== after.size || before.mtimeMs !== after.mtimeMs
+      || before.ctimeMs !== after.ctimeMs) return { state: 'changed-during-read' };
+    return { state: 'observed', bytes: bytes.subarray(0, size) };
+  } catch (e) {
+    return { state: e.code === 'ENOENT' ? 'missing' : 'unreadable' };
+  } finally { await handle?.close(); }
+}
+
+export async function skillInventory({ home = os.homedir(), cwd, limits = {} } = {}) {
+  const started = Date.now();
+  // macOS /tmp is a system alias for /private/tmp, not a skill symlink.
+  // Normalize only the trusted base once, rejecting symlinks below that base.
+  const originalHome = path.resolve(home), originalCwd = cwd && path.resolve(cwd);
+  home = await fs.realpath(home);
+  if (cwd) cwd = await fs.realpath(cwd);
+  const cap = Object.fromEntries(Object.entries(INVENTORY_LIMITS).map(([key, value]) =>
+    [key, Number.isInteger(limits[key]) && limits[key] > 0 ? Math.min(value, limits[key]) : value]));
+  const roots = [
+    ['.claude/skills', 'Claude Code'], ['.codex/skills', 'Codex'], ['.agents/skills', 'Shared'],
+    ['.claude/plugins/cache', 'Claude Code'], ['.codex/plugins/cache', 'Codex'],
+  ].map(([rel, host]) => ({ root: path.join(home, rel), label: '~/' + rel, host, scope: 'machine', cache: rel.endsWith('/cache') }));
+  if (cwd) for (const [rel, host] of [['.claude/skills', 'Claude Code'], ['.codex/skills', 'Codex'], ['.agents/skills', 'Shared']])
+    roots.push({ root: path.join(cwd, rel), label: 'project/' + rel, host, scope: 'project' });
+  // A large plugin's node_modules must not starve selected-project roots.
+  roots.sort((a, b) => Number(Boolean(a.cache)) - Number(Boolean(b.cache)));
+  const registryRoots = ['catalog', 'anthropic-skills', 'personal-skills'].map(rel => ({
+    root: path.join(home, '.great_cto', rel), label: '~/.great_cto/' + rel, host: 'Registry', scope: 'machine',
+  }));
+  const skills = [], sources = [], byFile = new Map();
+  let entries = 0, readBytes = 0, truncated = false;
+  const exhausted = () => {
+    if (entries >= cap.entries || skills.length >= cap.skills || readBytes >= cap.totalBytes || Date.now() - started > cap.milliseconds) {
+      truncated = true; return true;
+    }
+    return false;
+  };
+  async function add(file, source, declaredSource = null) {
+    if (byFile.has(file)) {
+      if (declaredSource) byFile.get(file).declared_source = safeDeclaration(declaredSource);
+      return;
+    }
+    const read = await readBounded(file, Math.min(cap.fileBytes, cap.totalBytes - readBytes), source.root);
+    readBytes += read.bytes?.length || 0;
+    const location = source.label + '/' + path.relative(source.root, file).split(path.sep).join('/');
+    const name = path.basename(file) === 'SKILL.md' ? path.basename(path.dirname(file)) : path.basename(file, '.md');
+    const warnings = [];
+    if (read.state === 'observed' && path.basename(file) === 'SKILL.md') {
+      const text = read.bytes.toString('utf8');
+      try {
+        const fm = parseFrontmatter(text);
+        if (!fm) warnings.push('missing-frontmatter');
+        else {
+          if (fm.data.name !== name) warnings.push('name-mismatch');
+          const d = fm.data.description;
+          if (typeof d !== 'string' || d.length < DESC_MIN || d.length > DESC_MAX) warnings.push('description-length');
+        }
+      } catch { warnings.push('invalid-frontmatter'); }
+      if (strictYamlIssues(text).length) warnings.push('ambiguous-yaml');
+      if (read.bytes.length > SIZE_BUDGET) warnings.push('over-context-budget');
+    }
+    if (read.state !== 'observed') source.state = 'partial';
+    const segments = path.relative(source.root, file).split(path.sep);
+    const row = { id: digest(source.scope + ':' + location).slice(0, 24), name, host: source.host, scope: source.scope,
+      location, declared_source: safeDeclaration(declaredSource),
+      cache_version: source.cache && segments.length > 3 ? safeDeclaration(segments[2]) : null,
+      read_state: read.state, bytes: read.bytes?.length ?? null,
+      document_sha256: read.bytes ? digest(read.bytes) : null, integrity: 'document-only',
+      upstream_revision: null, enabled: 'unknown', loaded: 'unknown', quality: 'not-measured', warnings };
+    skills.push(row); byFile.set(file, row);
+  }
+  async function scanSource(descriptor) {
+    const source = { ...descriptor, state: 'observed', warnings: [] };
+    sources.push(source);
+    if (exhausted()) { source.state = 'not-scanned'; return; }
+    const startEntries = entries, startSkills = skills.length, startTime = Date.now();
+    const sourceExhausted = () => {
+      if (exhausted()) return true;
+      if (source.cache && (entries - startEntries >= cap.cacheEntries
+        || skills.length - startSkills >= cap.cacheSkills || Date.now() - startTime > cap.cacheMilliseconds)) {
+        source.state = 'partial';
+        if (!source.warnings.includes('source-limit')) source.warnings.push('source-limit');
+        truncated = true; return true;
+      }
+      return false;
+    };
+    // Reject symlinked ancestors too; directory traversal is fixed, not an
+    // arbitrary-file capability. Not an atomic sandbox against a hostile same-UID process.
+    try {
+      if (await fs.realpath(source.root) !== path.resolve(source.root)) {
+        source.state = 'partial'; source.warnings.push('symlink-skipped'); return;
+      }
+    } catch (e) { source.state = e.code === 'ENOENT' ? 'absent' : 'unreadable'; return; }
+    const queue = [[source.root, 0]];
+    while (queue.length && !sourceExhausted()) {
+      const [dir, depth] = queue.shift();
+      let handle;
+      try {
+        if (await fs.realpath(dir) !== dir) { source.state = 'partial'; source.warnings.push('symlink-skipped'); continue; }
+        handle = await fs.opendir(dir);
+        for await (const entry of handle) {
+          ++entries;
+          if (sourceExhausted()) break;
+          const file = path.join(dir, entry.name);
+          if (entry.isSymbolicLink()) {
+            source.state = 'partial';
+            if (!source.warnings.includes('symlink-skipped')) source.warnings.push('symlink-skipped');
+          } else if (entry.isDirectory()) {
+            // Host caches are vendor/product/version/{skills,.codex-plugin}.
+            // Beyond version roots, traverse only skill-bearing directories,
+            // not package sources, git trees, assets or dependency installations.
+            const segments = path.relative(source.root, dir).split(path.sep);
+            const skillArea = segments.some(s => s === 'skills' || s === 'migrated-command-skills');
+            if (source.cache && depth >= 3 && !skillArea
+              && !['skills', '.codex-plugin', 'migrated-command-skills'].includes(entry.name)) continue;
+            if (['.git', 'node_modules'].includes(entry.name)) continue;
+            if (depth < cap.depth) queue.push([file, depth + 1]);
+            else { source.state = 'partial'; source.warnings.push('depth-limit'); truncated = true; }
+          } else if (entry.isFile() && entry.name === 'SKILL.md'
+            && (!source.cache || path.relative(source.root, file).split(path.sep).some(s => s === 'skills' || s === 'migrated-command-skills'))) {
+            await add(file, source);
+          }
+        }
+      } catch { source.state = 'unreadable'; }
+      // for-await owns the directory handle, including early break.
+    }
+    if (queue.length) source.state = 'partial';
+  }
+  // Local project/host directories and the existing registry have priority over
+  // large historical plugin caches. Each cache also gets its own bounded share.
+  for (const root of roots.filter(r => !r.cache)) await scanSource(root);
+  const registryFile = path.join(home, '.great_cto', 'skills-registry.json');
+  const registryRead = await readBounded(registryFile, cap.registryBytes, path.join(home, '.great_cto'));
+  const registry = { state: registryRead.state === 'missing' ? 'absent' : 'unreadable', declared_at: null, plugin_version: null };
+  if (registryRead.state === 'observed') {
+    try {
+      const data = JSON.parse(registryRead.bytes.toString('utf8'));
+      if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error('invalid registry');
+      const tiers = ['tier1_great_cto', 'tier2_external', 'tier3_personal'];
+      if (!tiers.some(key => Array.isArray(data[key]))) throw new Error('invalid registry');
+      registry.state = 'observed';
+      registry.declared_at = /^\d{4}-\d{2}-\d{2}T/.test(data.discovered_at || '') ? String(data.discovered_at).slice(0, 32) : null;
+      registry.plugin_version = safeDeclaration(data.plugin_version);
+      const source = { label: '~/.great_cto/skills-registry.json', state: 'observed', warnings: [], host: 'Registry', scope: 'machine' };
+      sources.push(source);
+      for (const key of tiers) {
+        if (data[key] !== undefined && !Array.isArray(data[key])) { source.state = 'partial'; continue; }
+        for (const entry of data[key] || []) {
+          ++entries;
+          if (exhausted()) { source.state = 'partial'; break; }
+          let file = typeof entry?.path === 'string' && path.isAbsolute(entry.path) ? path.resolve(entry.path) : null;
+          if (file && inside(originalHome, file)) file = path.join(home, path.relative(originalHome, file));
+          else if (file && originalCwd && inside(originalCwd, file)) file = path.join(cwd, path.relative(originalCwd, file));
+          const allowed = file && [...roots, ...registryRoots].find(r => inside(r.root, file));
+          if (!allowed || !file.endsWith('.md')) { source.state = 'partial'; source.warnings.push('unmanaged-path'); continue; }
+          // Registry entries must not bypass the directory symlink guard.
+          try {
+            if (await fs.realpath(file) !== file) throw new Error('symlink');
+          } catch {
+            source.state = 'partial';
+            source.warnings.push('unavailable-declaration');
+            continue;
+          }
+          await add(file, { ...allowed, state: 'observed' }, entry.source);
+          if (byFile.get(file)?.read_state !== 'observed') source.state = 'partial';
+        }
+      }
+      source.warnings = [...new Set(source.warnings)];
+    } catch { registry.state = 'unreadable'; }
+  }
+  for (const root of roots.filter(r => r.cache)) await scanSource(root);
+  const partial = truncated || registry.state === 'unreadable' || sources.some(s => !['observed', 'absent'].includes(s.state));
+  return { schema: 1, state: partial ? 'partial' : 'observed', observed_at: new Date().toISOString(),
+    duration_ms: Date.now() - started, truncated, registry,
+    sources: sources.map(({ label, host, scope, state, warnings }) => ({ label, host, scope, state, warnings })),
+    skills: skills.sort((a, b) => a.location < b.location ? -1 : a.location > b.location ? 1 : 0) };
+}
+
+// Bound memory and coalesce concurrent Claude/Codex board requests. This is a
+// read cache, not a cross-process lock for installation/update (not implemented).
+const cache = new Map();
+export function getSkillsInventory(cwd) {
+  const key = os.homedir() + '\0' + path.resolve(cwd);
+  const previous = cache.get(key);
+  if (previous && (!previous.settled || Date.now() - previous.at < 30000)) return previous.promise;
+  const item = { at: Date.now(), settled: false, promise: skillInventory({ cwd }) };
+  cache.set(key, item);
+  if (cache.size > 8) cache.delete(cache.keys().next().value);
+  item.promise.then(() => { item.settled = true; item.at = Date.now(); },
+    () => { if (cache.get(key) === item) cache.delete(key); });
+  return item.promise;
+}

package/board/packages/board/lib/usage-report-worker.mjs

@@ -2,8 +2,8 @@ import { parentPort, workerData } from 'node:worker_threads';
 import { scanUsage, summarizeUsage, readCodexTitles, readClaudeLimits, claudeRecorder } from '../../../scripts/lib/session-usage.mjs';
 try {
   const snapshot = await scanUsage();
-  const report = summarizeUsage(snapshot.index, { days: workerData.days, codexTitles: readCodexTitles(), claudeReadings: readClaudeLimits(), claudeRecorderState: claudeRecorder() });
-  parentPort.postMessage({ ...report, seen: snapshot.seen, files: snapshot.files });
+  const report = summarizeUsage(snapshot.index, { days: workerData.days, projectPath: workerData.projectPath, codexTitles: readCodexTitles(), claudeReadings: readClaudeLimits(), claudeRecorderState: claudeRecorder() });
+  parentPort.postMessage({ seen: snapshot.seen, files: snapshot.files, ...report });
 } catch {
   parentPort.postMessage({ state: 'unavailable', why: 'Session statistics could not be read; retry or inspect local logs.' });
 }

package/board/packages/board/lib/usage-report.mjs

@@ -1,8 +1,9 @@
 import { Worker } from 'node:worker_threads';
+import path from 'node:path';
 
-function computeReport(days) {
+function computeReport(days, projectPath) {
   return new Promise((resolve, reject) => {
-    const worker = new Worker(new URL('./usage-report-worker.mjs', import.meta.url), { workerData: { days } });
+    const worker = new Worker(new URL('./usage-report-worker.mjs', import.meta.url), { workerData: { days, projectPath } });
     worker.unref();
     let settled = false;
     const finish = (error, result) => {
@@ -20,26 +21,33 @@ function computeReport(days) {
 
 /** Bounded stale-while-refresh cache. One scan at a time, off the HTTP thread. */
 export function usageReports({ compute = computeReport, now = Date.now, ttlMs = 60000, limit = 8 } = {}) {
-  const slots = new Map(); let running = null;
+  const slots = new Map(); let running = null, runningKey = null;
   return {
-    get(days) {
-      let slot = slots.get(days);
+    get(days, projectPath = null) {
+      projectPath = projectPath ? path.resolve(projectPath) : null;
+      const key = JSON.stringify([days, projectPath]);
+      let slot = slots.get(key);
       if (!slot) {
-        if (slots.size >= limit) slots.delete(slots.keys().next().value);
-        slot = { value: null, at: 0 }; slots.set(days, slot);
+        if (slots.size >= limit) {
+          const evict = [...slots.keys()].find(k => k !== runningKey);
+          if (evict === undefined) return { state: 'computing', why: 'Waiting for the active statistics scan; navigation remains available.' };
+          slots.delete(evict);
+        }
+        slot = { value: null, at: 0 }; slots.set(key, slot);
       }
       if ((!slot.value || now() - slot.at >= ttlMs) && !running) {
-        running = Promise.resolve().then(() => compute(days)).then(value => {
+        runningKey = key;
+        running = Promise.resolve().then(() => compute(days, projectPath)).then(value => {
           if (value?.state === 'counted') { slot.value = value; slot.error = null; }
           else if (!slot.value) slot.value = { state: 'unavailable', why: value?.why || 'Statistics could not be read.' };
           else slot.error = value?.why || 'Statistics refresh failed.';
         }, () => {
           if (!slot.value) slot.value = { state: 'unavailable', why: 'Statistics worker failed; retry after a minute.' };
           else slot.error = 'Statistics refresh failed.';
-        }).finally(() => { slot.at = now(); running = null; });
+        }).finally(() => { slot.at = now(); running = null; runningKey = null; });
       }
       if (!slot.value) return { state: 'computing', why: 'Reading session statistics in a background worker; navigation remains available.' };
-      return { ...slot.value, refreshing: !!running, stale: !!slot.error || now() - slot.at >= ttlMs, refreshError: slot.error || null };
+      return { ...slot.value, refreshing: runningKey === key, stale: !!slot.error || now() - slot.at >= ttlMs, refreshError: slot.error || null };
     },
   };
 }

package/board/packages/board/lib/view-counter.mjs

@@ -28,7 +28,7 @@ import path from 'path';
 // it exists to protect. Work and History were routed and missing from this list,
 // so opening either answered 400 into the console; the test now pins the two
 // lists to each other.
-const VALID_VIEWS = ['work', 'history', 'decisions', 'ledger', 'fleet', 'harness', 'usage', 'settings', 'kanban'];
+const VALID_VIEWS = ['work', 'history', 'decisions', 'ledger', 'fleet', 'harness', 'usage', 'skills', 'settings', 'kanban'];
 
 function logFilePath(root) {
   return path.join(root, '.great_cto', 'view-counter.log');