polymath-society 0.2.20 → 0.2.22

package/dist/pipeline/coding-agglomerate.js

@@ -134,13 +134,13 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-agglomerate.mts
-import { promises as fs8 } from "fs";
-import path12 from "path";
+import { promises as fs9 } from "fs";
+import path13 from "path";
 
 // ../../lib/agents/coding/agglomerate.ts
-import { promises as fs7 } from "fs";
-import os2 from "os";
-import path10 from "path";
+import { promises as fs8 } from "fs";
+import os3 from "os";
+import path11 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -508,6 +508,13 @@ ${report}`);
 }
 
 // ../../lib/agents/shared/codexAdapter.ts
+var CODEX_DEFAULT_MODEL = "gpt-5.5";
+var CODEX_MINI_MODEL = "gpt-5.4-mini";
+function mapCodexTier(model2, env = process.env) {
+  if (model2 && !/^(claude|haiku|sonnet|opus)/i.test(model2)) return model2;
+  if (model2 && /^haiku/i.test(model2)) return env.POLYMATH_CODEX_MODEL_MINI || CODEX_MINI_MODEL;
+  return env.POLYMATH_CODEX_MODEL || CODEX_DEFAULT_MODEL;
+}
 function composePrompt(inv, roots) {
   return [
     inv.systemPrompt ? `<system>
@@ -548,7 +555,7 @@ var codexAdapter = {
       "read-only",
       "--json"
     ];
-    if (inv.model && !/^claude/i.test(inv.model)) args.push("--model", inv.model);
+    args.push("--model", mapCodexTier(inv.model));
     args.push(composePrompt(inv, roots));
     const started = Date.now();
     const toolCalls = [];
@@ -2176,8 +2183,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path14, errorMaps, issueData } = params;
+  const fullPath = [...path14, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2293,11 +2300,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path14, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path14;
     this._key = key;
   }
   get path() {
@@ -15084,39 +15091,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -15137,7 +15144,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path13 }) => `${baseURL}${path13}`,
+      url: ({ path: path14 }) => `${baseURL}${path14}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -15777,19 +15784,20 @@ var GRADED_CRITERIA = CODING_CRITERIA.filter((c) => c.graded);
 var RUBRIC_FINGERPRINT = rubricFingerprint(GRADED_CRITERIA);
 
 // ../../lib/agents/coding/docsDir.ts
-import { promises as fs5 } from "fs";
-import path9 from "path";
+import { promises as fs6 } from "fs";
+import path10 from "path";
 
 // ../../lib/agents/coding/materialize.ts
-import { promises as fs4 } from "fs";
+import { promises as fs5 } from "fs";
 
 // ../coding-core/dist/injected.js
+var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
 function isHarnessEntry(e) {
   return e.isMeta === true || e.isCompactSummary === true;
 }
 
 // ../coding-core/dist/codex.js
-var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var SYSTEM_REMINDER_RE2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
 var CODEX_INJECTED_TEXT_RE = /^\s*(<(environment_context|user_instructions|ENVIRONMENT_CONTEXT|turn_aborted)\b|#\s*AGENTS\.md instructions\b)/;
 function isCodexInjectedUserText(text2) {
   return CODEX_INJECTED_TEXT_RE.test(text2);
@@ -15852,7 +15860,7 @@ function extractCodexEvents(raw) {
     const ptype = p.type;
     if (ptype === "message") {
       const role = p.role;
-      const text2 = codexContentText(p.content).replace(SYSTEM_REMINDER_RE, "").trim();
+      const text2 = codexContentText(p.content).replace(SYSTEM_REMINDER_RE2, "").trim();
       if (!text2)
         continue;
       if (role === "user") {
@@ -15879,8 +15887,288 @@ function extractCodexEvents(raw) {
   return out;
 }
 
+// ../coding-core/dist/cursor.js
+import { promises as fs4 } from "fs";
+var NODE_SQLITE = "node:sqlite";
+async function openCursorSqlite(dbPath) {
+  try {
+    await fs4.access(dbPath);
+  } catch {
+    return null;
+  }
+  let mod;
+  try {
+    mod = await import(NODE_SQLITE);
+  } catch {
+    return null;
+  }
+  const DatabaseSync = mod?.DatabaseSync;
+  if (!DatabaseSync)
+    return null;
+  let db;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+  } catch {
+    try {
+      db = new DatabaseSync(dbPath);
+    } catch {
+      return null;
+    }
+  }
+  const asText = (v) => v == null ? null : typeof v === "string" ? v : Buffer.from(v).toString("utf-8");
+  return {
+    prefix(prefix) {
+      try {
+        const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\'").all(likePrefix(prefix));
+        return rows.map((r) => ({ key: r.key, value: asText(r.value) ?? "" }));
+      } catch {
+        return [];
+      }
+    },
+    get(key) {
+      try {
+        const row = db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(key);
+        return row ? asText(row.value) : null;
+      } catch {
+        return null;
+      }
+    },
+    close() {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  };
+}
+function likePrefix(prefix) {
+  return prefix.replace(/[\\%_]/g, (c) => "\\" + c) + "%";
+}
+var CURSOR_USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+function cleanUserText(raw) {
+  let t = raw.replace(SYSTEM_REMINDER_RE, "");
+  const m = t.match(CURSOR_USER_QUERY_RE);
+  if (m)
+    t = m[1];
+  return t.trim();
+}
+var msFrom = (v) => {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "string") {
+    const n = Date.parse(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+};
+function readCursorComposer(db, composerId) {
+  const cdRaw = db.get(`composerData:${composerId}`);
+  if (!cdRaw)
+    return null;
+  let cd;
+  try {
+    cd = JSON.parse(cdRaw);
+  } catch {
+    return null;
+  }
+  const headers = Array.isArray(cd.fullConversationHeadersOnly) ? cd.fullConversationHeadersOnly : [];
+  if (headers.length === 0)
+    return null;
+  const bubbles = /* @__PURE__ */ new Map();
+  for (const row of db.prefix(`bubbleId:${composerId}:`)) {
+    const bid = row.key.slice(`bubbleId:${composerId}:`.length);
+    try {
+      bubbles.set(bid, JSON.parse(row.value));
+    } catch {
+    }
+  }
+  const turns = [];
+  let clock = msFrom(cd.createdAt) ?? 0;
+  for (const h of headers) {
+    const b = bubbles.get(h.bubbleId);
+    if (!b)
+      continue;
+    const type = h.type === 1 ? 1 : 2;
+    const tool2 = type === 2 && b.toolFormerData && typeof b.toolFormerData.name === "string" ? b.toolFormerData.name : null;
+    const rawText = typeof b.text === "string" ? b.text : "";
+    const text2 = type === 1 ? cleanUserText(rawText) : rawText.replace(SYSTEM_REMINDER_RE, "").trim();
+    if (!text2 && !tool2)
+      continue;
+    const t = msFrom(b.createdAt);
+    clock = Math.max(clock, t ?? clock + 1);
+    const model2 = b.modelInfo && typeof b.modelInfo.modelName === "string" ? b.modelInfo.modelName : null;
+    turns.push({ t: clock, type, text: text2, tool: tool2, model: model2 });
+  }
+  if (turns.length === 0)
+    return null;
+  const gitRepo = Array.isArray(cd.trackedGitRepos) && cd.trackedGitRepos[0] && typeof cd.trackedGitRepos[0].repoPath === "string" ? cd.trackedGitRepos[0].repoPath : null;
+  return {
+    composerId,
+    createdAt: msFrom(cd.createdAt),
+    updatedAt: msFrom(cd.lastUpdatedAt),
+    name: typeof cd.name === "string" && cd.name.trim() ? cd.name.trim() : null,
+    gitRepo,
+    turns
+  };
+}
+function sniffCursorRaw(raw) {
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    try {
+      const e = JSON.parse(line);
+      return (e.role === "user" || e.role === "assistant") && typeof e.message === "object" && e.message !== null && "content" in e.message && !("type" in e);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function jsonlText(content) {
+  const parts = [];
+  const tools = [];
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (!item || typeof item !== "object")
+        continue;
+      const it = item;
+      if (it.type === "text" && it.text)
+        parts.push(it.text);
+      else if (it.type === "tool_use" && it.name)
+        tools.push(it.name);
+    }
+  } else if (typeof content === "string")
+    parts.push(content);
+  return { text: parts.join("\n"), tools };
+}
+function parseCursorJsonl(raw, base) {
+  const turns = [];
+  let clock = base;
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.role !== "user" && e.role !== "assistant")
+      continue;
+    const { text: rawText, tools } = jsonlText(e.message?.content);
+    const type = e.role === "user" ? 1 : 2;
+    const text2 = type === 1 ? cleanUserText(rawText) : rawText.replace(SYSTEM_REMINDER_RE, "").trim();
+    if (type === 2 && tools.length) {
+      for (const tool2 of tools) {
+        clock += 1;
+        turns.push({ t: clock, type: 2, text: "", tool: tool2, model: null });
+      }
+    }
+    if (!text2)
+      continue;
+    clock += 1;
+    turns.push({ t: clock, type, text: text2, tool: null, model: null });
+  }
+  if (turns.length === 0)
+    return null;
+  return { composerId: "", createdAt: base, updatedAt: clock, name: null, gitRepo: null, turns };
+}
+var AI_GIST = 500;
+function renderCursorTranscript(c) {
+  const lines = [];
+  let humanTurns = 0, humanChars = 0;
+  let aiProse = "";
+  const aiTools = /* @__PURE__ */ new Map();
+  const flushAI = () => {
+    if (!aiProse && aiTools.size === 0)
+      return;
+    const tools = [...aiTools.entries()].map(([n, k]) => k > 1 ? `${n}\xD7${k}` : n).join(", ");
+    const gist = aiProse ? aiProse.length > AI_GIST ? aiProse.slice(0, AI_GIST) + "\u2026" : aiProse : "";
+    const bits = [];
+    if (gist)
+      bits.push(gist);
+    if (tools)
+      bits.push(`ran ${tools}`);
+    lines.push(`[AI: ${bits.join(" \xB7 ")}]`);
+    aiProse = "";
+    aiTools.clear();
+  };
+  for (const turn of c.turns) {
+    if (turn.type === 1) {
+      flushAI();
+      humanTurns++;
+      humanChars += turn.text.length;
+      lines.push(`>> ${turn.text}`);
+    } else {
+      if (turn.tool)
+        aiTools.set(turn.tool, (aiTools.get(turn.tool) ?? 0) + 1);
+      if (turn.text)
+        aiProse = turn.text.replace(/\s+/g, " ").trim();
+    }
+  }
+  flushAI();
+  return { text: lines.join("\n"), humanTurns, humanChars };
+}
+function composerIdFromFile(file2) {
+  const m = file2.match(/agent-transcripts\/([^/]+)\/[^/]+\.jsonl$/);
+  return m ? m[1] : null;
+}
+async function loadCursorComposer(file2, raw, dbPath) {
+  const cid = composerIdFromFile(file2);
+  if (cid && dbPath) {
+    const db = await openCursorSqlite(dbPath);
+    if (db) {
+      try {
+        const c = readCursorComposer(db, cid);
+        if (c)
+          return c;
+      } finally {
+        db.close();
+      }
+    }
+  }
+  return parseCursorJsonl(raw, 0);
+}
+
+// ../coding-core/dist/raw.js
+import path9 from "path";
+import os2 from "os";
+var SOURCE_ROOT_ENV_VARS = [
+  "CLAUDE_PROJECTS_DIR",
+  "CODEX_SESSIONS_DIR",
+  "CURSOR_WORKSPACE_DIR",
+  "CURSOR_PROJECTS_DIR",
+  // Cursor's globalStorage dir (holds state.vscdb — the composer bubbles that
+  // carry a Cursor session's real per-turn timestamps + content). Same
+  // isolation contract: overriding any root disables every unset source.
+  "CURSOR_GLOBAL_DIR"
+];
+var anyRootOverridden = () => SOURCE_ROOT_ENV_VARS.some((v) => !!process.env[v]);
+function resolveSourceRoot(envVar, ...defaultSegments) {
+  const explicit = process.env[envVar];
+  if (explicit)
+    return explicit;
+  if (anyRootOverridden())
+    return null;
+  return path9.join(os2.homedir(), ...defaultSegments);
+}
+var cursorGlobalRoot = () => resolveSourceRoot("CURSOR_GLOBAL_DIR", "Library", "Application Support", "Cursor", "User", "globalStorage");
+function cursorGlobalDbPath() {
+  const root = cursorGlobalRoot();
+  return root === null ? null : path9.join(root, "state.vscdb");
+}
+var MACHINE_CURSOR_FILE_RE = /^(.*[/\\]machines[/\\][^/\\]+[/\\]\.cursor)[/\\]projects[/\\]/;
+function cursorDbPathForFile(file2) {
+  const m = file2.match(MACHINE_CURSOR_FILE_RE);
+  if (m)
+    return path9.join(m[1], "globalStorage", "state.vscdb");
+  return cursorGlobalDbPath();
+}
+
 // ../../lib/agents/coding/materialize.ts
-var SYSTEM_REMINDER_RE2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var SYSTEM_REMINDER_RE3 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
 var INJECT_GIST = 120;
 var INJECTED = [
   { re: /<task-notification>[\s\S]*?<\/task-notification>/g, label: "bg task", gistRe: /<summary>([\s\S]*?)<\/summary>/ },
@@ -15900,7 +16188,7 @@ function collapseInjected(input) {
       return "";
     });
   }
-  return { text: text2.replace(SYSTEM_REMINDER_RE2, "").trim(), markers };
+  return { text: text2.replace(SYSTEM_REMINDER_RE3, "").trim(), markers };
 }
 function extractText(content) {
   if (typeof content === "string") return content;
@@ -15916,7 +16204,7 @@ function extractText(content) {
 function isToolResultOnly(content) {
   return Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
 }
-var AI_GIST = 160;
+var AI_GIST2 = 160;
 function materializeCodex(raw) {
   const lines = [];
   let humanTurns = 0, humanChars = 0;
@@ -15925,7 +16213,7 @@ function materializeCodex(raw) {
   const flushAI = () => {
     if (!aiLastProse && aiTools.size === 0) return;
     const tools = [...aiTools.entries()].map(([n, c]) => c > 1 ? `${n}\xD7${c}` : n).join(", ");
-    const gist = aiLastProse ? aiLastProse.length > AI_GIST ? aiLastProse.slice(0, AI_GIST) + "\u2026" : aiLastProse : "";
+    const gist = aiLastProse ? aiLastProse.length > AI_GIST2 ? aiLastProse.slice(0, AI_GIST2) + "\u2026" : aiLastProse : "";
     const bits = [];
     if (gist) bits.push(gist);
     if (tools) bits.push(`ran ${tools}`);
@@ -15949,14 +16237,19 @@ function materializeCodex(raw) {
   flushAI();
   return { text: lines.join("\n"), humanTurns, humanChars };
 }
+async function materializeCursor(file2, raw) {
+  const composer = await loadCursorComposer(file2, raw, cursorDbPathForFile(file2));
+  return composer ? renderCursorTranscript(composer) : { text: "", humanTurns: 0, humanChars: 0 };
+}
 async function materializeSession(file2) {
   let raw;
   try {
-    raw = await fs4.readFile(file2, "utf-8");
+    raw = await fs5.readFile(file2, "utf-8");
   } catch {
     return null;
   }
   if (sniffCodexRaw(raw)) return materializeCodex(raw);
+  if (sniffCursorRaw(raw)) return materializeCursor(file2, raw);
   const lines = [];
   let humanTurns = 0, humanChars = 0;
   const pendingQueued = [];
@@ -15969,7 +16262,7 @@ async function materializeSession(file2) {
   const flushAI = () => {
     if (!aiLastProse && aiTools.size === 0) return;
     const tools = [...aiTools.entries()].map(([n, c]) => c > 1 ? `${n}\xD7${c}` : n).join(", ");
-    const gist = aiLastProse ? aiLastProse.length > AI_GIST ? aiLastProse.slice(0, AI_GIST) + "\u2026" : aiLastProse : "";
+    const gist = aiLastProse ? aiLastProse.length > AI_GIST2 ? aiLastProse.slice(0, AI_GIST2) + "\u2026" : aiLastProse : "";
     const bits = [];
     if (gist) bits.push(gist);
     if (tools) bits.push(`ran ${tools}`);
@@ -16049,10 +16342,10 @@ async function materializeSession(file2) {
 
 // ../../lib/agents/coding/docsDir.ts
 async function writeScoreboard(codingDir, docs) {
-  const gradesDir = path9.join(codingDir, "grades");
+  const gradesDir = path10.join(codingDir, "grades");
   let files = [];
   try {
-    files = (await fs5.readdir(gradesDir)).filter((f) => f.endsWith(".json")).sort();
+    files = (await fs6.readdir(gradesDir)).filter((f) => f.endsWith(".json")).sort();
   } catch {
     return;
   }
@@ -16060,7 +16353,7 @@ async function writeScoreboard(codingDir, docs) {
   for (const f of files) {
     let g;
     try {
-      g = JSON.parse(await fs5.readFile(path9.join(gradesDir, f), "utf8"));
+      g = JSON.parse(await fs6.readFile(path10.join(gradesDir, f), "utf8"));
     } catch {
       continue;
     }
@@ -16076,8 +16369,8 @@ async function writeScoreboard(codingDir, docs) {
     ([key, rows]) => `## ${key}
 ${rows.sort((a, b) => b.s - a.s).map((r) => r.line).join("\n")}`
   );
-  await fs5.writeFile(
-    path9.join(docs, "_scoreboard.md"),
+  await fs6.writeFile(
+    path10.join(docs, "_scoreboard.md"),
     `# Scoreboard \u2014 every graded session per criterion, best first.
 # Lx~ = estimate. Format: level \xB7 date \xB7 title \xB7 sessionId \u2014 graded instance.
 
@@ -16086,24 +16379,24 @@ ${blocks.join("\n\n")}
   );
 }
 async function ensureCodingDocs(codingDir, sessions) {
-  const docs = path9.join(codingDir, "docs");
-  await fs5.mkdir(docs, { recursive: true });
+  const docs = path10.join(codingDir, "docs");
+  await fs6.mkdir(docs, { recursive: true });
   const user = sessions.filter((s) => s.sessionId && !s.duplicateOf && (!("klass" in s) || s.klass === "interactive"));
   let written = 0;
   for (const s of user) {
-    const out = path9.join(docs, `${s.sessionId}.txt`);
+    const out = path10.join(docs, `${s.sessionId}.txt`);
     try {
-      await fs5.access(out);
+      await fs6.access(out);
       continue;
     } catch {
     }
     const mat = await materializeSession(s.file).catch(() => null);
     if (!mat?.text) continue;
-    await fs5.writeFile(out, mat.text);
+    await fs6.writeFile(out, mat.text);
     written++;
   }
   const rows = user.sort((a, b) => (a.start ?? "") < (b.start ?? "") ? -1 : 1).map((s) => `${(s.start ?? "").slice(0, 10)} \xB7 ${(s.title ?? "").replace(/\n.*/s, "").slice(0, 80)} \xB7 ${s.sessionId}`);
-  await fs5.writeFile(path9.join(docs, "_map.md"), rows.join("\n") + "\n");
+  await fs6.writeFile(path10.join(docs, "_map.md"), rows.join("\n") + "\n");
   await writeScoreboard(codingDir, docs);
   if (written) console.log(`[docs] materialized ${written} new transcript(s) \u2192 ${docs}`);
   return docs;
@@ -16116,7 +16409,7 @@ SOURCE LOOKUP \u2014 you have Read/Grep/Glob over the working directory, which h
 
 // ../../lib/agents/coding/promptCache.ts
 import { createHash as createHash2 } from "crypto";
-import { promises as fs6 } from "fs";
+import { promises as fs7 } from "fs";
 function promptSha(parts) {
   const h = createHash2("sha256");
   for (const p of parts) {
@@ -16127,58 +16420,486 @@ function promptSha(parts) {
 }
 async function reusableOutput(outPath, sha, valid, key = "promptSha") {
   try {
-    const o = JSON.parse(await fs6.readFile(outPath, "utf8"));
+    const o = JSON.parse(await fs7.readFile(outPath, "utf8"));
     if (o[key] === sha && valid(o)) return o;
   } catch {
   }
   return null;
 }
 
+// ../../lib/agents/coding/titles.ts
+function cleanSessionTitle(raw) {
+  let s = String(raw ?? "");
+  s = s.replace(/<[a-z][\w-]*(\s[^>]*)?(>|$)/gi, " ");
+  s = s.replace(/\b(name|path|src)=("[^"]*("|$)|\[[^\]]*(\]|$)|\S+)/gi, " ");
+  s = s.replace(/\s+/g, " ").trim().replace(/^[·:;,.\-—\s]+/, "").trim();
+  return s || "untitled session";
+}
+
+// ../../lib/agents/engine/lenses/reasoning.ts
+var reasoningLens = {
+  key: "reasoning",
+  label: "Observed reasoning",
+  intro: "It judges how this person's thinking MOVES in raw, real-time transcripts: their raw reasoning ability, whether they choose the right things to work on, whether they resist their own biases, and how they explain wins and setbacks. Built only from visible moves \u2014 never a claim about IQ.",
+  gateLabel: "CONTENT DIFFICULTY",
+  gateLadder: `  3 \u2014 everyday practical matter (logistics, how-to, routine decisions)
+  5 \u2014 requires holding a multi-part model in mind (a system with interacting parts)
+  7 \u2014 open conceptual question on which informed people genuinely disagree
+  9 \u2014 frontier question without expert consensus
+  11 \u2014 a recognized open problem`,
+  processNote: "COMPRESSION SPEED \u2014 live transcripts show what polished work hides: how directly the person moved from meeting hard material to its underlying principle (turns/steps, not word count). First contact is a bonus signal for raw ability, never required.",
+  selectHint: "Pick conversations where the person is ENGAGING WITH NEW, HARD MATERIAL \u2014 encountering a concept, theory, or domain they are LEARNING (an unfamiliar idea in science, math, philosophy, economics, a technical system) and visibly thinking hard about it: questioning it, building a mental model, pushing back, re-deriving it, synthesizing, catching flaws. Reasoning shows most when someone reasons through the UNFAMILIAR \u2014 not when they execute competently in territory they already own. STRONGLY PREFER conversations where a genuinely hard NEW theory or concept is being grappled with and the person is generating their own ideas about it. DEPRIORITIZE (these look substantial but reveal far less reasoning): long strategy/product/planning threads inside their own domain (that is competence, not the reasoning ceiling), debugging/how-to/logistics, and anything personal/emotional/relational. ON LENGTH: depth usually SHOWS UP as length \u2014 the deeper someone goes into a hard topic, the longer the conversation grows (once it is past just a few messages), so among genuinely deep conversations the longer ones are often the richer. But length is a CORRELATE of depth, not a substitute: a long familiar-territory thread is still competence, while a shorter conversation wrestling hard with a NEW concept beats it. Use length to compare AMONG deep conversations, never to pick a shallow-but-long one. JUDGMENT IS THE EXCEPTION TO THE DEPRIORITIZE: the personal/emotional/relational/high-stakes decisions you would skip for reasoning-horsepower are exactly the PRIME evidence for the Judgment facet \u2014 a hard call made under real emotional, ego, or personal pull (love, conflict, insecurity, a relationship or partner decision, a status threat) is where judgment is most visible. Include those conversations; they are deprioritized only for Capability, never for Judgment.",
+  facets: [
+    {
+      key: "capability",
+      name: "Raw reasoning ability",
+      definition: "Thinking horsepower, all in one: how fast they grasp new material, how high a level of abstraction they operate at, what genuinely new things they generate beyond their inputs, and how reliably they catch flaws and edge cases. The gestalt of how good the thinking is \u2014 graded as a ceiling (the level proven across multiple conversations, not one lucky moment). SYNTHESIS AND NEW IDEAS HAPPEN IN EVERY DOMAIN, not only technical ones, and are often fast: seeing a recurring pattern and naming the real issue behind it then the fix, or thinking through something and landing a genuine new epiphany of one's own \u2014 e.g. realizing the non-obvious variable that actually drives an outcome, or collapsing a messy personal or strategic decision to the single factor that truly discriminates. A real insight counts whether the subject is a theory, a startup, or oneself \u2014 judge the cognitive MOVE (was genuinely new understanding generated and reached independently?), never the topic. Do NOT discount reasoning because a conversation looks emotional, personal, or self-reflective; epiphanies about oneself or one's situation are synthesis too. ASKING a genuinely novel, hard-hitting question is itself FIRST-CLASS generation \u2014 equal to producing an answer or a synthesis, not a lesser thing. A cross-domain or reframing question that opens a problem up counts as a new idea even when no full synthesis follows (e.g. lifting a framework from one field to pose a sharp new question in another); a great question does not need an answer attached to count. (Calibration: one sharp novel question shows the generative instinct \u2014 strong, but not the ceiling on its own; doing this as a DEFAULT MODE, repeatedly cutting to the load-bearing question, is the rung-11 pattern-recognition route.) At the top, judge the WHOLE: whether the person is genuinely exceptional at the core of reasoning \u2014 generating new ideas, seeing the load-bearing thing others miss (the pattern-recognition that unearths non-obvious truths), critiquing and overturning their own, and breaking new ground. Being world-class at ANY ONE of these is enough; the rungs are calibration, not a checklist, and a missing sub-move is not a cap. THE ASSISTANT IS THE PERSON'S INSTRUMENT: how much the AI explains, formalizes, or elaborates around the person's move is IRRELEVANT to the grade \u2014 never discount for 'AI-scaffolded', 'guided', 'co-constructed', 'stays within the AI's frames', or the person's small share of the words. ORIGINATION is the only gate: the objection, mechanism, counterexample, synthesis, or reframing question must START in the person; merely ratifying the AI's suggestion is not origination. And multiple independently-originated top-rung moves in one conversation \u2014 or one such move the person drives into their own synthesis \u2014 reach the ceiling together: never average several strong moves down to the rung of any single one.",
+      rungs: [
+        {
+          level: 2,
+          marker: "Can't get off the ground \u2014 doesn't grasp the concept and bails ('forget it'). No completion, no generation. Example: hits a real tradeoff, says 'too complicated', drops it."
+        },
+        {
+          level: 4,
+          marker: "Gets there with effort \u2014 several passes, maybe a wrong model first, loses the thread of fast multi-step arguments, but perseveres and genuinely arrives (often visible excitement when it clicks). Needing passes because the EXPLANATION was bad \u2014 demanding it be made legible \u2014 is not slow uptake; grade the thinker, not the teacher. Example: misapplies a new concept, course-corrects after pushback, lands it."
+        },
+        {
+          level: 6,
+          marker: "Fluent user \u2014 grasps new concepts and uses them correctly later; applies a known framework cleanly in a domain it didn't come from; names the governing pattern when pointed near it. Example: lifts a pricing framework from another industry and applies it correctly to their own."
+        },
+        {
+          level: 7,
+          marker: "Sharp on hard material \u2014 fast uptake; unprompted, collapses a messy situation to its governing principle; asks problem-finding questions that fit the model, or catches a real counterexample when one is there. Example: cuts a tangled strategy debate to 'only X matters', and it's right."
+        },
+        {
+          level: 9,
+          marker: "Generates and breaks \u2014 collapses hard material to first principles fast; produces genuinely new positions, INCLUDING re-deriving cold a result or objection the field considers hard (counts fully even if it already exists in the literature \u2014 the cognitive act is graded, not its novelty to the world); reliably finds the load-bearing flaw \u2014 fast to WHERE an argument fails, not just that it feels off. Example: walks into a theory cold and reconstructs its strongest published objection from their own pushback."
+        },
+        {
+          level: 10,
+          marker: "Builds a new frame \u2014 invents a framing that reorganizes a hard problem at a high level of abstraction; catches loopholes and edge cases live as the discussion moves; carries the new idea to cases the source never covered. The interlocutor supplying facts or formalism on request never caps this \u2014 the person supplies the moves. Example: splits a muddled concept into two clean axes that survive the standard counterexamples (a position the source didn't contain) and applies it to a new case."
+        },
+        {
+          level: 11,
+          marker: "The full live ceiling, CALIBRATED TO THE MEDIUM \u2014 the most a person can show reasoning out loud on hard material. Reached by ANY of these routes alone (you do NOT need more than one, and you do NOT need every sub-move within a route): (c) DENSITY \u2014 SEVERAL independent rung-10 moves in ONE conversation (distinct originated frames, load-bearing flaw-catches, or cold re-derivations of hard results, each clearing rung 10 on its own) IS the ceiling: a person generating top-rung moves repeatedly in a single sitting is exhibiting ceiling capability even if no single move alone would be an 11. NEVER average multiple top-rung moves down to the rung of the best single one. The gate is strict: each counted move must INDEPENDENTLY clear rung 10 \u2014 any number of rung-7/8 moves never aggregates upward. (a) GENERATIVE + CRITICAL LOOP at full power \u2014 generates a novel frame or synthesis the source didn't contain AND drives it: finds the load-bearing flaw, draws out the uncomfortable consequences, and/or figures out things the material never stated. (b) SUPERHUMAN PATTERN-RECOGNITION / LOAD-BEARING INSIGHT \u2014 as a default mode, repeatedly finds the genuinely novel question or thought that is LOAD-BEARING: cuts straight to the deepest assumption, sees what everyone else missed, unearths a non-obvious truth about the world. This is 11 ON ITS OWN \u2014 even with NO engagement with new material, NO synthesis, and NO self-critique. Being world-class at finding what is load-bearing IS the ceiling. A new CONCEPTUAL frame or insight counts fully; inventing fresh formal/mathematical machinery or a publishable theory is NOT required (a research-paper standard, impossible live). The interlocutor supplying facts, names, notation, or sharper precision never caps it. CO-CONSTRUCTION WITH THE AI IS FINE \u2014 thinking WITH the AI as a partner is the medium, not a deduction. The test is whether genuinely NEW things were SYNTHESIZED in the thread (a new frame, insight, or connection), NOT whether the person reached it alone, 'owned' every step, or could have done it without the AI. Do NOT require solo, AI-free authorship. GRADE THE PEAK, NOT THE WHOLE. This rung is cleared by genuine MOMENTS of brilliance \u2014 a real new synthesis, a load-bearing insight, a novel frame the person reached on hard material. It does NOT require that EVERY move be novel, that the generative loop run at full power for the WHOLE conversation, or that the questions be DRIVEN TO RESOLUTION / closed. A conversation can meander, spend stretches on the ordinary, hand threads back open, and still be an 11 on the strength of a few genuine peak moments. Grade the HIGH-WATER MARK of the thinking, not its average and not whether it was carried to completion. Concretely, NONE of these is a cap: (1) the brilliant move ENDS IN AN OPEN QUESTION \u2014 leaving the deepest tension unresolved is fine; the moment of synthesis already happened, resolution is NOT required. (2) the synthesis RECOMBINES EXISTING / IMPORTED frames (e.g. integration-\u03A6 + Deutsch's universal explainers fused into a new two-axis model of a hard problem). Recombining known ideas into a frame the source didn't contain counts FULLY; 'it leans on an existing frame / isn't from-scratch / isn't invented machinery' is NOT a valid cap (same rule as re-derivation \u2014 the cognitive act is graded, not its novelty to the world). (3) do NOT withhold 11 'on caution' or defer it to cross-corpus tempo ('would move to 11 if it holds across weeks'). If THIS conversation contains the peak moment, score it 11 \u2014 the 'proven across conversations, not one lucky moment' caveat is the AGGREGATOR's job (it reads many conversations), never a reason to cap a genuine single-conversation peak at 10. (4) the synthesis was CO-CONSTRUCTED WITH THE AI, or is written up as a condensed SUMMARY/recap. Neither caps it: do NOT hold at 10 because you 'can't tell whether the person or the AI reached it,' or because the move appears in a summary rather than a live derivation. If genuinely new things were synthesized in the thread, that IS the 11 \u2014 provenance-purity (solo, AI-free) is NOT the bar; new synthesis is. Examples: (a) cold on a hard theory, generates a cleaner framing that survives the standard counterexamples and corners the theory into its most uncomfortable commitment; (b) keeps asking the one question that cracks the problem open or names the load-bearing assumption nobody else saw."
+        }
+      ]
+    },
+    {
+      key: "taste",
+      name: "Taste",
+      definition: "An intuitive AESTHETIC SENSIBILITY \u2014 a feel for what is GOOD / beautiful / elegant and what will RESONATE \u2014 AND the ability to ACT on it without running the experiment. The 'art' side of the mind. THE SPINE IS A GRADIENT: DETECT \u2192 PREDICT \u2192 GENERATE, and the positive, GENERATIVE end is the ceiling. Merely detecting that something is off/cringe is the FLOOR of real taste (~7); predicting what will resonate is higher (8-9); GENERATING the thing that actually lands \u2014 the line, the design, the insight that hits \u2014 is the top (10-11). PRIMARY EVIDENCE is the active, vindicated, LED aesthetic call \u2014 a reaction that ORIGINATES in the person (a flinch, 'this is cringe', 'no \u2014 more like this'), where THEY drive the direction. ORIGINATION GATE: passively ratifying the AI's option ('okay, that looks good') is NOT taste, wherever it would otherwise land \u2014 the signal must be sourced by them, not approved. SOUNDNESS: grade whether the call ACTUALLY lands, NOT whether the AI agreed (the assistant folds out of sycophancy, so its agreement is confounded); an outside observer should be able to tell they were right. A confident call that is BAD taste \u2014 shipping the cringe/shiny/conventional version thinking it's great \u2014 is an ANTI-SIGNAL. GENERIC-CORRECTNESS IS NON-EVIDENCE: 'make it cleaner / more professional' \u2014 anything the AI could have gone either way on \u2014 does not count; the call must be specific and load-bearing. THE BAR / CARE raises the read: refusing the mediocre version, pushing it to be 'more and more good', holding a high standard \u2014 i.e. how hard they push toward the top rung. AFFINITY / DIET is a CORROBORATOR AND A FLOOR, NOT the driver (a deliberate flip from a diet-primary reading): the canon they curate and study (design/craft reading, Jobs/Ive/Hara/Zumthor/Rubin \u2014 check Obsidian), the sophistication of their aesthetic reasoning (naming WHY something resonates or falls flat), and self-reported care \u2014 these RAISE CONFIDENCE and set a baseline when no live calls were sampled, but cannot carry the top alone. MEDIUM IS INCIDENTAL: taste surfaces across registers \u2014 visual/design, product-feel, writing/copy, craft/engineering-elegance, curatorial \u2014 and scores the SAME; judge the substance, not the medium. Independently-verifiable great OUTPUT rarely appears on a chat stage, so its absence is a sampling gap, never a cap. Distinct from Judgment (rightness of a decision under pull), Prioritization (choosing what to pursue), and Capability (raw thinking). Boundary vs Abstraction: if the value is 'it LANDS / it resonates', score it here; if the value is 'it's a non-obvious TRUTH', that is Abstraction \u2014 the same move can be evidence for both, scored on its own dimension.",
+      rungs: [
+        { level: 2, marker: "No discernible taste \u2014 can't tell good from mediocre even when it matters; satisfied with whatever's in front of them; preferences purely conventional / shiny-chasing." },
+        { level: 4, marker: "Emerging \u2014 recognizes good from bad mostly only once it's pointed out; ratifies others' / the AI's calls ('looks good') rather than sourcing them; reaches for the safe, conventional version." },
+        { level: 6, marker: "Real but informal \u2014 a genuine sense of quality: reactions originate in them and they recognize the better option WHEN SHOWN it and iterate toward it, but stay reactive (responding to options, not yet generating the direction)." },
+        { level: 7, marker: "Reliable negative sensor \u2014 UNPROMPTED, detects what's off / cringe / mediocre and is RIGHT, before anyone tests it. Real, originated, vindicated taste \u2014 but a NEGATIVE call: names the problem, does not yet produce the better thing. The floor of the high range." },
+        { level: 8, marker: "Begins to lead \u2014 EITHER predicts a better DIRECTION that is right but partial/modest and drives toward it, OR an exceptionally fine, non-obvious cringe-catch beyond a plain 7 (spots what others wouldn't flag as off). Forward simulation starting, but not yet a clean, fully-landed resonance call." },
+        { level: 9, marker: "Predicts resonance and leads it \u2014 names the BETTER DIRECTION before testing ('this way will land', 'this will make them feel seen') and it's RIGHT; forward simulation of reception, not just the alarm; actively drives collaborators / the AI toward it rather than reacting." },
+        { level: 10, marker: "Generates the resonant thing \u2014 produces the actual artifact / line / design / insight that HITS (not 'this is off' but 'here \u2014 this'), at a fine level of discrimination (good\u2192great, not garbage\u2192gold); names the resonant core others miss; holds a high bar and refuses the mediocre version." },
+        { level: 11, marker: "World-class, as a DEFAULT MODE \u2014 repeatedly generates what resonates and cuts straight to what's great with almost no need to experiment; a curated canon, sophisticated aesthetic thinking, and self-reported care converge (each plays a role, none required alone). Produced great work confirms it when present but is rarely on the chat stage and never required. (Default-mode is a person-level read \u2014 the aggregator's job, not a single conversation.)" }
+      ]
+    },
+    {
+      key: "judgment",
+      name: "Judgment (decision soundness)",
+      definition: "Making the RIGHT call and acting on it \u2014 where 'right' means the choice whose LONG-TERM consequences are best, not the one that feels good now (Naval: judgment is knowing the long-term effects of your decisions and choosing accordingly). Judgment is a DISPOSITION read over MANY decisions, never a verdict on one: the question is which way the person RELIABLY leans \u2014 toward the long arc or the short pull, toward the honest read or the wishful one \u2014 not whether any single call was perfect. Even the soundest people slip; a base rate of avoiding bad calls is the trait, not a highlight reel of brilliant ones. Its SIGNATURE is the COSTLY-BUT-CORRECT call: paying a real short-term price \u2014 emotional, social, ego \u2014 because the person sees the long arc and chooses it anyway. A decision that HURT to make or came out of conflict but was right on the long horizon (e.g. sending a hard, kind message to save a friendship they'd have regretted losing) is TOP-rung judgment, NOT a lapse \u2014 grade the decision on its merits and long-horizon correctness, NEVER on how painful or emotional it was. Conversely, an emotion or OUTCOME that happened TO them (being hurt, not being believed in, a painful event they did not author) is NOT a decision and carries NO penalty. Resisting short-term pull, flattery, and incentive-caused bias (letting what you WANT bend what you CONCLUDE) is core; so is not letting an irrational belief corrupt the METHOD for a high-stakes choice (a partner, what to build). THE STAKES AXIS \u2014 JUDGMENT IS MOST VISIBLE WHERE THE PULL IS STRONGEST: the 'difficulty' that matters for judgment is NOT the intellectual complexity of the topic (that is Capability) but the strength of the emotional / ego / personal STAKES \u2014 insecurity, craving, love, betrayal, conflict, status threat, fear. A 'routine' topic on the content ladder can be the HARDEST judgment test on the stakes ladder; a high-stakes personal/relational decision is PRIME judgment evidence, never low-grade because the subject is not intellectual. A sound call made under MAXIMAL pull is the ceiling; a sound call on a low-stakes matter does not set it, and a slip on a low-stakes passing impulse is not diagnostic. NOT reasoning horsepower (Capability), aesthetic feel (Taste), or where effort is pointed (Prioritization). Boundary \u2014 score the CHOICE here: the accuracy of the underlying READ is Bias resistance, and authoring a decision against external pull overlaps with Self-authorship (agency); do not count one moment across all three. Deliberating, weighing tradeoffs, voicing uncertainty, and taking time are the PROCESS \u2014 never a penalty; and a right call reached by INTUITION or feeling counts exactly as much as one reached by visible calculation \u2014 do not reward shown work or 'caught every edge case' over a heartfelt call that lands right. RULE-BENDING IS NOT A LAPSE \u2014 PRICE THE DOWNSIDE, DON'T POLICE THE RULE: bending norms, conventions, or gatekeeping to get things done \u2014 selling a vision ahead of reality, projecting confidence, stating a deliverable OUTCOME as present-tense ('we have routes into X' when you are confident you will get the candidate in front of X) \u2014 is NOT dishonesty and is often HIGH judgment. 'Fake it till you make it' backed by genuine ability to DELIVER is not a lie; the test is deliverability and bounded, recoverable downside, NOT whether a rule was bent. The ONLY integrity-related ding is a MISPRICED long-arc downside: a claim a counterparty relies on that the person cannot or will not back, where discovery would compound against them \u2014 AND the person doesn't see it or rationalizes past it. A cheap probe with bounded downside, killed fast, is sound judgment even if aggressive. SELF-DIAGNOSED PAST DECISIONS COUNT AS DECISIONS: when the person's own later post-mortem describes a specific past decision failure in their own words (the class: 'I ignored what I already knew about them', 'I decided on far too little signal', 'I let an outside voice outweigh my own better-grounded assessment'), the GRADED OBJECT is that described past decision, weighed at the severity the record supports \u2014 a lapse documented after the fact is decision evidence exactly like one enacted live. Writing the post-mortem does NOT convert the lapse into mere self-awareness: the insight is diagnosis (credit it under growth/self facets), but the decision it describes belongs HERE, as judgment evidence. Do not skip such a described lapse because the conversation's other decisions lean well. Grade which way they reliably lean and where they land on the long arc.",
+      rungs: [
+        { level: 2, marker: "Takes the sweetest or easiest option; chases the short-term payoff with little regard for where it leads." },
+        { level: 4, marker: "Readily rationalizes toward what they want; the comfortable or flattering option keeps winning; misses considerations an honest look would catch." },
+        { level: 6, marker: "Oriented to the right call and resists the obvious temptations, but inconsistent \u2014 a strong incentive or a charged moment can still bend the bigger decisions." },
+        { level: 8, marker: "Usually lands on the right long-term call and resists short-term pull, INCLUDING calls that cost them something; directionally sound as a default, even if a hard call is occasionally read incompletely." },
+        { level: 10, marker: "Reliably right on the long arc, as a default: chooses the long-term-correct thing over the short pull again and again \u2014 INCLUDING the costly-but-correct calls others flinch from \u2014 and acts on it. Reached by EITHER route, neither required: thorough consequence-reasoning that catches the edge cases, OR a sound, vindicated read that lands right even when it was intuitive rather than visibly calculated. A right call reached by feel counts FULLY." },
+        { level: 11, marker: "Holds even on very hard, high-stakes, genuinely difficult calls \u2014 near-impossible to manipulate, judgment you would TRUST to get the outcome when it is hardest and costliest; the long-term-right choice stays the default even under real personal pressure." }
+      ]
+    },
+    {
+      key: "prioritization",
+      name: "Outcome-orientedness / prioritization",
+      definition: "Pointing effort where it actually moves the outcome: picking the load-bearing problem, the highest-leverage move, knowing what to ignore, deciding what to bet on. Tightly linked to ambition. Distinct from Judgment (rightness of a choice under pull), Taste (aesthetic feel), and Capability (raw thinking). Graded by where they sit on the spectrum \u2014 it NEVER requires a particular signature (e.g. explicit 'leverage / opportunity-cost / one-way-door' talk, or cheap empirical tests); sound prioritization that lands on the genuinely important thing counts however it is reasoned. (Choosing to build a new meaning system for the post-AGI world, say, is a high-prioritization move \u2014 picking a load-bearing problem at scale.) This is the facet where disproportionate effort on a LOW-leverage question (e.g. circling 'did I give too much away') is a legitimate ding \u2014 never penalize deliberation itself here, only effort aimed at the wrong thing.",
+      rungs: [
+        { level: 2, marker: "Effort goes wherever \u2014 no sense of what matters; works on whatever is in front of them." },
+        { level: 4, marker: "Mis-aimed \u2014 pulled toward the shiny or easy; overbuilds the wrong thing; identifies what matters mostly only when told." },
+        { level: 6, marker: "Aimed \u2014 identifies what actually matters for the outcome and works on it; prioritization still informal, and can sink real time into low-leverage questions." },
+        { level: 8, marker: "Ruthless within the problem: given a goal or task, cuts to the biggest bottleneck / highest-leverage move and discards the rest. A sharp prioritizer on the choices in front of them." },
+        { level: 10, marker: "Reliably right across the field, as a default: not just the lever inside one problem but which bets/goals to pursue at all among many messy options \u2014 their sense of what matters is consistently well-aimed without having to be told." },
+        { level: 11, marker: "Exceptional prioritization \u2014 originates the high-leverage bet others don't even look at (defines the bet, doesn't just pick from the menu), on problems at the largest scale, and the choices reliably convert into outsized outcomes." }
+      ]
+    },
+    {
+      key: "bias",
+      name: "Bias resistance",
+      definition: "How well they resist their own cognitive biases \u2014 whether what they believe stays honest. What happens to a held belief when counterevidence arrives, and whether they hunt for the ways they're wrong or defend their ego. Graded on MOVES (belief movement, concessions, self-generated objections), never on polite words. The high rungs require high stakes \u2014 conceding on things you don't care about proves nothing (see egoStakes).",
+      rungs: [
+        {
+          level: 2,
+          marker: "Facts can't get in \u2014 could be given all the facts perfectly and still rejects them and calls the person an idiot; treats one counterexample as demolishing a whole thesis; puts down capable people when their success threatens self-image."
+        },
+        {
+          level: 4,
+          marker: "Considers it, then skews back \u2014 restates the original position unchanged; the comfortable/wishful estimate keeps winning. Includes performed open-mindedness ('interesting, I'll think about it') with no actual movement, ever."
+        },
+        { level: 5, marker: "Honest stubbornness \u2014 admits they can't counter the argument ('I don't have an answer, but I still think X') and holds the prior WITHOUT confabulating a fake rebuttal." },
+        { level: 6, marker: "Genuinely updates when beaten \u2014 visible concessions ('you're right, I had that wrong') and real belief movement." },
+        { level: 8, marker: "Proactively stress-tests their own position \u2014 generates objections before anyone else does, premortems their own plans, asks what would prove them wrong." },
+        { level: 10, marker: "Habitually hunts disconfirmation \u2014 once they form an argument, they attack it from every angle and deliberately look for data that proves them wrong." },
+        {
+          level: 11,
+          marker: "Does it on identity-loaded beliefs \u2014 their own project, their own ability, the things it hurts to be wrong about \u2014 and visibly acts on what it turns up."
+        }
+      ]
+    },
+    {
+      key: "outlook",
+      name: "Optimism / energy",
+      definition: "How they explain what has already happened, especially setbacks, and whether that explanation keeps them generative \u2014 the lean of their causal stories (temporary\u2194permanent, specific\u2194pervasive, fixable\u2194personal-flaw) and whether it fuels or drains forward energy. The average across many explanations is the trait, never the best day. Only explanations of things that mattered to them count. Owns the PAST; mood is OCEAN's, forecasts are 'choosing the right thing / taste'.",
+      rungs: [
+        {
+          level: 2,
+          marker: "Doom \u2014 bad events are permanent, everywhere, and their own fault ('I always ruin this', 'everything's like this'); good events are luck. The profile that predicts quitting."
+        },
+        { level: 4, marker: "Pessimistic lean \u2014 setbacks usually read as stable and global; wins get discounted." },
+        { level: 6, marker: "Realistic \u2014 explanations track the evidence; no systematic doom, no systematic rescue." },
+        { level: 8, marker: "Optimistic style \u2014 setbacks explained as temporary, specific, actionable ('that channel didn't work, this variable was off'); wins partly own-doing. The persistence profile." },
+        { level: 10, marker: "Markedly optimistic-generative as a DEFAULT \u2014 sits high on the optimism spectrum: setbacks reliably read as temporary/specific/actionable and the energy stays forward across the board. Reached by EITHER route, neither required: (a) sustained high optimism on its own (you do NOT need to see a genuinely bad stretch \u2014 purely very optimistic, consistently, is enough), OR (b) energizing under fire \u2014 mid a bad stretch, turns immediately to causes and next moves." },
+        { level: 11, marker: "The top of the spectrum \u2014 exceptional, durable optimistic energy that is also CALIBRATED: the optimistic explanations check out against evidence (bias resistance stays high alongside, so it's conviction not delusion), and/or it visibly energizes under genuine fire." }
+      ]
+    }
+  ],
+  references: []
+};
+
+// ../../lib/agents/engine/lenses/agency.ts
+var agencyLens = {
+  key: "agency",
+  label: "Agency",
+  intro: "It judges this person's self-directed power to act on the world, from visible MOVES in raw transcripts: who sets the goals they pursue, how big an irreversible bet fear actually permits (relative to what they have), whether they self-start and persist past barriers, and how fast deciding becomes doing. Words about boldness are not boldness; only executed moves climb the high rungs.",
+  gateLabel: "STAKES",
+  gateLadder: `  3 \u2014 routine, fully reversible choice; nothing meaningful at risk
+  5 \u2014 costs real time or money but recoverable; mild social exposure
+  7 \u2014 irreversible or socially risky for THIS person: public commitment, cold outreach to strangers, a meaningful slice of their savings or standing
+  9 \u2014 a major fraction of their available resources, reputation, or optionality on the line
+  11 \u2014 bet-the-runway scale for them, taken against unanimous discouragement
+JUDGE STAKES RELATIVE TO THE PERSON'S VISIBLE CAPACITY \u2014 the excerpt reveals their scale (someone agonizing over a $200 spend or a first cold email is telling you their scale; someone casually approving a contractor invoice is telling you theirs).`,
+  processNote: "LATENCY & FOLLOW-THROUGH \u2014 transcripts show what narratives hide: note the gap between deciding and doing (timestamps, turns), and whether stated intentions later appear as completed actions. 'Said it Monday, did it Monday' is a move; 'planned for weeks, never sent' is also a move.",
+  selectHint: "Pick conversations where the person is DECIDING or ACTING on something with REAL STAKES \u2014 making a bold or risky move, choosing their own direction against the grain or against advice, committing to something big, quitting/starting/betting, or pushing through a hard barrier. Agency shows in high-stakes action and self-authorship, not in abstract discussion. STRONGLY PREFER moments of genuine consequence (money, reputation, a major life or company decision on the line). DEPRIORITIZE pure ideation, learning, or analysis with nothing at stake, and routine logistics. Length helps only as a side effect of a real, worked-through decision \u2014 never pick on length alone.",
+  facets: [
+    {
+      key: "frame-scope",
+      name: "Self-authorship",
+      definition: "Whose goals are they actually chasing \u2014 handed to them, or authored by them? From executing someone else's spec, up through running their own life on first principles, to world-scale aims. Graded from which frame the episode shows them operating in and whether they question the frame itself ('should I even be doing this?'). Distinct from Initiative (self-STARTING action) \u2014 this is about whose goals.",
+      rungs: [
+        {
+          level: 3,
+          marker: "Executes only what they're told at the current job/role; does not think and synthesize on their own; does not simulate how people would actually react to the thing they're building; implements the spec but not the extra mile where some thought would have shown a much better option existed; people have to repeatedly tell them to do this and that."
+        },
+        {
+          level: 5,
+          marker: "The optimizer \u2014 puts real effort into the job, learns, does tasks without consistent oversight, gets outcomes, has ownership over the work. But they are optimizing to be really good at a task someone else decided; the guardrails were set by other people and never questioned. (If they chose the frame deliberately, with eyes open \u2014 a considered bet on a job or degree \u2014 that ranks a notch above defaulting into it.)"
+        },
+        {
+          level: 7,
+          marker: "The explorer \u2014 building things on their own, doing things outside the norm of what's necessary for them, because they're interested or want to explore. Hasn't taken the leap to committing to something world-scale."
+        },
+        {
+          level: 9,
+          marker: "Self-authored, with some hedging \u2014 runs major life and work choices from first principles, including what to work on; contrarian, off the default path \u2014 but at moderate intensity, not yet all-in (still partly tethered to what's safe or expected)."
+        },
+        {
+          level: 10,
+          marker: "Self-authored at full conviction \u2014 runs their whole life from first principles, including what to work on, at high intensity and urgency; thoroughly contrarian; does what they want and never lets conformism or 'this won't work' stop them. Same move as 9, lived all the way."
+        },
+        {
+          level: 11,
+          marker: "Aims really high, off the consensus path \u2014 world-scale goals chosen against the standard playbook. Offered the safe, legible version of their ambition (the vertical-SaaS-shaped choice), they turn it down. The goal stays up when every credible voice says it's bad."
+        }
+      ]
+    },
+    {
+      key: "fear-gate",
+      name: "Risk taking",
+      definition: "How much FEAR is allowed to block or delay an irreversible, scary move \u2014 judged by DECISIVENESS, not by the dollar size of the bet. The real tell is the AGONIZING: do they stall, deliberate endlessly, and flinch from the scary irreversible thing \u2014 or do they just DO it? The currency is whatever they fear losing (money, reputation, optionality, rejection) RELATIVE to their own capacity: a broke student risking their whole runway and a funded founder making a six-figure bet sit on the SAME rung if the fear is the same. Stakes/money size is at most a weak proxy \u2014 NEVER score on the amount; score on whether fear gated or delayed the move. (Defiance of consensus scores HERE; how they PROCESSED the consensus they defied scores under bias resistance.)",
+      rungs: [
+        { level: 3, marker: "Fear closes the option space \u2014 the scary irreversible move is never conceived, or never survives to a plan ('not something people like me do' operates silently)." },
+        { level: 5, marker: "Agonizes and stalls \u2014 concrete scary plans form (researched, costed, sometimes scheduled) and the last step never happens; fear holds the door even once the plan is ready." },
+        { level: 7, marker: "Does the scary thing at the edge of comfort, but only after heavy agonizing/delay \u2014 the irreversible move eventually happens with a lot of hand-wringing; it is not their default and it visibly costs them." },
+        { level: 9, marker: "Often just does it \u2014 executes irreversible, scary moves with little agonizing on the things that grip them; deliberation is short and action follows; the very scariest tier still occasionally stalls." },
+        { level: 10, marker: "Decisive on irreversible risk as a DEFAULT \u2014 when the right scary move is clear they just do it, fast and repeatedly, with minimal agonizing; fear rarely gates or delays. Only the single scariest tier may still give brief pause." },
+        { level: 11, marker: "Fear gates essentially nothing \u2014 they execute the scariest irreversible moves decisively and repeatedly, before any guarantee, sustained even against unanimous discouragement with real downside live. Thinking happens but never delays the action. The tell is the ABSENCE of agonizing where almost anyone else would freeze: they just do the thing." }
+      ]
+    },
+    {
+      key: "ambition",
+      name: "Ambition",
+      definition: "What they WANT to pursue \u2014 the lens through which they see the world, not the pursuit itself (acting on the want scores under frame-scope, fear-gate, and initiative; a big-wanting non-actor is ambition 10 / fear-gate 3, and that profile is the point). THE AXIS IS THE REACH OF THE WANT: what has to be true of a future for it to count as worth wanting \u2014 personal safety \u2192 the work itself \u2192 their own days \u2192 the world \u2192 authored legacy \u2192 counterfactual history. Graded from the REVEALED lens, not declarations: how they evaluate options, what they dismiss as too small, which futures keep recurring when they think out loud. One grand statement is nothing; the same evaluative lens across many episodes is the trait. Two cautions: (1) DEEP HUMAN CONNECTION NEVER LOWERS AMBITION \u2014 someone who is empathetic and deeply connected AND ambitious is, if anything, a stronger profile; never deduct for caring about people, friends, or love. (2) The civilization / large-scale frame need NOT be explicit \u2014 infer the reach from what consistently drives them across the corpus, not from explicit 'change the world' declarations; the absence of grand civilizational talk is not evidence of small ambition.",
+      rungs: [
+        {
+          level: 2,
+          marker: "Safety only \u2014 they'll do what they get, as long as it gives them stability; work is purely instrumental and whether it's done well is irrelevant to them. The want stops at themselves-as-safe."
+        },
+        {
+          level: 4,
+          marker: "Safety, plus the work should be GOOD \u2014 still takes what they get, horizon unchanged, but a real want attaches to the work itself: pride, standards, caring about being good at it. The first reach of wanting beyond self-preservation. (Grades the CARING, revealed in how they talk about work \u2014 whether the work actually is good scores under caliber/conscientiousness.)"
+        },
+        { level: 5, marker: "Their own days \u2014 they want to enjoy doing what they want; it doesn't much matter what it's working towards. The want directs life choices, but its object is their own experience." },
+        { level: 7, marker: "Good work for the world \u2014 real impact matters to them, but within structures other people own; their own thing isn't the requirement." },
+        { level: 8, marker: "Their own thing + generational wealth \u2014 ownership is the requirement; the future they want has their name on it and changes their family's trajectory." },
+        { level: 9, marker: "Reshape a whole industry or field \u2014 wants to change how a whole domain works, huge but bounded; the win is being the one who reshaped it." },
+        { level: 10, marker: "Reshape how many people live \u2014 impact at the scale of an institution or a way-of-doing-things for a large population; their own dent in the world, beyond a single industry." },
+        {
+          level: 11,
+          marker: "Civilization-scale ambition \u2014 the lens admits almost nothing smaller; smaller futures feel viscerally not-enough. ONE OPTIONAL flavor (NOT required \u2014 do NOT index hard on it) is wanting specifically the things that would not happen without them ('is this big enough, and would it happen anyway?'). Plenty of people with civilization-scale ambition never think in counterfactual-impact terms; grade the REACH and intensity of the want, never whether they frame it as 'only I could do this.'"
+        }
+      ]
+    },
+    {
+      key: "initiative",
+      name: "Bias to action",
+      definition: "The gap between wanting and doing \u2014 do they self-start, with urgency, and follow through, without being told? The one thing the other agency facets don't catch: self-authorship is whose goals, ambition is what they want, risk-taking is how big a bet, barriers is what happens after a block \u2014 this is whether they actually MOVE. (Grounded in Frese's Personal Initiative construct \u2014 self-starting, proactive, follow-through.)",
+      rungs: [
+        { level: 2, marker: "Doesn't start \u2014 intentions don't become action; 'I should do X' recurs without X ever happening; waits to be told and waits to be unblocked." },
+        { level: 4, marker: "Acts only when pushed or when it's easy \u2014 does what's asked and follows through on low-friction things, but stalls on anything that requires initiating from cold; long lag between deciding and doing." },
+        { level: 6, marker: "Self-starts on what matters \u2014 turns intentions into action without being told, reasonable urgency, follows through on most of what they commit to; does a bit more than asked." },
+        { level: 9, marker: "Acts fast and unprompted SOMETIMES \u2014 near-zero lag between decision and action on the things that grip them, but not yet across the board." },
+        { level: 10, marker: "Bias to action is their DEFAULT \u2014 decisions become action almost immediately, across the board, as how they operate; the intention-action gap is consistently tiny." },
+        { level: 11, marker: "Exceptional urgency \u2014 thinking never delays action; operates at maximum speed, ships and reaches out relentlessly, essentially no gap between deciding and doing." }
+      ]
+    },
+    {
+      key: "barriers",
+      name: "Barrier persistence",
+      definition: "What happens after a block, judged on the SEQUENCE of moves (not the mood). Track THREE things together: (1) ROUTE GENERATION \u2014 how many distinct, high-leverage ways past the block they generate, with how little delay; (2) MORALE RESILIENCE \u2014 do they keep going when punched in the face, when they feel low-status, when others don't respect them, and is their drive independent of that status; (3) COMMITMENT TO THE GOAL \u2014 they route around as long as the final mission still seems possible. A confessed doubt ('should I give up?', 'I'm cooked', 'my brain is in a rut') is corroborating color, NOT a cap: if any route follows it \u2014 here or later \u2014 score the routes and let the doubt pass. A doubt lowers the score ONLY when it is the TERMINUS (no route follows and the effort ends). Score the sequence, never the feeling.",
+      rungs: [
+        { level: 3, marker: "The first obstacle ends the attempt, or they wait for someone else to unblock them \u2014 or they give up without enough reason to give up." },
+        { level: 5, marker: "Retries the same approach harder, escalates politely, then stalls; a dip in morale ends the effort." },
+        { level: 7, marker: "Generates a second and third genuinely distinct route past the block; keeps going on what matters, though not relentlessly across the board." },
+        { level: 9, marker: "Routes around the blocks that matter as a near-default \u2014 finds the side door and keeps the final goal alive; mostly holds morale, occasionally still stalls on lesser blocks." },
+        { level: 10, marker: "An idea-machine that keeps finding alternate ways to the SAME mission \u2014 DOES lose morale under hard hits, but bounces back EVERY time and keeps going; being punched / disrespected / made to feel low-status stings but does not stop them. Always recovering despite morale dips is the realistic HUMAN ceiling here \u2014 it brushes 11; do not treat the dips themselves as a knock." },
+        { level: 11, marker: "Never loses morale (a near-superhuman bar \u2014 almost no one truly never dips, so reserve 11 for genuinely no morale loss) \u2014 picks themselves up immediately and acts; exhausts the methods and goes for the highest-leverage ones with very little delay; routes around any block as long as the final goal still seems possible; a relentless idea-machine generating many fresh ways to the same mission; keeps going when punched in the face and when they feel low-status, with drive that is independent of how others respect them." }
+      ]
+    }
+  ],
+  references: []
+};
+
 // ../../lib/agents/coding/agglomerate.ts
+var AXIS_SOURCES = {
+  judgement: ["generative"],
+  agency: ["outcomes", "caliber"],
+  taste: ["taste"],
+  // Owner call 2026-07-21: the qualitatives mirror the chat report's breadth —
+  // every construct with real graded volume gets a card. Delegation places on
+  // its OWN criteria.ts rungs (coding-native ladder).
+  delegation: ["delegation"]
+};
 var LABEL = new Map(GRADED_CRITERIA.map((c) => [c.key, c.label]));
-function renderTakes(grades) {
+var eff = (t) => t.score ?? t.best ?? 0;
+var oneLine = (s, n) => (s || "").replace(/\s+/g, " ").trim().slice(0, n);
+function takesFor(grades, keys) {
+  const out = [];
+  for (const g of grades) {
+    for (const key of keys) {
+      const c = g.criteria.find((x) => x.key === key);
+      if (!c || c.score == null && c.bestEstimate == null) continue;
+      out.push({
+        sessionId: g.sessionId,
+        title: cleanSessionTitle(g.title) || g.sessionId,
+        date: g.date || "",
+        score: typeof c.score === "number" ? c.score : null,
+        best: typeof c.bestEstimate === "number" ? c.bestEstimate : null,
+        instance: c.instance || "",
+        why: c.why || "",
+        quotes: c.quotes || []
+      });
+    }
+  }
+  return out.sort((a, b) => eff(b) - eff(a));
+}
+function axisStatsLine(takes, nGraded) {
+  const exercised = takes.filter((t) => t.score != null || t.best != null);
+  const sessions = new Set(exercised.map((t) => t.sessionId)).size;
+  const dist = exercised.map(eff).sort((a, b) => b - a).join(", ") || "none";
+  return `${sessions} of ${nGraded} graded sessions exercised this (score-or-null grading: the rest had no opportunity, not lows) \xB7 scores high to low: ${dist}`;
+}
+function qualifyingTakes(takes) {
+  const scored = takes.filter((t) => typeof t.score === "number");
+  if (!scored.length) return { scored: 0, qualifying: 0, peak: null };
+  const sorted = [...scored].sort((a, b) => b.score - a.score);
+  const peak = sorted[0];
+  const qualifying = sorted.filter((t) => t.score >= Math.max(8, peak.score - 1)).length;
+  return { scored: scored.length, qualifying, peak };
+}
+var K_PEAKS = 8;
+var K_FLOORS = 3;
+function takeEntry(t) {
+  const est = t.score == null ? "~" : "";
+  const quotes = (t.quotes || []).slice(0, 2).map((q) => `
+  > "${oneLine(q, 300)}"`).join("");
+  return `- [L${eff(t)}${est} \xB7 "${oneLine(t.title, 60)}" \xB7 ${(t.date || "?").slice(0, 10)} \xB7 session ${t.sessionId}] ${oneLine(t.instance, 400)}${t.why ? `
+  WHY: ${oneLine(t.why, 700)}` : ""}${quotes}`;
+}
+function renderDossier(grades) {
+  const n = grades.length;
   const blocks = [];
   for (const c of GRADED_CRITERIA) {
-    const rows = [];
-    for (const g of grades) {
-      const t = g.criteria.find((x) => x.key === c.key);
-      if (!t || t.score == null && t.bestEstimate == null) continue;
-      const s = t.score != null ? `L${t.score}` : `~L${t.bestEstimate}`;
-      const q = t.quotes[0] ? ` | quote: "${t.quotes[0].slice(0, 180)}"` : "";
-      rows.push(`  - [${s}] ${(g.title || g.sessionId).replace(/\n.*/, "").slice(0, 50)} (${(g.date || "").slice(0, 10)}): ${t.instance}${t.why ? ` \u2014 ${t.why.slice(0, 240)}` : ""}${q}`);
+    const takes = takesFor(grades, [c.key]);
+    if (!takes.length) continue;
+    const peaks = takes.slice(0, K_PEAKS);
+    const floors = takes.slice(K_PEAKS).filter((t) => t.score != null).slice(-K_FLOORS);
+    let block = `### ${c.label} (${c.key})
+STATS: ${axisStatsLine(takes, n)}
+PEAKS \u2014 the top ${peaks.length} take(s), in full:
+${peaks.map(takeEntry).join("\n")}`;
+    if (floors.length) block += `
+FLOORS \u2014 the bottom ${floors.length} scored take(s) (the ceiling tests):
+${floors.map(takeEntry).join("\n")}`;
+    blocks.push(block);
+  }
+  return blocks.join("\n\n");
+}
+var SYSTEM = "You synthesize how a person works across many of their coding-agent sessions. You are given the per-session findings (already graded, with the user's verbatim quotes), pre-digested by code into per-criterion stats, peaks, and floors. Your job is INSIGHT and honest VERDICTS: find the patterns, the signature moves, and the honest gaps, then place each display axis with a best + range + conditions \u2014 never a bare point score on thin evidence. Ground every claim in the evidence given; never invent. Most people are mostly hand-holding the model \u2014 say so plainly when the evidence is thin. Thin evidence cuts both ways: the truth can sit below the peak as easily as above it. Write tight, specific prose; no flattery, no filler; no em dashes in any user-facing line.";
+var AXIS_LADDER_FACETS = {
+  judgement: { lens: reasoningLens, keys: ["judgment"] },
+  agency: { lens: agencyLens, keys: ["frame-scope", "initiative", "barriers"] },
+  taste: { lens: reasoningLens, keys: ["taste"] },
+  // Coding-native construct: the ladder is the criterion's own rung set from
+  // criteria.ts (the same rungs the per-session grader placed the takes on).
+  delegation: { criterion: "delegation" }
+};
+function axisLadders() {
+  const blocks = [];
+  for (const axis of Object.keys(AXIS_LADDER_FACETS)) {
+    const { lens, keys, criterion } = AXIS_LADDER_FACETS[axis];
+    if (criterion) {
+      const c = GRADED_CRITERIA.find((x) => x.key === criterion);
+      if (!c?.rungs?.length) throw new Error(`axis ladder missing: ${axis}/${criterion} \u2014 criteria.ts changed shape?`);
+      blocks.push(`### ${axis} ladder \u2014 ${c.label}
+${c.rungs.map((r) => `  L${r.level} \u2014 ${r.marker}`).join("\n")}`);
+      continue;
+    }
+    for (const key of keys ?? []) {
+      const f = lens?.facets.find((x) => x.key === key);
+      if (!f?.rungs?.length) throw new Error(`axis ladder missing: ${axis}/${key} \u2014 engine lens changed shape?`);
+      blocks.push(`### ${axis} ladder \u2014 ${f.name}
+${f.rungs.map((r) => `  L${r.level} \u2014 ${r.marker}`).join("\n")}`);
     }
-    if (rows.length) blocks.push(`### ${c.label} (${c.key})
-${rows.join("\n")}`);
   }
   return blocks.join("\n\n");
 }
-var SYSTEM = "You synthesize how a person works across many of their coding-agent sessions. You are given the per-session findings (already graded, with the user's verbatim quotes). Your job is INSIGHT, not scoring: find the patterns, the signature moves, and the honest gaps. Ground every claim in the evidence given; never invent. Most people are mostly hand-holding the model \u2014 say so plainly when the evidence is thin. Write tight, specific prose; no flattery, no filler.";
 function buildPrompt(grades) {
-  return `Below are the per-session findings for ONE person across ${grades.length} of their Claude Code sessions, grouped by criterion. Each line is one session's distilled finding for that criterion (level in brackets, then what it showed, then a verbatim quote of the user's own words).
+  const n = grades.length;
+  const axisStats = Object.keys(AXIS_SOURCES).map((axis) => `- ${axis} (from ${AXIS_SOURCES[axis].join(" + ")}): ${axisStatsLine(takesFor(grades, AXIS_SOURCES[axis]), n)}`).join("\n");
+  return `Below are the per-session findings for ONE person across ${n} of their coding-agent sessions, grouped by criterion. For each criterion you get STATS (how many of the graded sessions exercised it, and the full score distribution high to low), the PEAKS (the top takes in full: the instance, the grader's why, verbatim quotes of the user's own words), and the FLOORS (the bottom scored takes \u2014 the ceiling tests), when they exist.
 
-${renderTakes(grades)}
+${renderDossier(grades)}
 
-Per-session scores are capped at 10. YOU are the aggregator that can promote a criterion to 11 \u2014 but ONLY when the corpus shows enough CONSISTENCY or a genuine sustained peak (taste/expertise/delegation/metacognition consistency across many sessions; abstraction peaks that out-reason the tool more than once; outcomes stacked across a day). Say so explicitly when an 11 is warranted, and refuse it when the evidence is one good session.
+Per-session scores are capped at 10; the person-type ladders below run to 11. YOU are the aggregator: your verdicts place the PERSON on those ladders from the whole record, which is a different judgment than any single session's grade.
 
 Synthesize across ALL of it:
 1. "overall" \u2014 2\u20133 tight paragraphs: how this person actually works in their coding agents. What's genuinely strong, what's routine, where the real signal is vs. where it's just scaffolding the model. Be specific and honest. Preface any absent dimension gently ("we haven't seen evidence yet \u2014 very possibly the work just hasn't called for it"), never as a deficit.
 2. "signatureMoves" \u2014 the 3\u20136 single most telling moments (the SPIKES/FLARES) across EVERY session (a sharp override, a real taste call, an out-reasons-the-tool insight, a system-design move). Each: what it was, which session, and the verbatim quote.
 3. "criteria" \u2014 for each criterion present above: a one-line "headline" and a 2\u20134 sentence "insight" describing the PATTERN across sessions; state whether the aggregate merits an 11 and why/why-not. For "frontier", END the insight with a concrete LEVEL-UP LIST \u2014 the specific frontier techniques (loops, workflow orchestration, scheduled cloud agents, broader MCP, queue-ahead) they're NOT yet using. Only include criteria that have evidence.
+4. "verdicts" \u2014 the person-level verdict for each of the FOUR DISPLAY AXES the report renders. Each axis draws ONLY on its own criteria's takes:
+   \u2022 "judgement" \u2190 the Abstraction (generative) takes.
+   \u2022 "agency" \u2190 the Outcomes takes PLUS the Caliber takes. Caliber's autonomy half \u2014 originating the hard thing and unblocking their own path, never needing rescue \u2014 is agency evidence; so is shipping verified outcomes.
+   \u2022 "taste" \u2190 the Taste takes.
+   \u2022 "delegation" \u2190 the Delegation takes (when to hold the leash vs let the AI run, front-loading vs correction rounds).
+   NEVER borrow evidence across axes: a receipt that earned one criterion its score cannot also earn another axis's verdict. If an axis's own takes are empty, its verdict is null \u2014 never fill the hole from a neighboring criterion.
+
+   SHARED VERDICT LAWS (these override any instinct to be generous):
+   \u2022 A RUNG IS A CEILING, NOT AN AVERAGE \u2014 BUT A CEILING MUST BE EARNED. The best few genuine demonstrations set the level; routine stretches never drag it down. A level is earned by a few clear demonstrations that the person CAN operate at that altitude \u2014 more than a single lucky one-off, but never a requirement to sustain it throughout. A level seen ONCE is a PROVISIONAL PEAK, not a proven level: one brilliant moment proves the altitude is reachable, not that it is where they live \u2014 report it as best + an honestly wide range. AWARD THE RUNG THE EVIDENCE MATCHES \u2014 never deny a level for lacking the NEXT level's criteria, and never withhold the top on caution; SEVERAL independent demonstrations at a level SETTLE that level (density is ceiling behavior) \u2014 never average strong takes down below the rung they prove, and never promote above the demonstrated rung on density alone.
+   \u2022 PLACEMENT BY PERSON-TYPE LADDER (how "best" is decided). Build a MENTAL MODEL of the person from the whole record \u2014 stats, peaks, floors, base rates \u2014 then place them on the axis's LADDER below: "best" is the rung whose PERSON-TYPE the record matches, the honest answer to "what kind of person produces this record, and what can people like that do". The ladder markers describe dispositions and records, not single moments \u2014 so a record can match a rung no single session hit (dense strong takes whose shape reads like the higher type), and a record can FAIL to match a rung despite touching its number once (one lucky moment does not make the person that type). Read the marker's words against the record and place where it genuinely fits; the marker decides, never arithmetic over the distribution and never generosity.
+   \u2022 THE GAP IS MANDATORY. For every verdict, "gap" states concretely what the NEXT rung's record would contain that this one does not \u2014 read the next marker and name what is missing, checkably (the kind of moment, at what stakes, with what vindication). If you cannot articulate a real gap, you have under-placed: move up. If the gap is glaring, do not let density talk you past it. A placement without a named gap is invalid.
+   \u2022 THE GAP MUST BE VISIBLE IN THIS MEDIUM \u2014 AND LEAD WITH IT. The gap's FIRST sentence names the concrete behavior these coding logs COULD contain but do not: a kind of session, move, or verified outcome that would show up right here. Some next-rung markers are legible only outside coding logs (life-scale ambition, org-scale moves, how they carry other people); penalizing their absence from a coding record is a category error \u2014 and so is RECITING that rung's content: never open with or describe the off-medium rung. If it must be acknowledged at all, one short trailing clause ("the rest of that rung lives outside these logs") is the maximum. Where the record already contains a smaller version of the missing behavior, say what the larger version would look like without belittling the one that happened. A gap the person would read and rightly answer "these logs could never show that" \u2014 or a generic self-help line that fits anyone \u2014 is invalid.
+   \u2022 CONFIDENCE IS EARNED BY RECURRENCE. "provisional" = the level rests on one or two moments; "grounded" = the same altitude recurs across several independent sessions; "strong" = it recurs consistently across many sessions and contexts. Never label a one-moment read grounded or strong.
+   \u2022 ALWAYS BEST + RANGE + THE CONDITIONS THAT MOVE EACH BOUND \u2014 never a bare point score. The range is not a hedge; it is a structured query for the next runs: "conditions" states exactly what evidence would push the score to the high bound and what to the low bound (e.g. "high if the same altitude recurs on the next genuinely hard fork; low if the next several ambiguous calls land conventional"). A confident verdict still carries a range \u2014 just a tight one; the WIDTH encodes your confidence.
+   \u2022 NULL SESSIONS ARE SAMPLING GAPS, NEVER LOWS. Score-or-null grading means a session without a take had no opportunity to show the criterion \u2014 it must not drag the verdict down, and it must not count as evidence of consistency either.
+   \u2022 FREQUENCY IS PART OF THE VERDICT. Echo the code-computed stats line for the axis (given below) into "statsLine" verbatim, and state the base rate plainly inside "verdictLine" (e.g. "one judgement-grade moment across two graded sessions"). A pattern requires multiple distinct sessions; one moment is one moment.
+   \u2022 THIN EVIDENCE CUTS BOTH WAYS \u2014 NO FLATTERY, NO UPWARD-ONLY HEDGING. With little evidence the truth can sit below the peak as easily as above it; never write "probably even better than this shows", and never quietly round a range up. State what the takes show, at the confidence they earn \u2014 and no more.
+   \u2022 ORIGINATION IS THE GATE. The AI is the person's instrument: never discount a move because the AI elaborated or formalized around it \u2014 and never credit one that merely ratifies the AI's own suggestion. The move must start in the person.
+   \u2022 GROUND EVERY CLAIM in the takes given: cite session titles/dates; "peak" names the single strongest take of THAT axis (its sessionId, title, date, score). Never invent or paraphrase a quote. In verdictLine/gap/conditions, describe moves in plain what-the-person-did words \u2014 stored session titles are auto-generated noise: copy them verbatim only as identifiers, never lean on them for meaning, and never coin ornamental names for what happened.
+   \u2022 PEAKS ARE DEMONSTRATIONS, NOT HIGH SCORES. "peaks" lists the sessionIds of the 2-3 takes (from THIS axis's takes only) a reader should see to BELIEVE the verdict \u2014 chosen for how purely they demonstrate the AXIS'S OWN CONSTRUCT, not for their score. A take can carry a top score on its source criterion and still be a poor demonstration of this axis (a well-executed delivery scores high on outcomes but demonstrates nothing about agency's self-authorship; a clean routine call demonstrates nothing about judgement's high-stakes forks). For agency pick the origination stories (evidence sought outside the work, mid-flight redirection, self-derived constraints) over well-executed delivery; for judgement the calls where the most rode on being right; for taste the sharpest vindicated bars; for delegation the leash calls. Order them strongest-demonstration first.
+   "verdictLine" is 1\u20132 sentences, plain language, no em dashes: the pattern plus its base rate.
+
+   PER-AXIS JUDGMENT (how to read each construct):
+   \u2022 JUDGEMENT is PEAK-DRIVEN, AND ITS PEAKS ARE THE HIGH-STAKES CALLS. It is most visible exactly where the stakes of the call are real \u2014 shipping risk, irreversibility, measurement integrity, a fork where continuing-without-noticing silently corrupts the result \u2014 not in cool routine threads. Hard rules: (1) GRADE THE CALL ON ITS OWN MERITS, isolated from the noise around it: a sound call amid a messy session is sound judgement; something that happened TO them (a tool failure, a broken environment) is not a decision and carries no penalty. (2) REAL-TIME RECONSIDERATION IS DELIBERATION, NOT A FAILURE MODE: catching themselves and weighing it is the process working \u2014 grade where they LAND, never the wavering on the way. (3) A failure-mode cap fires ONLY on a genuine PATTERN of landing on the wrong call across distinct sessions \u2014 letting what they want bend the decision, chasing the short-term fix against the long arc; it does NOT fire on charged-but-sound moments, on costly-but-correct calls (paying a real price in time or rework to do the long-term-right thing is TOP-rung judgement), or on the ordinary slips every sound person makes; a single low amid strong takes is a slip, never the level. (4) WEIGHT BY THE STAKES OF THE DECISION, not the topic's intellectual prestige: the ceiling is set by sound calls made where the most rode on being right; a correct call on a trivial matter does not set it.
+   \u2022 AGENCY is self-directed power to act, judged from visible MOVES: words about boldness are not boldness; only executed moves climb. Read three things in the outcomes + caliber takes: (1) SELF-AUTHORSHIP \u2014 whose goals are they chasing: do they originate the direction and question the frame itself, or execute what was handed to them? Self-sourced moves count at full weight; a move the AI handed them does not. (2) BIAS TO ACTION AND FOLLOW-THROUGH \u2014 the gap between deciding and doing, and whether stated intentions later appear as completed, verified actions ("said it, did it" is a move; "planned, never shipped" is also a move). (3) BARRIER PERSISTENCE \u2014 judge the SEQUENCE of moves after a block, not the mood: how many distinct routes past it they generate, whether they unblock their own path rather than wait to be rescued (never needing to be unblocked across the corpus is itself a top-tier signal; needing constant rescue caps the tier no matter the occasional brilliance). A confessed doubt is corroborating color, not a cap \u2014 it lowers the verdict only when it is the TERMINUS, with no route after it. (4) EXECUTION IS NOT AGENCY. Competently working through already-identified work \u2014 fixing a list of reported bugs, implementing a change someone directed, tuning a gate or threshold the task already called for \u2014 is execution and never climbs this ladder on its own, however clean. What converts the same stretch into agency evidence is the SELF-ORIGINATED LOOP around it: putting the thing in front of real users without being asked and systematically working what came back; going outside the codebase for evidence (user conversations, watching real adoption) and letting it REDIRECT the work mid-flight; deriving a constraint nobody handed them from how people will actually use the thing, then re-engineering to meet it. When choosing peaks, rank origination-of-direction above cleverness-of-implementation.
+   \u2022 TASTE is how high and how RIGHT a quality bar they hold \u2014 the rare, specific, vindicated call the AI could never have reached on its own, or a developed up-front vision where the AI is weakest, plus knowing where NOT to impose a bar (letting the AI run on throwaway is calibration, not absence). Generic corrections the AI could have gone either way on are NON-EVIDENCE, never low taste; a low score on rote work is no penalty, while a withheld bar on taste-heavy work is a real miss. The verdict discipline is the same as everywhere: the ceiling is the tested bar, a bar shown once is a one-off until it recurs, and the base rate rides in the verdict.
+
+THE PERSON-TYPE LADDERS (verbatim from the chat engine's lenses \u2014 the SAME ladders the person's chat report is placed on, so a 9 means one thing everywhere. They were authored for live-chat evidence: read them at PERSON level \u2014 "what kind of person produces this record" \u2014 and translate their stakes to the coding medium: shipping risk, irreversibility, measurement integrity, data loss. Where a marker says "conversation", read "session"):
+
+${axisLadders()}
+
+AXIS STATS (code-computed \u2014 echo each verbatim into that axis's "statsLine"):
+${axisStats}
 
 Output a SINGLE fenced \`\`\`json block:
 \`\`\`json
 {
   "overall": "",
   "signatureMoves": [ { "what": "", "session": "", "quote": "" } ],
-  "criteria": [ { "key": "taste", "headline": "", "insight": "" } ]
-}
-\`\`\``;
+  "criteria": [ { "key": "taste", "headline": "", "insight": "" } ],
+  "verdicts": {
+    "judgement": { "best": 0, "low": 0, "high": 0, "confidence": "provisional|grounded|strong", "statsLine": "", "verdictLine": "", "peak": { "sessionId": "", "title": "", "date": "", "score": 0 }, "peaks": ["sessionId of the 2-3 takes that best DEMONSTRATE this axis, strongest first"], "conditions": "", "gap": "what the next rung's record would contain that this one doesn't" },
+    "agency": null,
+    "taste": null,
+    "delegation": null
+  }
+}
+\`\`\`
+(an axis whose criteria have no takes is null; the other two follow the schema above \u2014 "gap" is REQUIRED on every non-null verdict)`;
+}
+function applyVerdictSeatbelt(llm, takes, nGraded, log = (m) => console.warn(m)) {
+  const { scored, qualifying, peak } = qualifyingTakes(takes);
+  if (scored === 0 || !peak) return null;
+  if (!llm || typeof llm !== "object") return null;
+  const o = llm;
+  const num2 = (v) => {
+    const x = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+    return Number.isFinite(x) ? Math.round(x) : null;
+  };
+  let best = num2(o.best);
+  if (best == null) return null;
+  best = Math.max(2, Math.min(11, best));
+  let low = Math.max(1, Math.min(num2(o.low) ?? best, best));
+  const high = Math.min(11, Math.max(num2(o.high) ?? best, best));
+  const confidence = o.confidence === "grounded" || o.confidence === "strong" || o.confidence === "provisional" ? o.confidence : "provisional";
+  if (low >= best && (qualifying <= 1 || confidence === "provisional")) {
+    low = Math.max(1, best - (qualifying <= 1 ? 2 : 1));
+    log(`[agglomerate] seatbelt: ${qualifying} qualifying take(s) but the model returned a point score (best ${best} = low) \u2014 range opened to ${low}-${high}; check the prompt's provisionality laws`);
+  }
+  const clean = (s, n) => String(s ?? "").replace(/\s*—\s*/g, ", ").replace(/\s+/g, " ").trim().slice(0, n);
+  const citedId = o.peak && typeof o.peak === "object" ? String(o.peak.sessionId ?? "") : "";
+  const cited = takes.find((t) => t.sessionId === citedId && typeof t.score === "number");
+  const p = cited ?? peak;
+  const ownScored = new Set(takes.filter((t) => typeof t.score === "number").map((t) => t.sessionId));
+  const peaksArr = (Array.isArray(o.peaks) ? o.peaks : []).map((x) => String(x ?? "")).filter((id, i, a) => ownScored.has(id) && a.indexOf(id) === i).slice(0, 3);
+  const gap = clean(o.gap, 500);
+  if (!gap) {
+    log(`[agglomerate] INVALID: no "gap" named for a placement (best ${best}) \u2014 the prompt requires one on every verdict`);
+    throw new Error(`agglomerate: verdict missing its mandatory "gap" (placement best ${best}) \u2014 generation rejected, existing output kept`);
+  }
+  return {
+    best,
+    low,
+    high,
+    confidence,
+    qualifying,
+    scored,
+    statsLine: axisStatsLine(takes, nGraded),
+    verdictLine: clean(o.verdictLine, 600),
+    peak: { sessionId: p.sessionId, title: oneLine(p.title, 90), date: (p.date || "").slice(0, 10), score: p.score },
+    ...peaksArr.length ? { peaks: peaksArr } : {},
+    conditions: clean(o.conditions, 600),
+    gap
+  };
 }
-function validate(raw, n, costUsd) {
+function validate(raw, grades, costUsd) {
   if (!raw || typeof raw !== "object") return null;
   const r = raw;
   const overall = typeof r.overall === "string" ? r.overall.trim() : "";
   if (!overall) return null;
+  if (!r.verdicts || typeof r.verdicts !== "object") return null;
   const keys = new Set(GRADED_CRITERIA.map((c) => c.key));
   const criteria = (Array.isArray(r.criteria) ? r.criteria : []).map((c) => {
     const o = c ?? {};
@@ -16190,34 +16911,43 @@ function validate(raw, n, costUsd) {
     const o = m ?? {};
     return { what: String(o.what ?? "").slice(0, 400), session: String(o.session ?? "").slice(0, 120), quote: String(o.quote ?? "").slice(0, 400) };
   }).filter((m) => m.what).slice(0, 8);
-  return { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), sessionsUsed: n, overall, signatureMoves, criteria, meta: { costUsd } };
+  const v = r.verdicts;
+  const n = grades.length;
+  const verdicts = {
+    judgement: applyVerdictSeatbelt(v.judgement, takesFor(grades, AXIS_SOURCES.judgement), n),
+    agency: applyVerdictSeatbelt(v.agency, takesFor(grades, AXIS_SOURCES.agency), n),
+    taste: applyVerdictSeatbelt(v.taste, takesFor(grades, AXIS_SOURCES.taste), n),
+    delegation: applyVerdictSeatbelt(v.delegation, takesFor(grades, AXIS_SOURCES.delegation), n)
+  };
+  return { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), sessionsUsed: n, overall, signatureMoves, criteria, verdicts, meta: { costUsd } };
 }
 async function agglomerate(opts) {
   let files = [];
   try {
-    files = (await fs7.readdir(opts.gradesDir)).filter((f) => f.endsWith(".json")).sort();
+    files = (await fs8.readdir(opts.gradesDir)).filter((f) => f.endsWith(".json")).sort();
   } catch {
     return null;
   }
   const grades = [];
   for (const f of files) {
     try {
-      grades.push(JSON.parse(await fs7.readFile(path10.join(opts.gradesDir, f), "utf8")));
+      grades.push(JSON.parse(await fs8.readFile(path11.join(opts.gradesDir, f), "utf8")));
     } catch {
     }
   }
   if (grades.length === 0) return null;
   const prompt = buildPrompt(grades);
   const system = opts.sourceDir ? SYSTEM + sourceLookupNote() : SYSTEM;
-  const sha = promptSha([system, prompt, opts.model ?? "sonnet"]);
+  const model2 = opts.model ?? "opus";
+  const sha = promptSha([system, prompt, model2]);
   if (!opts.refresh) {
-    const prev = await reusableOutput(opts.outFile, sha, (o) => !!o.overall);
+    const prev = await reusableOutput(opts.outFile, sha, (o) => !!o.overall && o.verdicts !== void 0);
     if (prev) {
       console.log(`[agglomerate] inputs unchanged \u2014 reusing output from ${prev.generatedAt} (--refresh to regenerate)`);
       return prev;
     }
   }
-  const sandbox = opts.sourceDir ?? await fs7.mkdtemp(path10.join(os2.tmpdir(), "ps-coding-agg-"));
+  const sandbox = opts.sourceDir ?? await fs8.mkdtemp(path11.join(os3.tmpdir(), "ps-coding-agg-"));
   try {
     const run2 = await invokeAgent({
       prompt,
@@ -16226,21 +16956,21 @@ async function agglomerate(opts) {
       allowedTools: opts.sourceDir ? ["Read", "Grep", "Glob"] : ["Read"],
       maxTurns: opts.sourceDir ? 10 : 6,
       timeoutMs: 3e5,
-      model: opts.model ?? "sonnet"
+      model: model2
     });
-    const agg = validate(run2.json, grades.length, run2.costUsd);
-    if (!agg) return null;
+    const agg = validate(run2.json, grades, run2.costUsd);
+    if (!agg) throw new Error("agglomerate: the model returned no valid synthesis (overall + verdicts required) \u2014 existing output kept");
     agg.promptSha = sha;
-    await fs7.writeFile(opts.outFile, JSON.stringify(agg, null, 2));
+    await fs8.writeFile(opts.outFile, JSON.stringify(agg, null, 2));
     return agg;
   } finally {
-    if (!opts.sourceDir) await fs7.rm(sandbox, { recursive: true, force: true }).catch(() => {
+    if (!opts.sourceDir) await fs8.rm(sandbox, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 
 // ../../lib/agents/coding/profile.ts
-import path11 from "path";
+import path12 from "path";
 
 // ../../lib/agents/coding/walkthrough.ts
 var IDLE_CAP_MS = 12 * 6e4;
@@ -16251,7 +16981,7 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-16.2",
+  version: "2026-07-21.1",
   // = RUBRIC_FINGERPRINT of the shipped npm rubric (packages/coding-analyzer/
   // src/grade/criteria.ts). A unit test fails loud when the rubric changes
   // without this being updated (and re-pushed to the server).
@@ -16347,13 +17077,14 @@ var DEFAULT_CALIBRATION = {
   },
   codingBenchmarks: {
     flow: {
-      // typical knowledge worker ≈ 35% of an 8h day focused; ~4h/day is the
-      // recognized deep-work ceiling (Newport) ≈ 50% — most sit far below it.
+      // typical knowledge worker ≈ 35% of an 8h day focused; the ~4h/day
+      // deep-work ceiling (Newport) sits nearer ~40% of a real (9-10h) top
+      // performer's day — 50% overstated it (owner call 2026-07-21).
       typicalPctOfDay: 0.35,
-      topPctOfDay: 0.5,
+      topPctOfDay: 0.4,
       tag: "measured",
-      source: "RescueTime 2019 (~2h48m focused/day) \xB7 Cal Newport, Deep Work (~4h/day deep-work ceiling)",
-      line: "the best spend ~half the workday in true deep flow; ~4h/day is the human ceiling"
+      source: "RescueTime 2019 (~2h48m focused/day) \xB7 Cal Newport, Deep Work (~4h/day deep-work ceiling against a 9-10h day)",
+      line: "the best spend ~40% of the workday in true deep flow; ~4h/day is the human ceiling"
     },
     longestRun: {
       typicalHours: 0.67,
@@ -16402,18 +17133,18 @@ var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
 
 // ../../lib/agents/coding/profile.ts
 var ROOT = process.cwd();
-var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path11.join(process.env.POLYMATH_DATA_DIR, "coding") : path11.join(ROOT, ".data", "coding");
-var GRADES = path11.join(CODING_DIR, "grades");
+var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path12.join(process.env.POLYMATH_DATA_DIR, "coding") : path12.join(ROOT, ".data", "coding");
+var GRADES = path12.join(CODING_DIR, "grades");
 
 // ../../scripts/coding-agglomerate.mts
 var argv = process.argv.slice(2);
-var model = argv.indexOf("--model") >= 0 ? argv[argv.indexOf("--model") + 1] : "sonnet";
+var model = argv.indexOf("--model") >= 0 ? argv[argv.indexOf("--model") + 1] : "opus";
 var CODING = CODING_DIR;
 async function main() {
   console.log(`[agglomerate] synthesizing across graded sessions on ${model}\u2026`);
-  const sessions = await fs8.readFile(path12.join(CODING, "sessions.json"), "utf8").then(JSON.parse).catch(() => []);
+  const sessions = await fs9.readFile(path13.join(CODING, "sessions.json"), "utf8").then(JSON.parse).catch(() => []);
   await ensureCodingDocs(CODING, sessions);
-  const agg = await agglomerate({ model, gradesDir: path12.join(CODING, "grades"), outFile: path12.join(CODING, "agglomerate.json"), refresh: process.argv.includes("--refresh"), sourceDir: CODING });
+  const agg = await agglomerate({ model, gradesDir: path13.join(CODING, "grades"), outFile: path13.join(CODING, "agglomerate.json"), refresh: process.argv.includes("--refresh"), sourceDir: CODING });
   if (!agg) {
     console.log("[agglomerate] no grades found \u2014 run coding-grade.mts first");
     return;
@@ -16426,6 +17157,19 @@ ${agg.overall}
   console.log(`SIGNATURE MOVES:`);
   for (const m of agg.signatureMoves) console.log(`  \u2022 ${m.what} \u2014 ${m.session}
     "${m.quote}"`);
+  if (agg.verdicts) {
+    console.log(`
+VERDICTS:`);
+    for (const [axis, v] of Object.entries(agg.verdicts)) {
+      if (!v) {
+        console.log(`  ${axis}: null (no takes of its own)`);
+        continue;
+      }
+      console.log(`  ${axis}: best ${v.best} \xB7 range ${v.low}-${v.high} \xB7 ${v.confidence} (${v.qualifying} qualifying / ${v.scored} scored)`);
+      console.log(`    stats: ${v.statsLine}`);
+      console.log(`    ${v.verdictLine}`);
+    }
+  }
   console.log(`
 wrote \u2192 .data/coding/agglomerate.json`);
 }