polymath-society 0.2.5 → 0.2.7

package/dist/pipeline/coding-agglomerate.js

@@ -134,12 +134,13 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-agglomerate.mts
-import path11 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: path12, errorMaps, issueData } = params;
-  const fullPath = [...path12, ...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, path12, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path12;
+    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: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    url: ({ path: path13 }) => `${baseURL}${path13}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path12 }) => `${baseURL}${path12}`,
+    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: path12 }) => `${baseURL}${path12}`,
+      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,41 +16050,52 @@ 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 path10 from "path";
+import path11 from "path";
 
 // ../../lib/agents/coding/walkthrough.ts
 var IDLE_CAP_MS = 12 * 6e4;
@@ -15860,7 +16106,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).
@@ -15949,7 +16195,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" }
   },
@@ -15982,12 +16228,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",
@@ -16004,8 +16256,8 @@ var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
 
 // ../../lib/agents/coding/profile.ts
 var ROOT = process.cwd();
-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");
+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);
@@ -16013,7 +16265,9 @@ var model = argv.indexOf("--model") >= 0 ? argv[argv.indexOf("--model") + 1] : "
 var CODING = CODING_DIR;
 async function main() {
   console.log(`[agglomerate] synthesizing across graded sessions on ${model}\u2026`);
-  const agg = await agglomerate({ model, gradesDir: path11.join(CODING, "grades"), outFile: path11.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;

package/dist/pipeline/coding-aggregate.js

@@ -431,7 +431,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).
@@ -520,7 +520,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" }
   },
@@ -553,12 +553,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",
@@ -722,7 +728,7 @@ async function main() {
   const flow = await flowStats();
   const throughput = await throughputAvg(4);
   const prev = await readJson("aggregate.json", {});
-  const out = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ability, flow, throughput, ...prev.bigPicture ? { bigPicture: prev.bigPicture } : {} };
+  const out = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ability, flow, throughput, ...prev.bigPicture ? { bigPicture: prev.bigPicture, ...prev.bigPictureSha ? { bigPictureSha: prev.bigPictureSha } : {} } : {} };
   await fs2.writeFile(path2.join(CODING, "aggregate.json"), JSON.stringify(out, null, 2));
   console.log("aggregate.json written" + (prev.bigPicture ? " (bigPicture preserved)" : " (no bigPicture present \u2014 run coding-nutshell.mts)"));
   console.log(`  Throughput AVG (start\u2192finish span \u2265${throughput.spanHourMin}h): ${throughput.score}/11 (${throughput.label}) \xB7 ${throughput.avgWordsPerDay} words/day over ${throughput.substantialDays}/${throughput.totalCodingDays} days \xB7 [peak ceiling was ${throughput.ceiling}]`);

package/dist/pipeline/coding-build.js

@@ -1294,7 +1294,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).
@@ -1383,7 +1383,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" }
   },
@@ -1416,12 +1416,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",