polymath-society 0.2.5 → 0.2.7

package/dist/pipeline/coding-expertise.js

@@ -134,9 +134,9 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-expertise.mts
-import { promises as fs5 } from "fs";
+import { promises as fs7 } from "fs";
 import os2 from "os";
-import path10 from "path";
+import path11 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -2151,8 +2151,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: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2268,11 +2268,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -15059,39 +15059,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -15112,7 +15112,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path11 }) => `${baseURL}${path11}`,
+      url: ({ path: path12 }) => `${baseURL}${path12}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -15625,20 +15625,9 @@ function chunkText(text2, max) {
   return out;
 }
 
-// ../../lib/agents/coding/expertise-floor.ts
-var MIN_EXPERTISE_SESSIONS = 3;
-function applyExpertiseFloor(domains, min = MIN_EXPERTISE_SESSIONS) {
-  const kept = [];
-  const dropped = [];
-  for (const d of domains) {
-    const dates = new Set(
-      (d.evidence ?? []).map((e) => (e?.date ?? "").slice(0, 10)).filter(Boolean)
-    );
-    if (dates.size >= min && (d.sessions ?? 0) >= min) kept.push(d);
-    else dropped.push({ domain: d.domain ?? "?", distinctDates: dates.size, sessions: d.sessions ?? 0 });
-  }
-  return { kept, dropped };
-}
+// ../../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";
@@ -15783,13 +15772,115 @@ async function materializeSession(file2) {
   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/expertise-floor.ts
+var MIN_EXPERTISE_SESSIONS = 3;
+function applyExpertiseFloor(domains, min = MIN_EXPERTISE_SESSIONS) {
+  const kept = [];
+  const dropped = [];
+  for (const d of domains) {
+    const dates = new Set(
+      (d.evidence ?? []).map((e) => (e?.date ?? "").slice(0, 10)).filter(Boolean)
+    );
+    if (dates.size >= min && (d.sessions ?? 0) >= min) kept.push(d);
+    else dropped.push({ domain: d.domain ?? "?", distinctDates: dates.size, sessions: d.sessions ?? 0 });
+  }
+  return { kept, dropped };
+}
+
+// ../../lib/agents/coding/promptCache.ts
+import { createHash } from "crypto";
+import { promises as fs6 } from "fs";
+function promptSha(parts) {
+  const h = createHash("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/profile.ts
-import path9 from "path";
+import path10 from "path";
 
 // ../../lib/calibration/fingerprint.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function rubricFingerprint(criteria) {
-  return createHash("sha256").update(JSON.stringify(criteria)).digest("hex").slice(0, 10);
+  return createHash2("sha256").update(JSON.stringify(criteria)).digest("hex").slice(0, 10);
 }
 
 // ../../lib/agents/coding/criteria.ts
@@ -15938,7 +16029,7 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-12.2",
+  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).
@@ -16027,7 +16118,7 @@ var DEFAULT_CALIBRATION = {
     }
   ],
   codingTiers: {
-    push: { median: 300, sigma: 1.121, 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 shape from its actions-per-prompt distribution. AVERAGE over substantial days, cumulative not spiky." },
+    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" }
   },
@@ -16060,12 +16151,18 @@ var DEFAULT_CALIBRATION = {
       line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
     },
     throughput: {
-      // Top-0.1% words/day reference lines, anchored to the throughput ladder
-      // (THROUGHPUT_LADDER in throughput.ts): score 10 "world-class sustained" =
-      // 9k/day, score 11 "superhuman ceiling" = 12k/day. Calibrated to the person's
-      // own anchors, not a wild guess — but still a target, not a measured population.
-      topAvgWordsPerDay: 9e3,
-      topPeakWordsPerDay: 12e3,
+      // 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",
@@ -16082,14 +16179,15 @@ var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
 
 // ../../lib/agents/coding/profile.ts
 var ROOT = process.cwd();
-var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path9.join(process.env.POLYMATH_DATA_DIR, "coding") : path9.join(ROOT, ".data", "coding");
-var GRADES = path9.join(CODING_DIR, "grades");
+var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path10.join(process.env.POLYMATH_DATA_DIR, "coding") : path10.join(ROOT, ".data", "coding");
+var GRADES = path10.join(CODING_DIR, "grades");
 
 // ../../scripts/coding-expertise.mts
 var CODING = CODING_DIR;
-var OUTDIR = path10.join(CODING, "expertise");
+var OUTDIR = path11.join(CODING, "expertise");
 var CHUNK = 46e3;
-var CONC = 5;
+var concFlag = process.argv.indexOf("--conc");
+var CONC = concFlag >= 0 ? Math.max(1, Number(process.argv[concFlag + 1]) || 5) : 5;
 var EXTRACT_SYS = `You extract HARD TECHNICAL / SYSTEMS domain expertise from one coding session \u2014 ONLY genuine, specialized technical knowledge a very smart generalist who never worked in that domain could NOT produce. WHAT EXPERTISE IS \u2014 accumulated FIELD knowledge. An expert has internalized a domain's empirical landscape: what its practitioners collectively learned by trial and error \u2014 which approaches win in practice, named techniques / benchmarks / known results, the field's failure taxonomies, tool trade-offs and their folklore. It is knowledge that exists OUTSIDE the system in this session and could only come from having read, built, and experimented deeply IN the field itself. THE BAR is HARD systems/infra domains: memory architectures, vector databases, graph databases, RAG / retrieval systems, agent harnesses, distributed systems, database internals, kernels / OS, networking, GPU / CUDA, compilers, concurrency, ML training / serving infrastructure, large-scale data engineering. HIRING-BAR TEST \u2014 apply to EVERY candidate signal: would this line convince a team hiring a cutting-edge specialist in that exact domain that this person already operates at that level? If it merely shows a very smart person reasoning well about the system in front of them, it fails the bar \u2192 exclude. DERIVED-ON-THE-SPOT \u2260 EXPERTISE \u2014 the most common false positive. A correct, even mechanism-level, call that a smart generalist could DERIVE in the moment by reasoning about the system in front of them \u2014 cost/latency arithmetic, quality-vs-price trade-offs between components, 'the bottleneck will be X', 'cache that, it's called in a loop', 'shard by the hot key' read straight off the schema at hand \u2014 is GENERAL REASONING, not expertise, EVEN WHEN the AI hadn't thought of it and the person turned out right. Real expertise REFERENCES the field: named methods, known empirical results, failure modes a non-practitioner would not know existed. EXCLUDE ENTIRELY \u2014 these do NOT count here: the person's own PRODUCT / APPLICATION area (evaluating humans, personality / psychometrics / Big Five / OCEAN, talent assessment, rubric design for their own scoring product, analyzing chat-log corpora), generic Claude Code / CLI usage, common sense, general intelligence, and building a product that merely USES a domain's concepts. Building an evaluator FOR X is NOT expertise IN X. NARROW-SLICE RULE \u2014 fluently handling the narrow slice of a domain that the person's OWN product consumes is USING the domain, not expertise in it (tuning your own app's queries does not make you a database-internals expert; wiring a vector search into your app does not make you a vector-DB expert). Capture TWO distinct KINDS of signal and TAG each with "type": (1) "built" \u2014 the person HANDS-ON built, optimized, or deeply experimented with a hard technical SYSTEM in this session: implemented internals, tried multiple approaches, debugged it at the mechanism level, studied how it works. Real sustained engagement with the system itself. (2) "directs" \u2014 the person DIRECTS the AI with OPINIONATED, MECHANISM-LEVEL technical authority in a hard domain, even without building it here: e.g. 'use HNSW not IVF-flat, recall collapses past ~1M vectors', 'wrong index for this access pattern', 'that isolation level lets the anomaly through'. The knowledge must be SPECIALIZED and NON-INTUITIVE \u2014 something a very smart generalist could NOT reach by good judgment alone. EXCLUDE good architectural / engineering JUDGMENT (fan-out in parallel, explore-before-building, staging, caching, don't-use-a-critic, cheap-pass-first-expensive-pass-when-warranted) \u2014 that is GENERAL INTELLIGENCE, not domain expertise. For BOTH, the knowledge must be PREDICTIVE / constraint-level and clearly require accumulated specialized experience. TRANSFERABILITY TEST: could a very smart generalist produce this from common sense + on-the-spot reasoning about the system at hand? YES \u2192 exclude. When in doubt, exclude. Most sessions show NO hard-technical-domain expertise \u2014 say so plainly. Never flatter, never pad, never invent.`;
 function extractPrompt(rec, transcript, seg = "") {
   return `SESSION: "${rec.title}" \xB7 ${rec.start?.slice(0, 10)}${seg}
@@ -16128,17 +16226,17 @@ async function pool(items, n, fn) {
 }
 async function main() {
   const aggOnly = process.argv.includes("--agg");
-  await fs5.mkdir(OUTDIR, { recursive: true });
-  const sessions = JSON.parse(await fs5.readFile(path10.join(CODING, "sessions.json"), "utf8"));
+  await fs7.mkdir(OUTDIR, { recursive: true });
+  const sessions = JSON.parse(await fs7.readFile(path11.join(CODING, "sessions.json"), "utf8"));
   const byId = new Map(sessions.map((s) => [s.sessionId, s]));
-  const gradeFiles = (await fs5.readdir(path10.join(CODING, "grades"))).filter((f) => f.endsWith(".json"));
+  const gradeFiles = (await fs7.readdir(path11.join(CODING, "grades"))).filter((f) => f.endsWith(".json")).sort();
   const ids = gradeFiles.map((f) => f.replace(".json", ""));
   if (!aggOnly) {
     let done = 0;
     await pool(ids, CONC, async (id) => {
-      const out = path10.join(OUTDIR, id + ".json");
+      const out = path11.join(OUTDIR, id + ".json");
       try {
-        await fs5.access(out);
+        await fs7.access(out);
         done++;
         return;
       } catch {
@@ -16147,7 +16245,7 @@ async function main() {
       if (!rec) return;
       const mat = await materializeSession(rec.file);
       if (!mat) return;
-      const sandbox2 = await fs5.mkdtemp(path10.join(os2.tmpdir(), "exp-"));
+      const sandbox = await fs7.mkdtemp(path11.join(os2.tmpdir(), "exp-"));
       try {
         const chunks = chunkText(mat.text, CHUNK);
         const realExpertise = [];
@@ -16156,49 +16254,56 @@ async function main() {
         const summaries = [];
         for (let ci = 0; ci < chunks.length; ci++) {
           const seg = chunks.length > 1 ? ` \xB7 segment ${ci + 1}/${chunks.length}` : "";
-          const run2 = await invokeAgent({ prompt: extractPrompt(rec, chunks[ci], seg), systemPrompt: EXTRACT_SYS, addDir: sandbox2, allowedTools: ["Read"], maxTurns: 5, timeoutMs: 24e4, model: "sonnet" });
+          const run2 = await invokeAgent({ prompt: extractPrompt(rec, chunks[ci], seg), systemPrompt: EXTRACT_SYS, addDir: sandbox, allowedTools: ["Read"], maxTurns: 5, timeoutMs: 24e4, model: "sonnet" });
           const j = run2.json || {};
           realExpertise.push(...j.realExpertise || []);
           excluded.push(...j.excluded || []);
           for (const d of j.domains || []) if (!domains.includes(d)) domains.push(d);
           if (j.summary) summaries.push(j.summary);
         }
-        await fs5.writeFile(out, JSON.stringify({ sessionId: id, date: rec.start?.slice(0, 10), title: rec.title, realExpertise, excluded, domains, summary: summaries.join(" ") }, null, 1));
+        await fs7.writeFile(out, JSON.stringify({ sessionId: id, date: rec.start?.slice(0, 10), title: rec.title, realExpertise, excluded, domains, summary: summaries.join(" ") }, null, 1));
         done++;
         console.log(`[${done}/${ids.length}] ${rec.title} \u2014 ${realExpertise.length} real`);
       } catch (e) {
         console.log(`ERR ${rec.title}: ${e.message.slice(0, 80)}`);
       } finally {
-        await fs5.rm(sandbox2, { recursive: true, force: true }).catch(() => {
+        await fs7.rm(sandbox, { recursive: true, force: true }).catch(() => {
         });
       }
     });
   }
   const perSession = [];
-  for (const f of (await fs5.readdir(OUTDIR)).filter((f2) => f2.endsWith(".json"))) {
+  for (const f of (await fs7.readdir(OUTDIR)).filter((f2) => f2.endsWith(".json")).sort()) {
     try {
-      perSession.push(JSON.parse(await fs5.readFile(path10.join(OUTDIR, f), "utf8")));
+      perSession.push(JSON.parse(await fs7.readFile(path11.join(OUTDIR, f), "utf8")));
     } catch {
     }
   }
   const items = perSession.flatMap((s) => (s.realExpertise || []).map((e) => ({ ...e, date: s.date, title: s.title })));
   const titles = perSession.map((s) => ({ date: s.date, title: s.title })).filter((t) => t.title);
   const stats = { sessionsProcessed: perSession.length, sessionsWithExpertise: perSession.filter((s) => (s.realExpertise || []).length).length, sessionsZero: perSession.filter((s) => !(s.realExpertise || []).length).length, totalSignals: items.length };
+  const AGG_SYSX = AGG_SYS + sourceLookupNote();
+  const prompt2 = aggPrompt(items, stats, titles);
+  const sha = promptSha([AGG_SYSX, prompt2, "sonnet"]);
+  if (!process.argv.includes("--refresh")) {
+    const prev = await reusableOutput(path11.join(CODING, "expertise.json"), sha, (o) => Array.isArray(o.domains));
+    if (prev) {
+      console.log(`[expertise] inputs unchanged \u2014 reusing aggregate from ${prev.generatedAt} (--refresh to regenerate)`);
+      return;
+    }
+  }
+  await ensureCodingDocs(CODING, sessions);
   console.log("\nAGGREGATING", stats);
-  const sandbox = await fs5.mkdtemp(path10.join(os2.tmpdir(), "expagg-"));
   let map = { domains: [], building: [], summary: "", directiveQuality: "", seeingAroundCorners: "" };
   let aggOk = false;
   try {
-    const run2 = await invokeAgent({ prompt: aggPrompt(items, stats, titles), systemPrompt: AGG_SYS, addDir: sandbox, allowedTools: ["Read"], maxTurns: 4, timeoutMs: 54e4, model: "sonnet" });
+    const run2 = await invokeAgent({ prompt: prompt2, systemPrompt: AGG_SYSX, addDir: CODING, allowedTools: ["Read", "Grep", "Glob"], maxTurns: 10, timeoutMs: 54e4, model: "sonnet" });
     if (run2.json) {
       map = run2.json;
       aggOk = true;
     }
   } catch (e) {
     console.log("AGG ERR", e.message.slice(0, 120));
-  } finally {
-    await fs5.rm(sandbox, { recursive: true, force: true }).catch(() => {
-    });
   }
   const REJECT_DOMAIN = /psychometr|big.?five|\bocean\b|personality|\btalent\b|performance assessment|agent.?harness|harness (design|architect)/i;
   if (Array.isArray(map.domains)) {
@@ -16210,15 +16315,15 @@ async function main() {
     map.domains = kept;
   }
   if (!aggOk && !(map.domains || []).length) {
-    const existing = await fs5.readFile(path10.join(CODING, "expertise.json"), "utf8").then(JSON.parse).catch(() => null);
+    const existing = await fs7.readFile(path11.join(CODING, "expertise.json"), "utf8").then(JSON.parse).catch(() => null);
     if (existing && (existing.domains || []).length) {
       console.log("AGG FAILED (0 domains) \u2014 keeping existing", existing.domains.length, "domains");
       return;
     }
     console.log("AGG failed and no good existing file \u2014 writing empty");
   }
-  const result = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...stats, ...map };
-  await fs5.writeFile(path10.join(CODING, "expertise.json"), JSON.stringify(result, null, 2));
+  const result = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...aggOk ? { promptSha: sha } : {}, ...stats, ...map };
+  await fs7.writeFile(path11.join(CODING, "expertise.json"), JSON.stringify(result, null, 2));
   console.log("\nWROTE .data/coding/expertise.json \u2014", (map.domains || []).length, "domains");
 }
 main().catch((e) => {

package/dist/pipeline/coding-flow.js

@@ -394,7 +394,7 @@ var IDLE_CAP_MS = 12 * 6e4;
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-12.2",
+  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).
@@ -483,7 +483,7 @@ var DEFAULT_CALIBRATION = {
     }
   ],
   codingTiers: {
-    push: { median: 300, sigma: 1.121, 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 shape from its actions-per-prompt distribution. AVERAGE over substantial days, cumulative not spiky." },
+    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" }
   },
@@ -516,12 +516,18 @@ var DEFAULT_CALIBRATION = {
       line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
     },
     throughput: {
-      // Top-0.1% words/day reference lines, anchored to the throughput ladder
-      // (THROUGHPUT_LADDER in throughput.ts): score 10 "world-class sustained" =
-      // 9k/day, score 11 "superhuman ceiling" = 12k/day. Calibrated to the person's
-      // own anchors, not a wild guess — but still a target, not a measured population.
-      topAvgWordsPerDay: 9e3,
-      topPeakWordsPerDay: 12e3,
+      // 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",