polymath-society 0.2.4 → 0.2.6

package/dist/pipeline/coding-agglomerate.js

@@ -134,12 +134,13 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-agglomerate.mts
-import path10 from "path";
+import { promises as fs8 } from "fs";
+import path12 from "path";
 
 // ../../lib/agents/coding/agglomerate.ts
-import { promises as fs4 } from "fs";
+import { promises as fs7 } from "fs";
 import os2 from "os";
-import path9 from "path";
+import path10 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -2154,8 +2155,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2271,11 +2272,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -15062,39 +15063,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -15115,7 +15116,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path11 }) => `${baseURL}${path11}`,
+      url: ({ path: path13 }) => `${baseURL}${path13}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -15754,6 +15755,240 @@ var CODING_CRITERIA = [
 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";
+
+// ../../lib/agents/coding/materialize.ts
+import { promises as fs4 } from "fs";
+
+// ../coding-core/dist/injected.js
+function isHarnessEntry(e) {
+  return e.isMeta === true || e.isCompactSummary === true;
+}
+
+// ../../lib/agents/coding/materialize.ts
+var SYSTEM_REMINDER_RE = /<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>/ },
+  { re: /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g, label: "cmd output" },
+  { re: /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, label: null },
+  { re: /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g, label: null }
+];
+function collapseInjected(input) {
+  const markers = [];
+  let text2 = input;
+  for (const { re: re2, label, gistRe } of INJECTED) {
+    text2 = text2.replace(re2, (block) => {
+      if (label) {
+        const gist = (gistRe ? block.match(gistRe)?.[1] ?? "" : block.replace(/<[^>]*>/g, " ")).replace(/\s+/g, " ").trim().slice(0, INJECT_GIST);
+        markers.push(gist ? `[${label}: ${gist}]` : `[${label}]`);
+      }
+      return "";
+    });
+  }
+  return { text: text2.replace(SYSTEM_REMINDER_RE, "").trim(), markers };
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const item of content) {
+      if (item && typeof item === "object" && item.type === "text") parts.push(item.text || "");
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+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;
+async function materializeSession(file2) {
+  let raw;
+  try {
+    raw = await fs4.readFile(file2, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = [];
+  let humanTurns = 0, humanChars = 0;
+  const pendingQueued = [];
+  let lastMode = "";
+  const pushMarkers = (markers) => {
+    for (const mk of markers) if (mk !== lines[lines.length - 1]) lines.push(mk);
+  };
+  let aiLastProse = "";
+  const aiTools = /* @__PURE__ */ new Map();
+  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 bits = [];
+    if (gist) bits.push(gist);
+    if (tools) bits.push(`ran ${tools}`);
+    lines.push(`[AI: ${bits.join(" \xB7 ")}]`);
+    aiLastProse = "";
+    aiTools.clear();
+  };
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const type = e.type;
+    if (type === "ai-title") continue;
+    if (type === "mode") {
+      flushAI();
+      const m = e.mode;
+      if (m && String(m) !== lastMode) {
+        lastMode = String(m);
+        lines.push(`[mode \u2192 ${m}]`);
+      }
+      continue;
+    }
+    if (type === "queue-operation") {
+      if (e.operation === "enqueue" && typeof e.content === "string") {
+        const { text: t, markers } = collapseInjected(e.content);
+        if (t || markers.length) flushAI();
+        pushMarkers(markers);
+        if (t) {
+          pendingQueued.push(t);
+          lines.push(`>> (queued while AI working) ${t}`);
+        }
+      }
+      continue;
+    }
+    if (type === "user") {
+      if (isHarnessEntry(e)) continue;
+      const content = e.message?.content;
+      if (isToolResultOnly(content)) continue;
+      const { text: t, markers } = collapseInjected(extractText(content));
+      if (!t && !markers.length) continue;
+      flushAI();
+      pushMarkers(markers);
+      if (!t) continue;
+      humanTurns++;
+      humanChars += t.length;
+      const qi = pendingQueued.indexOf(t);
+      if (qi >= 0) {
+        pendingQueued.splice(qi, 1);
+        continue;
+      }
+      lines.push(`>> ${t}`);
+      continue;
+    }
+    if (type === "assistant") {
+      const msg = e.message ?? {};
+      let prose = "";
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          const it = item;
+          if (it.type === "text" && it.text) prose += it.text;
+          else if (it.type === "tool_use" && it.name) aiTools.set(it.name, (aiTools.get(it.name) ?? 0) + 1);
+        }
+      } else prose = extractText(msg.content);
+      prose = prose.replace(/\s+/g, " ").trim();
+      if (prose) aiLastProse = prose;
+      continue;
+    }
+  }
+  flushAI();
+  return { text: lines.join("\n"), humanTurns, humanChars };
+}
+
+// ../../lib/agents/coding/docsDir.ts
+async function writeScoreboard(codingDir, docs) {
+  const gradesDir = path9.join(codingDir, "grades");
+  let files = [];
+  try {
+    files = (await fs5.readdir(gradesDir)).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return;
+  }
+  const byCriterion = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    let g;
+    try {
+      g = JSON.parse(await fs5.readFile(path9.join(gradesDir, f), "utf8"));
+    } catch {
+      continue;
+    }
+    for (const c of g.criteria ?? []) {
+      const s = c.score ?? c.bestEstimate;
+      if (s == null) continue;
+      const line = `L${s}${c.score == null ? "~" : ""} \xB7 ${(g.date ?? "").slice(0, 10)} \xB7 ${(g.title ?? g.sessionId ?? "").replace(/\n.*/s, "").slice(0, 60)} \xB7 ${g.sessionId} \u2014 ${(c.instance ?? "").slice(0, 110)}`;
+      (byCriterion.get(c.key) ?? byCriterion.set(c.key, []).get(c.key)).push({ s, line });
+    }
+  }
+  if (!byCriterion.size) return;
+  const blocks = [...byCriterion.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(
+    ([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"),
+    `# Scoreboard \u2014 every graded session per criterion, best first.
+# Lx~ = estimate. Format: level \xB7 date \xB7 title \xB7 sessionId \u2014 graded instance.
+
+${blocks.join("\n\n")}
+`
+  );
+}
+async function ensureCodingDocs(codingDir, sessions) {
+  const docs = path9.join(codingDir, "docs");
+  await fs5.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`);
+    try {
+      await fs5.access(out);
+      continue;
+    } catch {
+    }
+    const mat = await materializeSession(s.file).catch(() => null);
+    if (!mat?.text) continue;
+    await fs5.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 writeScoreboard(codingDir, docs);
+  if (written) console.log(`[docs] materialized ${written} new transcript(s) \u2192 ${docs}`);
+  return docs;
+}
+function sourceLookupNote() {
+  return `
+
+SOURCE LOOKUP \u2014 you have Read/Grep/Glob over the working directory, which holds EVERYTHING known about this person's coding work. MAPS FIRST, grep second (the engine rule): docs/_scoreboard.md ranks every graded session per criterion, best first \u2014 one glance shows where the spikes/flair are, so start there when hunting peaks or checking whether a high mark is consistent or a one-off; day-digest.json is the day-by-day story of what they did in order \u2014 read the relevant days to get the arc before searching; docs/_map.md lists every session (date \xB7 title \xB7 sessionId). Then drill down: walkthroughs/<sessionId>.json is that session's phase-by-phase account (cheap, already distilled), grades/<sessionId>.json its graded findings with quotes, and docs/<sessionId>.txt the FULL transcript (">> " = the person, "[AI]" = the model) \u2014 the ground truth, read it when the distilled layers can't settle it. Other artifacts (flow.json, delegation/, expertise/, aggregate.json) are there too if a claim depends on them. The digest you were given is the spine \u2014 use lookups when a CLAIM-MOVING question cannot be settled from it (a moment you are about to headline, a promotion/depth call, an ambiguous engagement, whether detail was vision or boilerplate). VERIFY every verbatim quote you cite by finding it in the transcript first; if you cannot find it, do not use it. Look up what changes the output \u2014 do not re-read the whole corpus.`;
+}
+
+// ../../lib/agents/coding/promptCache.ts
+import { createHash as createHash2 } from "crypto";
+import { promises as fs6 } from "fs";
+function promptSha(parts) {
+  const h = createHash2("sha256");
+  for (const p of parts) {
+    h.update(p ?? "");
+    h.update("\0");
+  }
+  return h.digest("hex").slice(0, 16);
+}
+async function reusableOutput(outPath, sha, valid, key = "promptSha") {
+  try {
+    const o = JSON.parse(await fs6.readFile(outPath, "utf8"));
+    if (o[key] === sha && valid(o)) return o;
+  } catch {
+  }
+  return null;
+}
+
 // ../../lib/agents/coding/agglomerate.ts
 var LABEL = new Map(GRADED_CRITERIA.map((c) => [c.key, c.label]));
 function renderTakes(grades) {
@@ -15815,51 +16050,229 @@ function validate(raw, n, costUsd) {
 async function agglomerate(opts) {
   let files = [];
   try {
-    files = (await fs4.readdir(opts.gradesDir)).filter((f) => f.endsWith(".json"));
+    files = (await fs7.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 fs4.readFile(path9.join(opts.gradesDir, f), "utf8")));
+      grades.push(JSON.parse(await fs7.readFile(path10.join(opts.gradesDir, f), "utf8")));
     } catch {
     }
   }
   if (grades.length === 0) return null;
-  const sandbox = await fs4.mkdtemp(path9.join(os2.tmpdir(), "ps-coding-agg-"));
+  const prompt = buildPrompt(grades);
+  const system = opts.sourceDir ? SYSTEM + sourceLookupNote() : SYSTEM;
+  const sha = promptSha([system, prompt, opts.model ?? "sonnet"]);
+  if (!opts.refresh) {
+    const prev = await reusableOutput(opts.outFile, sha, (o) => !!o.overall);
+    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-"));
   try {
     const run2 = await invokeAgent({
-      prompt: buildPrompt(grades),
-      systemPrompt: SYSTEM,
+      prompt,
+      systemPrompt: system,
       addDir: sandbox,
-      allowedTools: ["Read"],
-      maxTurns: 6,
+      allowedTools: opts.sourceDir ? ["Read", "Grep", "Glob"] : ["Read"],
+      maxTurns: opts.sourceDir ? 10 : 6,
       timeoutMs: 3e5,
       model: opts.model ?? "sonnet"
     });
     const agg = validate(run2.json, grades.length, run2.costUsd);
     if (!agg) return null;
-    await fs4.writeFile(opts.outFile, JSON.stringify(agg, null, 2));
+    agg.promptSha = sha;
+    await fs7.writeFile(opts.outFile, JSON.stringify(agg, null, 2));
     return agg;
   } finally {
-    await fs4.rm(sandbox, { recursive: true, force: true }).catch(() => {
+    if (!opts.sourceDir) await fs7.rm(sandbox, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 
+// ../../lib/agents/coding/profile.ts
+import path11 from "path";
+
+// ../../lib/agents/coding/walkthrough.ts
+var IDLE_CAP_MS = 12 * 6e4;
+
+// ../coding-core/dist/words.js
+var NOTE = "((ran|created|edited|read|wrote|searched) (a|an|\\d+) [a-z]+|updated todos)";
+var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s*thought for .{1,30}$`, "im");
+
+// ../../lib/calibration/index.ts
+var DEFAULT_CALIBRATION = {
+  version: "2026-07-14.2",
+  // = 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).
+  rubricVersion: "f51b3a93a3",
+  // Canonical scale = the one the product owner set for the public report
+  // (11=0.01% … 8=2%), extended downward from the old report ladder. The old
+  // CodeAnalysisView / npm-viewer maps (7→10%/15%, 6→25%/30%) were drift, not
+  // intent.
+  scoreBands: [
+    { score: 11, label: "Top 0.01%" },
+    { score: 10, label: "Top 0.1%" },
+    { score: 9, label: "Top 0.5%" },
+    { score: 8, label: "Top 2%" },
+    { score: 7, label: "Top 5%" },
+    { score: 6, label: "Top 15%" },
+    { score: 5, label: "Top 50%" },
+    { score: 4, label: "Top 65%" },
+    { score: 3, label: "Top 80%" },
+    { score: 2, label: "Top 90%" },
+    { score: 1, label: "Top 97%" }
+  ],
+  minRankedScore: 6,
+  benchmarkBands: [
+    {
+      level: "11",
+      name: "Superhuman",
+      rank: "Top 0.01%",
+      oneIn: "1 in 10,000+",
+      meaning: "Beyond the normal human ceiling for the trait \u2014 the genuine power-law outlier. Almost no one earns this; when the evidence shows it, it is scored, not rounded down.",
+      foundIn: [
+        "Fields Medal and Nobel-track researchers",
+        "Founders of generational companies",
+        "The handful of people a frontier field is named after"
+      ],
+      maxTopPct: 0.01
+    },
+    {
+      level: "10",
+      name: "World-class",
+      rank: "Top 0.1%",
+      oneIn: "1 in 1,000",
+      meaning: "Among the best alive at this trait \u2014 the level entire institutions are built to find.",
+      foundIn: [
+        "Researchers at frontier AI labs",
+        "Faculty at top-5 research universities",
+        "IMO / IOI medalists",
+        "Founders backed by the top decile of venture firms"
+      ],
+      maxTopPct: 0.1
+    },
+    {
+      level: "9",
+      name: "Exceptional",
+      rank: "Top 1%",
+      oneIn: "1 in 100",
+      meaning: "Clearly exceptional \u2014 the strongest person on most strong teams.",
+      foundIn: [
+        "PhD students at top programs",
+        "Early engineers at breakout startups",
+        "YC-class founders",
+        "National olympiad finalists"
+      ],
+      maxTopPct: 1
+    },
+    {
+      level: "8",
+      name: "Strong",
+      rank: "Top 10%",
+      oneIn: "1 in 10",
+      meaning: "Strong against the whole population \u2014 the best person in most rooms, not every room.",
+      foundIn: [
+        "Senior engineers at selective tech companies",
+        "Graduates of demanding technical programs",
+        "Operators who get promoted everywhere they go"
+      ],
+      maxTopPct: 10
+    },
+    {
+      level: "5",
+      name: "Median",
+      rank: "50th percentile",
+      oneIn: "1 in 2",
+      meaning: 'The middle of the general population. The reference class is all ~8 billion humans \u2014 so even "strong" above already means top 10% of everyone.',
+      foundIn: ["The general population \u2014 most people, most places"],
+      maxTopPct: 100
+    }
+  ],
+  codingTiers: {
+    push: { median: 300, sigma: 0.91, tag: "estimated \u2014 log-normal fit", source: "Anthropic 2026 Claude Code study (400k sessions): median engaged user ~8 prompts/day at ~35 words \u2014 ~300 directed words/day; tail: a 1-in-1,000 user AVERAGES ~5k directed words/day (near-daily heavy dictation, clearly below the ~10k single-day record). AVERAGE over substantial days, cumulative not spiky." },
+    focus: { median: 0.08, sigma: 0.559, tag: "estimated \u2014 proxy-anchored", source: "median: Anthropic 20h/week engaged-user figure implies ~1h/day of true rapid exchange against an 8h working day; ceiling anchored to the ~4h/day deep-work limit (45% share = 1-in-1,000). AVERAGE share, cumulative not spiky." },
+    orchestration: { tag: "estimated \u2014 behavior bands", source: "no published concurrency distribution exists; ceiling anchored to the Claude Code lead's documented 10-15 parallel sessions" }
+  },
+  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.
+      typicalPctOfDay: 0.35,
+      topPctOfDay: 0.5,
+      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"
+    },
+    longestRun: {
+      typicalHours: 0.67,
+      // ~40 min before the average worker is interrupted
+      topHours: 4,
+      tag: "measured",
+      source: "RescueTime (avg max ~40 min focus before interruption) \xB7 deep-work single-block ceiling ~3\u20134h",
+      line: "a top performer can hold a single ~3\u20134h uninterrupted block; the average worker breaks at ~40 min"
+    },
+    parallelism: {
+      topMaxConcurrent: 12,
+      // Boris Cherny ~10–15 interactive sessions
+      topAvgConcurrent: 6,
+      // time-weighted average while active (anecdotal, same source)
+      worktreesTip: "3\u20135 git worktrees at once",
+      tag: "anecdotal",
+      source: "Boris Cherny (Claude Code lead, Anthropic): ~10\u201315 concurrent sessions, 'dozens of Claudes running at all times'; 3\u20135 worktrees = 'the single biggest productivity unlock'",
+      line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
+    },
+    throughput: {
+      // Two DIFFERENT kinds of line (2026-07-14.2): topAvg is a PERCENTILE
+      // claim — what a 1-in-1,000 user AVERAGES over substantial days (5k/day:
+      // near-daily heavy dictation; a measured top dictating power user
+      // averages ~3.9k). topPeak is NOT a percentile — it is the CEILING
+      // reference, the wildest single days on record (~10k: a 14-16h
+      // launch-day marathon), rendered as "wildest single days", never
+      // "top X% peak". An avg-percentile and a peak-percentile can't both be
+      // shown at a same-ish value (avg≈peak reads broken — user call), and a
+      // peak PERCENTILE line is unknowable anyway; the record framing is
+      // honest and keeps the visual gap.
+      topAvgWordsPerDay: 5e3,
+      topPeakWordsPerDay: 1e4,
+      benchLabel: "top 0.1%",
+      // No published "words typed/day" for heavy users — the real story is OUTPUT.
+      loopsHeadline: ">1,000,000 lines of Rust at 99.8% tests passing",
+      loopsDetail: "the Bun runtime was ported Zig\u2192Rust largely autonomously \u2014 hundreds of parallel subagents, two AI reviewers per file",
+      tag: "measured",
+      source: "The Register, May 2026 (Bun Zig\u2192Rust rewrite)",
+      line: "autonomous fleets ported >1M lines of Rust at 99.8% tests passing; a while-loop agent delivered a $50k contract for $297 of compute"
+    }
+  }
+};
+
+// ../../lib/agents/coding/benchmarks.ts
+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");
+
 // ../../scripts/coding-agglomerate.mts
 var argv = process.argv.slice(2);
 var model = argv.indexOf("--model") >= 0 ? argv[argv.indexOf("--model") + 1] : "sonnet";
-var CODING = path10.join(process.cwd(), ".data", "coding");
+var CODING = CODING_DIR;
 async function main() {
   console.log(`[agglomerate] synthesizing across graded sessions on ${model}\u2026`);
-  const agg = await agglomerate({ model, gradesDir: path10.join(CODING, "grades"), outFile: path10.join(CODING, "agglomerate.json") });
+  const sessions = await fs8.readFile(path12.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 });
   if (!agg) {
     console.log("[agglomerate] no grades found \u2014 run coding-grade.mts first");
     return;
   }
-  console.log(`[agglomerate] ${agg.sessionsUsed} sessions \xB7 ${agg.criteria.length} criteria \xB7 ${agg.signatureMoves.length} signature moves \xB7 $${agg.meta.costUsd?.toFixed(2) ?? "?"}`);
+  console.log(`[agglomerate] ${agg.sessionsUsed} sessions \xB7 ${agg.criteria.length} criteria \xB7 ${agg.signatureMoves.length} signature moves`);
   console.log(`
 OVERALL:
 ${agg.overall}