crewforth 3.1.0-rc.5 → 3.1.0-rc.6

package/kit/studio/server/index.js

@@ -17,18 +17,20 @@ import os from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { getFleet, measureSpawnCost } from './lib/fleet.js';
-import { projectDir, listSessions, findSession, listProjects, sessionCwd } from './lib/projects.js';
+import { projectDir, listSessions, findSession, listProjects, sessionCwd, agentMetaFiles } from './lib/projects.js';
+import { agentOrigins } from './lib/agent-origin.js';
 import { buildGraph, agentDetail, conversation, STALE_MS } from './lib/graph.js';
 import { cachedUsage } from './lib/usage.js';
+import { readModels, readRecord, readCosts } from './lib/model-outcomes.js';
 
 const USAGE_BATCH = 12;
 import { palette } from './lib/palette.js';
 import { latestVersion, latestVersionCached, kitStatus } from './lib/kit.js';
 import { parsePeers, askAll, ask } from './lib/peers.js';
 import {
-  createSession, getSession, listSessionsOwned, reap, stopAll, ALLOWED_MODES,
+  createSession, getSession, listSessionsOwned, reap, stopAll, dropSpools, ALLOWED_MODES,
 } from './lib/session.js';
-import { decide, pending, alwaysList, revoke } from './lib/permissions.js';
+import { decide, pending, alwaysList, revoke, sweepLeft } from './lib/permissions.js';
 import { open as openTerminal, plan as terminalPlan } from './lib/terminal.js';
 import { gateLog, gateReport, sessionStats, board } from './lib/kit-telemetry.js';
 import { writeState, clearStateSync, findRunning } from './lib/instance.js';
@@ -138,8 +140,45 @@ export function writeAllowed(req) {
   return { ok: true };
 }
 
+/**
+ * The record of outcomes for a project, with each agent's cost where it can be read. Only the sessions written
+ * since the record began are opened, and each is read once and kept until it grows (usage.js).
+ */
+/** The ids of the agents of one session, from the files it left: the only lines of the record a page of it needs. */
+async function agentIdsOf(session) {
+  if (!session?.subagentsDir) return [];
+  return (await agentMetaFiles(session.subagentsDir)).map((m) => path.basename(m).replace(/^agent-/, '').replace(/\.meta\.json$/, ''));
+}
+
+/**
+ * What the classes of a project cost: each agent's tokens at list price, from the transcripts of the project's
+ * sessions that are on this machine. Reading those is the expensive part of the Models view, so it is asked for
+ * apart from the record and less often, and a session whose transcript has not changed is not read again
+ * (`cachedUsage`).
+ */
+async function modelCosts(cwd) {
+  const rec = readRecord(cwd);
+  if (!rec.measured) return { measured: false, reason: rec.reason, costs: {}, sessionsRead: 0 };
+  const per = new Map();
+  const dir = await projectDir(cwd);
+  let read = 0;
+  if (dir) {
+    const since = (rec.firstAt ?? 0) - 3600_000;
+    for (const s of (await listSessions(dir)).filter((x) => x.modifiedAt >= since).slice(0, MODELS_SESSIONS_MAX)) {
+      const u = await cachedUsage(s);
+      read += 1;
+      for (const [id, a] of Object.entries(u.agents ?? {})) per.set(id, a.cost);
+    }
+  }
+  return { measured: true, costs: readCosts(cwd, (id) => (per.has(id) ? per.get(id) : null)), sessionsRead: read };
+}
+const MODELS_SESSIONS_MAX = 60;
+
 const MAX_BODY_BYTES = 1024 * 1024;
 
+/** The session events after which a subscriber is sent the session's summary again. */
+export const STATE_AFTER = new Set(['result', 'exit', 'mode']);
+
 function readBody(req) {
   return new Promise((resolve) => {
     let size = 0;
@@ -294,6 +333,24 @@ async function handle(req, res) {
   }
 
   // What Crewforth already measures about itself, reported as Crewforth reports it.
+  // Which model did which class of work in this project, and how it went: Crewforth's own record of outcomes,
+  // and the lines of it that belong to the session on screen. What the classes cost is the next route.
+  if (url.pathname === '/api/models') {
+    const sid = url.searchParams.get('session');
+    const session = sid ? await findSession(sid) : null;
+    const cwd = url.searchParams.get('cwd') || (session ? await sessionCwd(session.file, session.bytes) : null);
+    if (!cwd) return sendJson(res, 200, { measured: false, reason: 'no project named', classes: [], suggestions: [], byAgent: {} });
+    return sendJson(res, 200, readModels(cwd, { agents: await agentIdsOf(session) }));
+  }
+
+  if (url.pathname === '/api/models/cost') {
+    const sid = url.searchParams.get('session');
+    const session = sid ? await findSession(sid) : null;
+    const cwd = url.searchParams.get('cwd') || (session ? await sessionCwd(session.file, session.bytes) : null);
+    if (!cwd) return sendJson(res, 200, { measured: false, reason: 'no project named', costs: {}, sessionsRead: 0 });
+    return sendJson(res, 200, await modelCosts(cwd));
+  }
+
   if (url.pathname === '/api/kit') {
     const cwd = url.searchParams.get('cwd') || process.cwd();
     const sid = url.searchParams.get('session');
@@ -310,6 +367,14 @@ async function handle(req, res) {
     return sendJson(res, 200, palette());
   }
 
+  // Where the agents of a session's project are defined: the project's own files and the user's.
+  if (url.pathname === '/api/agents') {
+    const sid = url.searchParams.get('session');
+    const session = sid ? await findSession(sid) : null;
+    const cwd = session ? await sessionCwd(session.file, session.bytes) : null;
+    return sendJson(res, 200, { measured: true, ...agentOrigins(cwd) });
+  }
+
   if (url.pathname === '/api/sessions') {
     const cwd = url.searchParams.get('cwd') || process.cwd();
     const dir = await projectDir(cwd);
@@ -455,12 +520,12 @@ async function handle(req, res) {
     const body = await readBody(req);
     if (!body) return sendJson(res, 400, { ok: false, reason: 'body was not JSON' });
     const toolUseId = decodeURIComponent(permMatch[2]);
-    const out = decide(s.id, toolUseId, body.verdict);
+    const out = decide(s.id, toolUseId, body.verdict, { answers: body.answers, mode: body.mode });
     if (out.ok) s.noteDecision(toolUseId, body.verdict);
     return sendJson(res, out.ok ? 200 : 400, out);
   }
 
-  const ownedMatch = url.pathname.match(/^\/api\/owned\/([^/]+)(?:\/(message|stop|events))?$/);
+  const ownedMatch = url.pathname.match(/^\/api\/owned\/([^/]+)(?:\/(message|stop|events|mode))?$/);
   if (ownedMatch) {
     const s = getSession(decodeURIComponent(ownedMatch[1]));
     if (!s) return sendJson(res, 404, { ok: false, reason: 'no such owned session' });
@@ -476,6 +541,13 @@ async function handle(req, res) {
 
     if (verb === 'stop') return sendJson(res, 200, { ...s.stop(), session: s.summary() });
 
+    // The viewer chose another mode for the session, from the three a session may be started in.
+    if (verb === 'mode') {
+      const asked = await readBody(req);
+      const out = s.requestMode(asked?.mode);
+      return sendJson(res, out.ok ? 200 : 400, { ...out, session: s.summary() });
+    }
+
     const body = await readBody(req);
     if (!body) return sendJson(res, 400, { ok: false, reason: 'body was not JSON' });
     const sent = s.send(body.text);
@@ -728,7 +800,9 @@ function ownedStream(req, res, url, session) {
 
   const unsubscribe = session.subscribe((ev) => {
     write('event', ev);
-    if (ev.rec?.type === 'result' || ev.rec?.type === 'exit') write('state', session.summary());
+    // The summary is what a pane paints its strip from. It follows what changes it: a turn ending, the session
+    // going, and the mode Claude Code reports. Without the last, the strip waited for the beat below.
+    if (STATE_AFTER.has(ev.rec?.type)) write('state', session.summary());
   }, after);
 
   const beat = setInterval(() => write('state', session.summary()), 15000);
@@ -815,6 +889,10 @@ async function main() {
     process.exit(await selftest());
   }
 
+  // What an earlier server left under the temp directory when it was killed: gone before this one makes its own.
+  // Only a server that is about to run does this; asking for --help or --selftest removes nothing.
+  sweepLeft();
+
   const server = http.createServer((req, res) => {
     handle(req, res).catch((e) => {
       process.stderr.write(`crewforth-studio: unhandled: ${e?.stack ?? e}\n`);
@@ -900,6 +978,7 @@ async function main() {
       // Children outlive their parent unless told otherwise, and a panel that
       // leaks running sessions is worse than one that never started them.
       stopAll();
+      dropSpools();
       server.close(() => process.exit(0));
       setTimeout(() => process.exit(0), 2000).unref();
     });

package/kit/studio/server/lib/agent-origin.js

@@ -0,0 +1,44 @@
+// Where a Claude Code agent is defined, as far as that can be read from disk.
+//
+// Claude Code takes an agent that is not built in from a Markdown file whose frontmatter names it: in the project
+// (`.claude/agents/`), in the user's own directory (`~/.claude/agents/`), or in a plugin. This file reads the first
+// two and nothing else. It keeps no list of built-in types: an agent found in neither place is reported as not
+// found, which is all that is known about it.
+//
+// Not read: a plugin's files (a plugin agent is told by its name, `plugin:agent`, in web/names.js), agents given
+// on the command line, managed settings, and files in a directory under `agents/`.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { PROJECTS_ROOT } from './projects.js';
+
+/** The agents one directory defines: { name: file name }. Null when the directory is not there or cannot be read. */
+export function agentsIn(dir) {
+  let files;
+  try { files = fs.readdirSync(dir); } catch { return null; }
+  const out = {};
+  for (const f of files.sort()) {
+    if (!f.endsWith('.md')) continue;
+    let src;
+    try { src = fs.readFileSync(path.join(dir, f), 'utf8'); } catch { continue; }
+    // Frontmatter only, as the palette reads it: a "name:" in the body is not the agent's name.
+    const fm = src.replace(/\r\n/g, '\n').split(/^---$/m)[1] ?? '';
+    const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim().replace(/^["']|["']$/g, '');
+    if (name && out[name] === undefined) out[name] = f;
+  }
+  return out;
+}
+
+/** Claude Code's own directory is the parent of its projects directory; the user's agents sit beside the projects. */
+export const USER_AGENTS_DIR = path.join(path.dirname(PROJECTS_ROOT), 'agents');
+
+/**
+ * @returns { project, user } — each { name: file name }, or null where that directory was not read. A project's
+ *          definition is the one Claude Code uses when both name the same agent, and it is listed in both here.
+ */
+export function agentOrigins(cwd, userDir = USER_AGENTS_DIR) {
+  return {
+    project: cwd ? agentsIn(path.join(cwd, '.claude', 'agents')) : null,
+    user: agentsIn(userDir),
+  };
+}

package/kit/studio/server/lib/graph.js

@@ -85,6 +85,41 @@ export function modelRank(model) {
   return i === -1 ? null : i;
 }
 
+// The tool a subagent hands its result back with. The report is the call's `message`; the agent often says
+// nothing after it, so a transcript with a handback and no closing text still holds a report.
+const HANDBACK = 'SubagentHandback';
+
+/**
+ * What an agent reported, from its own transcript, and where that was read from.
+ *
+ *   `closing`  — text the agent wrote after its last handback: its own last word, and it wins;
+ *   `handback` — the message of its last handback call, when nothing was written after it;
+ *   `text`     — with no handback at all, the last text it wrote (what came before is narration).
+ *
+ * Text written BEFORE a handback is narration on the way to it and is never the report.
+ * @returns { text, from } — text is null when the transcript holds none of the three
+ */
+export function reportIn(records) {
+  let lastText = null;       // the last text block of all
+  let afterHandback = null;  // the last text block since the last handback
+  let handback = null;
+  for (const r of records ?? []) {
+    if (r?.type !== 'assistant' || !Array.isArray(r.message?.content)) continue;
+    for (const c of r.message.content) {
+      if (c?.type === 'text' && typeof c.text === 'string' && c.text.trim()) {
+        lastText = c.text;
+        if (handback !== null) afterHandback = c.text;
+      } else if (c?.type === 'tool_use' && c.name === HANDBACK && typeof c.input?.message === 'string' && c.input.message.trim()) {
+        handback = c.input.message;
+        afterHandback = null;
+      }
+    }
+  }
+  if (afterHandback !== null) return { text: afterHandback, from: 'closing' };
+  if (handback !== null) return { text: handback, from: 'handback' };
+  return { text: lastText, from: lastText === null ? null : 'text' };
+}
+
 /** How a report says it ended: the `confidence: high|low` line a crew agent closes with, or null. */
 export function confidenceOf(text) {
   const m = typeof text === 'string' ? text.trimEnd().match(/(?:^|\n)\W*confidence:\s*(high|low)\W*$/i) : null;
@@ -287,7 +322,7 @@ async function scanAgent(file, usage = null, agentId = null) {
   const stats = {
     tools: {}, toolCount: 0, lastTool: null, errors: 0,
     model: null,      // the model its own transcript names: what it actually ran on
-    lastText: null,   // the end of the last thing it said, for the line a report closes with
+    lastText: null,   // the end of its report, for the line a report closes with
     tokens: null, startedAt: null, endedAt: null, turns: 0,
     owns: [], // tool_use ids this agent emitted — how nesting is resolved
   };
@@ -304,8 +339,6 @@ async function scanAgent(file, usage = null, agentId = null) {
       stats.turns += 1;
       const mdl = r.message?.model;
       if (typeof mdl === 'string' && mdl && mdl !== '<synthetic>') stats.model = mdl;
-      const said = textOf(r.message?.content);
-      if (said.trim()) stats.lastText = said.slice(-400);
       const u = r.message?.usage;
       if (u && u.cache_read_input_tokens != null) {
         stats.tokens = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
@@ -333,6 +366,8 @@ async function scanAgent(file, usage = null, agentId = null) {
   stats.durationMs = stats.startedAt !== null && stats.endedAt !== null
     ? stats.endedAt - stats.startedAt
     : null;
+  // The report, wherever the agent put it: the confidence line is its last line, handback included.
+  stats.lastText = reportIn(records).text?.slice(-400) ?? null;
   stats.midTurn = midTurn(records);
   stats.open = openCalls(records);
   return stats;
@@ -692,9 +727,10 @@ export async function agentDetail(session, agentId) {
     }
   }
 
-  // The report is the last text block the agent produced. Earlier blocks are
-  // narration between tool calls, which is progress rather than conclusion.
-  const report = texts.length ? texts[texts.length - 1].text : null;
+  // The report: what the agent wrote last, or what it handed back when it wrote nothing after that. Earlier
+  // blocks are narration between tool calls, which is progress rather than conclusion.
+  const reported = reportIn(records);
+  const report = reported.text;
 
   return {
     agentId,
@@ -705,9 +741,11 @@ export async function agentDetail(session, agentId) {
     spawnDepth: meta.spawnDepth ?? null,
     prompt,
     report,
+    // Where the report was read from: 'closing', 'handback' or 'text' (see reportIn); null when there is none.
+    reportFrom: reported.from,
     // Kept apart so the UI can show progress for an agent that has not
     // reported yet, without pretending the narration is a conclusion.
-    narration: texts.slice(0, -1).map((t) => t.text),
+    narration: texts.filter((t) => t.text !== report).map((t) => t.text),
     thinking: lastThinking,
     timeline,
     lastError,

package/kit/studio/server/lib/model-outcomes.js

@@ -0,0 +1,287 @@
+// What Crewforth recorded about which model did which work, and how it went.
+//
+// Crewforth writes one line per finished crew agent to `.claude/state/model-outcomes.tsv` (hooks/agent-outcome.sh):
+//
+//   ts  agent_id  agent  change  risk  card  model  verify  fixes  escalated_from  ran_on  confidence
+//
+// Twelve columns, tab-separated, a header on the first line, "-" for an empty value, and any column added later
+// is added at the end. This file reads that and adds nothing to it: a class's first-try success is counted from
+// the rows, never estimated, and a row that says nothing about the work says nothing here either.
+//
+//   class            agent x change x risk
+//   verified         verify is pass or fail: the command ran and gave a verdict
+//   first try        verify = pass and fixes = 0
+//   not verified     verify is none (no command), blocked (the command was not allowed to run) or timeout: no
+//                    verdict about the work, so these are shown apart and are in no rate
+//   escalated        escalated_from is not "-": this call repeats a card that failed one model down
+//
+// Crewforth also writes `.claude/state/crew-model-floors.auto`: a class held one model up because its first try
+// failed too often. Lowering such a hold is the user's to approve, with a Crewforth command in their own session:
+// Studio shows which holds could be lowered (`suggestionsOf`) and writes nothing. A panel's button is a request
+// any process of the same user can send, so it cannot stand for the user.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const COLUMNS = ['ts', 'agent_id', 'agent', 'change', 'risk', 'card', 'model', 'verify', 'fixes', 'escalated_from', 'ran_on', 'confidence'];
+const VERIFIED = new Set(['pass', 'fail']);
+// What the hooks write, and nothing else is a row. The words are hooks/guard-agent-model.sh's and
+// hooks/agent-outcome.sh's; a word they do not use is a line this file cannot read, not a new kind of work.
+export const VERIFY = ['pass', 'fail', 'none', 'blocked', 'timeout'];
+export const CHANGES = ['text', 'feature', 'fix-known', 'fix-unknown', 'refactor', 'migration', 'security', 'architecture', 'test-run', 'test-write', 'audit'];
+export const RISKS = ['critical', 'normal'];
+const TIERS = ['haiku', 'sonnet', 'opus', 'fable'];
+const MAX_BYTES = 4 * 1024 * 1024;      // the record is read whole; past this only its end is, and the answer says so
+// How many of a held class's latest verified calls have to have passed first time before lowering it is offered.
+// A starting point; it has not been measured.
+export const LOOSEN_AFTER = 10;
+const TRAIL_MAX = 6;
+
+const stateDir = (cwd) => path.join(cwd, '.claude', 'state');
+const dash = (v) => (v === '-' || v === '' || v == null ? null : v);
+
+/** Is this line one the hooks could have written? Every field that is counted or compared has to be what they write. */
+function rowProblem(f) {
+  if (f.length < COLUMNS.length) return 'fewer than twelve columns';
+  if (!/^[A-Za-z0-9._-]+$/.test(f[1])) return 'no agent id';
+  if (!Number.isFinite(Date.parse(f[0])) || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ$/.test(f[0])) return 'ts is not a UTC time';
+  if (!f[2]) return 'no agent';
+  if (!CHANGES.includes(f[3])) return 'change is not one of the eleven';
+  if (!RISKS.includes(f[4])) return 'risk is not critical or normal';
+  if (f[6] !== '-' && !TIERS.includes(f[6])) return 'model is not a tier';
+  if (!VERIFY.includes(f[7])) return 'verify is not one of the five';
+  if (!/^\d{1,4}$/.test(f[8])) return 'fixes is not a count';
+  if (f[9] !== '-' && !TIERS.includes(f[9])) return 'escalated_from is not a tier';
+  return null;
+}
+
+/**
+ * The rows of a model-outcomes.tsv. A line the hooks could not have written is dropped and counted, with the
+ * first reason of each kind kept so the view can say why the count is not zero.
+ */
+export function parseOutcomes(text) {
+  const lines = String(text ?? '').split('\n').map((l) => l.replace(/\r$/, '')).filter((l) => l !== '');
+  const out = { rows: [], dropped: 0, why: {}, header: false };
+  for (const [i, line] of lines.entries()) {
+    const f = line.split('\t');
+    if (i === 0 && f[0] === 'ts' && f[1] === 'agent_id') { out.header = true; continue; }
+    const problem = rowProblem(f);
+    if (problem) { out.dropped += 1; out.why[problem] = (out.why[problem] ?? 0) + 1; continue; }
+    const at = Date.parse(f[0]);
+    out.rows.push({
+      line: i, ts: f[0], at, agentId: f[1], agent: f[2], change: f[3], risk: f[4], card: dash(f[5]),
+      model: dash(f[6]), verify: f[7], fixes: Number.parseInt(f[8], 10), escalatedFrom: dash(f[9]), ranOn: dash(f[10]),
+      confidence: dash(f[11]),
+    });
+  }
+  return out;
+}
+
+/** The lines of crew-model-floors.auto: agent, change, risk, model, calls, not-first-try, when. Comments start with #. */
+export function parseFloors(text) {
+  const out = [];
+  for (const line of String(text ?? '').split('\n')) {
+    const l = line.replace(/\r$/, '');
+    if (!l || l.startsWith('#')) continue;
+    const f = l.split('\t');
+    if (f.length < 4 || !TIERS.includes(f[3])) continue;
+    out.push({ agent: f[0], change: f[1], risk: f[2], model: f[3], calls: Number.parseInt(f[4], 10) || null, notFirstTry: Number.parseInt(f[5], 10) || 0, when: f[6] ?? null });
+  }
+  return out;
+}
+
+/** The user's approvals to lower a held class: ts, agent, change, risk, from, to. The newest for a class is the one that counts. */
+export function parseLoosened(text) {
+  const out = [];
+  for (const [i, line] of String(text ?? '').split('\n').entries()) {
+    const f = line.replace(/\r$/, '').split('\t');
+    if (i === 0 && f[0] === 'ts') continue;
+    if (f.length < 6 || !TIERS.includes(f[4]) || !TIERS.includes(f[5])) continue;
+    out.push({ ts: f[0], at: Date.parse(f[0]) || null, agent: f[1], change: f[2], risk: f[3], from: f[4], to: f[5] });
+  }
+  return out;
+}
+
+const keyOf = (r) => `${r.agent}\t${r.change}\t${r.risk}`;
+const firstTry = (r) => r.verify === 'pass' && r.fixes === 0;
+
+/**
+ * The lowering that stands for a raised floor, or null. The rule is hooks/guard-agent-model.sh's (`_am_floor_now`),
+ * word for word: a lowering counts when it is not older than the raise it answers (the times are UTC text and are
+ * compared as text, as the hook does), is from the model the floor was raised to, and goes one model down. Raised
+ * again afterwards, the floor is the raised one. The last line that counts is the one in force.
+ */
+export function loweringOf(floor, loosened = []) {
+  let hit = null;
+  for (const l of loosened) {
+    if (keyOf(l) !== keyOf(floor)) continue;
+    if (String(l.ts) < String(floor.when ?? '')) continue;
+    if (l.from !== floor.model) continue;
+    if (TIERS.indexOf(l.to) < 0 || TIERS.indexOf(l.to) !== TIERS.indexOf(l.from) - 1) continue;
+    hit = { to: l.to, ts: l.ts };
+  }
+  return hit;
+}
+
+/** One line per class, the busiest first. What the class cost is asked apart (`classCosts`): it is read from elsewhere. */
+export function classesOf(rows, floors = [], loosened = []) {
+  const by = new Map();
+  for (const r of rows) {
+    const k = keyOf(r);
+    if (!by.has(k)) {
+      by.set(k, {
+        key: k, agent: r.agent, change: r.change, risk: r.risk, runs: 0, verified: 0, firstTry: 0, fixed: 0, failed: 0, escalated: 0,
+        notVerified: { none: 0, blocked: 0, timeout: 0 }, models: {}, ranOn: {}, lastAt: null, floor: null,
+      });
+    }
+    const c = by.get(k);
+    c.runs += 1;
+    const m = (c.models[r.model ?? 'unknown'] ??= { runs: 0, verified: 0, firstTry: 0 });
+    m.runs += 1;
+    if (r.ranOn) c.ranOn[r.ranOn] = (c.ranOn[r.ranOn] ?? 0) + 1;
+    if (VERIFIED.has(r.verify)) {
+      c.verified += 1; m.verified += 1;
+      if (firstTry(r)) { c.firstTry += 1; m.firstTry += 1; }
+      if (r.verify === 'fail') c.failed += 1;
+      if (r.fixes > 0) c.fixed += 1;
+    } else c.notVerified[r.verify] += 1;
+    if (r.escalatedFrom) c.escalated += 1;
+    if (r.at !== null && (c.lastAt === null || r.at > c.lastAt)) c.lastAt = r.at;
+  }
+  // A floor the user lowered is still on record as raised; what holds now is the lowered one, and both are said.
+  for (const f of floors) { const c = by.get(keyOf(f)); if (c) c.floor = { ...f, lowered: loweringOf(f, loosened) }; }
+  return [...by.values()]
+    // A rate with nothing under it is not zero: with no verified call there is none.
+    .map((c) => ({ ...c, firstTryRate: c.verified ? c.firstTry / c.verified : null }))
+    .sort((a, b) => b.runs - a.runs || a.key.localeCompare(b.key));
+}
+
+/**
+ * What each class's agents come to, where an agent's tokens could be read: { classKey: { cost, costed, runs } }.
+ * `costed` of `runs` were priced; the rest are not in the sum, so the sum is a floor and not the total.
+ * @param costOf  (agentId) => USD or null
+ */
+export function classCosts(rows, costOf) {
+  const out = {};
+  for (const r of rows) {
+    const c = (out[keyOf(r)] ??= { cost: 0, costed: 0, runs: 0 });
+    c.runs += 1;
+    const usd = costOf(r.agentId);
+    if (typeof usd === 'number') { c.cost += usd; c.costed += 1; }
+  }
+  return out;
+}
+
+/**
+ * The holds that could be lowered: a class the record of outcomes holds one model up (a line in
+ * crew-model-floors.auto), whose latest LOOSEN_AFTER verified calls on that model all passed the first time.
+ * Calls made before the user last approved a lowering of that class are not counted, and a hold already lowered
+ * since it was written is not offered again.
+ */
+export function suggestionsOf(rows, floors = [], loosened = [], need = LOOSEN_AFTER) {
+  const out = [];
+  for (const f of floors) {
+    const tier = TIERS.indexOf(f.model);
+    if (tier <= 0) continue;
+    const k = keyOf(f);
+    // Once for each raise: a floor whose lowering stands is not offered again (the same rule the gate reads it by).
+    if (loweringOf(f, loosened)) continue;
+    const since = Date.parse(f.when ?? '') || 0;
+    const recent = rows.filter((r) => keyOf(r) === k && r.model === f.model && VERIFIED.has(r.verify) && (r.at ?? 0) >= since)
+      .sort((a, b) => (b.at ?? 0) - (a.at ?? 0)).slice(0, need);
+    if (recent.length < need || !recent.every(firstTry)) continue;
+    out.push({ key: k, agent: f.agent, change: f.change, risk: f.risk, from: f.model, to: TIERS[tier - 1], passed: recent.length, heldSince: f.when ?? null });
+  }
+  return out;
+}
+
+function readBounded(file) {
+  let st;
+  try { st = fs.statSync(file); } catch { return null; }
+  if (st.size <= MAX_BYTES) return { text: fs.readFileSync(file, 'utf8'), truncated: false, bytes: st.size };
+  const fd = fs.openSync(file, 'r');
+  try {
+    const buf = Buffer.alloc(MAX_BYTES);
+    fs.readSync(fd, buf, 0, MAX_BYTES, st.size - MAX_BYTES);
+    const text = buf.toString('utf8');
+    return { text: text.slice(text.indexOf('\n') + 1), truncated: true, bytes: st.size };
+  } finally { fs.closeSync(fd); }
+}
+
+const sigOf = (file) => { try { const st = fs.statSync(file); return `${st.mtimeMs}:${st.size}`; } catch { return '-'; } };
+const FILES = ['model-outcomes.tsv', 'crew-model-floors.auto', 'crew-model-loosened.tsv'];
+const records = new Map();           // cwd -> { sig, value }
+export const _stats = { parsed: 0 };  // how many times a record was really read: the claims count it
+
+/**
+ * The record of one project, read once and kept until one of its three files changes (its time or its size).
+ * A view that asks every few seconds costs three stats, not a parse.
+ */
+export function readRecord(cwd) {
+  const dir = stateDir(cwd);
+  const sig = FILES.map((f) => sigOf(path.join(dir, f))).join('|');
+  const hit = records.get(cwd);
+  if (hit && hit.sig === sig) return hit.value;
+  const value = parseRecord(dir, cwd);
+  _stats.parsed += 1;
+  if (records.size > 50) records.clear();
+  records.set(cwd, { sig, value });
+  return value;
+}
+
+function parseRecord(dir, cwd) {
+  const record = readBounded(path.join(dir, FILES[0]));
+  if (!record) return { measured: false, reason: 'no .claude/state/model-outcomes.tsv in this project: no crew agent has finished here since model routing was installed', classes: [], suggestions: [], byAgent: {} };
+  const parsed = parseOutcomes(record.text);
+  const floors = parseFloors(readBounded(path.join(dir, FILES[1]))?.text ?? '');
+  const loosened = parseLoosened(readBounded(path.join(dir, FILES[2]))?.text ?? '');
+  const byAgent = {};
+  for (const r of parsed.rows) byAgent[r.agentId] = r;           // a resumed agent's latest line is the one that stands
+  // A card that failed is given again one model up, to another agent: the calls of one card, oldest first, are
+  // the trail the inspector shows under the newest of them.
+  const byCard = new Map();
+  for (const r of parsed.rows) if (r.card) byCard.set(`${r.agent}\t${r.card}`, [...(byCard.get(`${r.agent}\t${r.card}`) ?? []), r]);
+  for (const r of Object.values(byAgent)) {
+    const same = r.card ? (byCard.get(`${r.agent}\t${r.card}`) ?? []) : [];
+    // Earlier in the file, not earlier by the clock: two lines can carry the same second.
+    r.before = same.filter((x) => x.agentId !== r.agentId && x.line < r.line).slice(-TRAIL_MAX)
+      .map(({ agentId, model, verify, fixes, ranOn }) => ({ agentId, model, verify, fixes, ranOn }));
+  }
+  return {
+    measured: true,
+    cwd,
+    rows: parsed.rows.length,
+    dropped: parsed.dropped,
+    droppedWhy: parsed.why,
+    truncated: record.truncated,
+    firstAt: parsed.rows.reduce((m, r) => (m === null || r.at < m ? r.at : m), null),
+    classes: classesOf(parsed.rows, floors, loosened),
+    floors,
+    suggestions: suggestionsOf(parsed.rows, floors, loosened),
+    loosened,
+    byAgent,
+    all: parsed.rows,
+  };
+}
+
+/**
+ * What the Models view and the inspector are sent for one project.
+ * @param agents  the ids of the agents of the session on screen: only their lines are sent. Without it, none are:
+ *                a project's record can hold every agent it ever ran, and a page shows one session's.
+ * @returns measured: false with a reason when the project has no record — which is a project where no crew agent
+ *          has finished since model routing was installed, not a project where every agent failed.
+ */
+export function readModels(cwd, { agents = null } = {}) {
+  const rec = readRecord(cwd);
+  if (!rec.measured) return rec;
+  const byAgent = {};
+  for (const id of agents ?? []) if (Object.hasOwn(rec.byAgent, id)) byAgent[id] = rec.byAgent[id];
+  const { all, byAgent: _every, ...rest } = rec;
+  return { ...rest, byAgent };
+}
+
+/** What the classes of one project cost, from the kept record: see `classCosts`. Null when there is no record. */
+export function readCosts(cwd, costOf) {
+  const rec = readRecord(cwd);
+  return rec.measured ? classCosts(rec.all, costOf) : null;
+}

package/kit/studio/server/lib/palette.js

@@ -4,9 +4,11 @@
 // values below give each of those names one shade, so an agent keeps the same
 // colour in every session the panel draws.
 //
-// An agent type nobody declared gets a neutral grey and a marked flag. Guessing
-// a colour would make an unknown agent look like a known one, which is the
-// visual form of the thing this project refuses to do.
+// The map holds Crewforth's own agents and nothing else: the ones in its own
+// agents directory. There is no list of Claude Code's built-in agent types
+// here. There was one, and it went stale the first time Claude Code added a
+// type: its own "Workflow Subagent" was drawn as "not declared by Claude Code".
+// Whatever is not Crewforth's is a Claude Code agent, whoever defined it.
 
 import fs from 'node:fs';
 import path from 'node:path';
@@ -46,18 +48,6 @@ const NAMED = {
   yellow: '#db5f1c',
 };
 
-// Claude Code's built-in agent types are not kit components and declare
-// nothing, so they take the diagram's "core" tones.
-const BUILTIN = {
-  Explore: '#26c6e6',
-  Plan: '#a874f5',
-  'general-purpose': '#c79bff',
-  claude: '#5b8cff',
-  'code-simplifier': '#84e6b0',
-  'statusline-setup': '#94a3c8',
-  'claude-code-guide': '#8659ee',
-};
-
 const UNKNOWN = '#94a3c8';
 
 let cached = null;
@@ -92,9 +82,6 @@ export function palette() {
   for (const [name, v] of Object.entries(kit ?? {})) {
     map[name] = { hex: v.hex ?? UNKNOWN, declared: v.color, known: Boolean(v.hex), source: 'kit' };
   }
-  for (const [name, hex] of Object.entries(BUILTIN)) {
-    if (!map[name]) map[name] = { hex, declared: null, known: true, source: 'builtin' };
-  }
   cached = {
     map,
     unknown: UNKNOWN,