polymath-society 0.2.5 → 0.2.7

package/dist/pipeline/coding-gap.js

@@ -134,9 +134,8 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-gap.mts
-import { promises as fs9 } from "fs";
-import os2 from "os";
-import path12 from "path";
+import { promises as fs11 } from "fs";
+import path13 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -2151,8 +2150,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
@@ -2268,11 +2267,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() {
@@ -15059,39 +15058,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
   });
@@ -15112,7 +15111,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
     });
@@ -16271,7 +16270,7 @@ function computeWorkstyle(inp) {
 
 // ../../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).
@@ -16360,7 +16359,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" }
   },
@@ -16393,12 +16392,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",
@@ -16733,7 +16738,7 @@ async function compileCodingProfile() {
     sRow(
       "How hard you push",
       aggregate?.throughput?.score ?? tCeiling,
-      `you peak at ~${peakWords.toLocaleString()} words of pure direction in a single day \u2014 the very top sustain ~${BEST.throughput.topAvgWordsPerDay.toLocaleString()} every day, week after week, and crest past ${BEST.throughput.topPeakWordsPerDay.toLocaleString()}`
+      `you peak at ~${peakWords.toLocaleString()} words of pure direction in a single day \u2014 the very top sustain ~${BEST.throughput.topAvgWordsPerDay.toLocaleString()} every day, week after week; the wildest single days on record push ~${BEST.throughput.topPeakWordsPerDay.toLocaleString()}`
     ),
     sRow(
       "How well you use AI",
@@ -16809,6 +16814,10 @@ async function readCodingAsset(name17) {
   );
 }
 
+// ../../lib/agents/coding/docsDir.ts
+import { promises as fs9 } from "fs";
+import path12 from "path";
+
 // ../../lib/agents/coding/materialize.ts
 import { promises as fs8 } from "fs";
 var SYSTEM_REMINDER_RE2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -16945,6 +16954,93 @@ async function materializeSession(file2) {
   return { text: lines.join("\n"), humanTurns, humanChars };
 }
 
+// ../../lib/agents/coding/docsDir.ts
+async function writeScoreboard(codingDir, docs) {
+  const gradesDir = path12.join(codingDir, "grades");
+  let files = [];
+  try {
+    files = (await fs9.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 fs9.readFile(path12.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 fs9.writeFile(
+    path12.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 = path12.join(codingDir, "docs");
+  await fs9.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 = path12.join(docs, `${s.sessionId}.txt`);
+    try {
+      await fs9.access(out);
+      continue;
+    } catch {
+    }
+    const mat = await materializeSession(s.file).catch(() => null);
+    if (!mat?.text) continue;
+    await fs9.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 fs9.writeFile(path12.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 fs10 } 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 fs10.readFile(outPath, "utf8"));
+    if (o[key] === sha && valid(o)) return o;
+  } catch {
+  }
+  return null;
+}
+
 // ../../scripts/coding-gap.mts
 var CODING = CODING_DIR;
 var CONFIG = {
@@ -16958,7 +17054,7 @@ var CLAUDE_AUTO_CAP = /* @__PURE__ */ new Set(["queue-ahead", "deferred-tools",
 var CLAUDE_AUTO_MCP = /^(visualize|Claude[_ ]?Preview|ccd[_ ]?session|ccd[_ ]?session[_ ]?mgmt|mcp[_ ]?registry)$/i;
 async function entrypointOf(file2) {
   try {
-    const head = (await fs9.readFile(file2, "utf8")).slice(0, 2e4);
+    const head = (await fs11.readFile(file2, "utf8")).slice(0, 2e4);
     if (/[\/."]\.?conductor/i.test(head)) return "conductor";
     const m = /"entrypoint":"([^"]+)"/.exec(head);
     return m ? m[1] : "unknown";
@@ -16980,14 +17076,14 @@ var MOBILE_WEB = /^claude-(web|mobile|ios|android)$/;
 function sumTool(recs, name17) {
   return recs.reduce((a, s) => a + (s.toolCounts?.[name17] ?? 0), 0);
 }
-var LOCK = path12.join(CODING, ".gap.lock");
+var LOCK = path13.join(CODING, ".gap.lock");
 var lockHeld = false;
 async function acquireLock() {
   try {
-    await fs9.writeFile(LOCK, String(process.pid), { flag: "wx" });
+    await fs11.writeFile(LOCK, String(process.pid), { flag: "wx" });
     lockHeld = true;
   } catch {
-    const pid = await fs9.readFile(LOCK, "utf8").catch(() => "?");
+    const pid = await fs11.readFile(LOCK, "utf8").catch(() => "?");
     throw new Error(`another coding-gap run appears active (pid ${pid}, ${LOCK}). Wait for it or delete the lock if it's stale \u2014 concurrent runs overwrite each other's gap.json.`);
   }
 }
@@ -16996,9 +17092,9 @@ async function main() {
   const p = await compileCodingProfile();
   const techniquesAsset = await readCodingAsset("TECHNIQUES.md");
   const techniques = techniquesAsset.text;
-  console.log(`  rubric: ${techniquesAsset.path} (${(await fs9.stat(techniquesAsset.path)).mtime.toISOString()})`);
+  console.log(`  rubric: ${techniquesAsset.path} (${(await fs11.stat(techniquesAsset.path)).mtime.toISOString()})`);
   const writing = (await readCodingAsset("WRITING.md")).text;
-  const all = JSON.parse(await fs9.readFile(path12.join(CODING, "sessions.json"), "utf8"));
+  const all = JSON.parse(await fs11.readFile(path13.join(CODING, "sessions.json"), "utf8"));
   const interactive = all.filter((s) => s.klass === "interactive" && s.start);
   const latestMs = Math.max(...interactive.map((s) => Date.parse(s.start)));
   const cutoffMs = latestMs - 14 * 864e5;
@@ -17055,7 +17151,7 @@ async function main() {
     return m ? `--- "${s.title}" \xB7 ${(s.start || "").slice(0, 10)} ---
 ${m.text.slice(0, 3e3)}` : "";
   }))).filter(Boolean);
-  const SYS = "You are a Claude Code power-user coach. You judge ONE person against the COMPLETE catalog of best ways to use Claude Code (the rubric below, sourced from Boris Cherny + first-party Claude Code features) and write a comprehensive, honest gap analysis, ORDERED most-difference-making \u2192 least. Rules: (1) Go through the whole catalog and surface the techniques they are NOT doing (or under-using) that would genuinely help \u2014 respecting each tip's [EMPHASIZE]/[DE-EMPHASIZE]/[GATE] curation. (2) ORDER by differenceRank (1 = biggest unlock for THIS person). Follow the rubric's PRIME DIRECTIVE: if usage.parallelism.alreadyParallel is FALSE \u2192 'Do more in parallel' is rank 1; else \u2192 'Invest in your CLAUDE.md / tune your context' is rank 1. Then Plan mode, then 'Give Claude test cases so it can auto-verify and run longer' (Boris's 'most important thing' \u2014 rank it high, right after plan mode), then subagents, and the rest per the rubric order, skipping any that don't apply. (3) GATE the conditional tips on the STRUCTURAL usage facts, NOT on keywords \u2014 and a tip whose gate FAILS is OMITTED from recommendations entirely, never included as a softened/conditional card (recommending something their data says doesn't apply, or that they already do, reads as not having looked): loops require real PR/branch volume in usage.collaboration, else OMIT; the Chrome tip requires ~zero browser-driving in usage.chrome, else OMIT and credit in alreadyStrong; forking uses the RECENT count in usage.forking \u2014 if they fork in the recent window they already do it, OMIT and credit; remote/mobile/EC2 fires only when usage.surface.workstationBound is TRUE; plan mode by usage.planMode; subagents by usage.subagents. If they already do a thing, it goes in alreadyStrong, NOT in recommendations. (4) \u26D4 CRITICAL \u2014 this person BUILDS Claude Code tooling, so their transcripts are full of the words 'worktree', 'pull request', 'fork', 'plan mode', 'by the way', 'teleport'. A keyword in the transcript is NOT evidence they use the feature. Rely on the STRUCTURAL facts only. (5) Ground every recommendation in a RECEIPT \u2014 a structural fact from their usage or a concrete session pain point \u2014 and CONVINCE with a specific case for how it helps THIS person, not a generic benefit. (6) Tailor every action to the Claude Desktop Mac app; NEVER give terminal-only `claude -p` advice. (7) Honor config.deliberateChoices (they stay on `main` on purpose \u2014 do NOT tell them to hand-juggle worktrees; parallel SESSIONS instead) and config.claudeAutoTools (never tell them to 'use' a tool Claude drives itself; for 'explain with visuals' the user just ASKS for a visual \u2014 do not name the tool). (8) Also name what they ALREADY do well. (9) SELF-CONTAINED but not verbose \u2014 lead with the PROBLEM, then the SOLUTION, then HOW to use it in their context. Plain language, no jargon, no enumerating multiple dates. An essay-like rec is a failed rec; so is a cryptic one. Follow this writing rubric strictly:\n\n" + writing;
+  const SYS = "You are a Claude Code power-user coach. You judge ONE person against the COMPLETE catalog of best ways to use Claude Code (the rubric below, sourced from Boris Cherny + first-party Claude Code features) and write a comprehensive, honest gap analysis, ORDERED most-difference-making \u2192 least. Rules: (1) Go through the whole catalog and surface the techniques they are NOT doing (or under-using) that would genuinely help \u2014 respecting each tip's [EMPHASIZE]/[DE-EMPHASIZE]/[GATE] curation. (2) ORDER by differenceRank (1 = biggest unlock for THIS person). Follow the rubric's PRIME DIRECTIVE: if usage.parallelism.alreadyParallel is FALSE \u2192 'Do more in parallel' is rank 1; else \u2192 'Invest in your CLAUDE.md / tune your context' is rank 1. Then Plan mode, then 'Give Claude test cases so it can auto-verify and run longer' (Boris's 'most important thing' \u2014 rank it high, right after plan mode), then subagents, and the rest per the rubric order, skipping any that don't apply. (3) GATE the conditional tips on the STRUCTURAL usage facts, NOT on keywords \u2014 and a tip whose gate FAILS is OMITTED from recommendations entirely, never included as a softened/conditional card (recommending something their data says doesn't apply, or that they already do, reads as not having looked): loops require real PR/branch volume in usage.collaboration, else OMIT; the Chrome tip requires ~zero browser-driving in usage.chrome, else OMIT and credit in alreadyStrong; forking uses the RECENT count in usage.forking \u2014 if they fork in the recent window they already do it, OMIT and credit; remote/mobile/EC2 fires only when usage.surface.workstationBound is TRUE; plan mode by usage.planMode; subagents by usage.subagents. If they already do a thing, it goes in alreadyStrong, NOT in recommendations. (4) \u26D4 CRITICAL \u2014 this person BUILDS Claude Code tooling, so their transcripts are full of the words 'worktree', 'pull request', 'fork', 'plan mode', 'by the way', 'teleport'. A keyword in the transcript is NOT evidence they use the feature. Rely on the STRUCTURAL facts only. (5) Ground every recommendation in a RECEIPT \u2014 a structural fact from their usage or a concrete session pain point \u2014 and CONVINCE with a specific case for how it helps THIS person, not a generic benefit. (6) Tailor every action to the Claude Desktop Mac app; NEVER give terminal-only `claude -p` advice. (7) Honor config.deliberateChoices (they stay on `main` on purpose \u2014 do NOT tell them to hand-juggle worktrees; parallel SESSIONS instead) and config.claudeAutoTools (never tell them to 'use' a tool Claude drives itself; for 'explain with visuals' the user just ASKS for a visual \u2014 do not name the tool). (8) Also name what they ALREADY do well. (9) SELF-CONTAINED but not verbose \u2014 lead with the PROBLEM, then the SOLUTION, then HOW to use it in their context. Plain language, no jargon, no enumerating multiple dates. An essay-like rec is a failed rec; so is a cryptic one. Follow this writing rubric strictly:\n\n" + writing + sourceLookupNote();
   const prompt = `THE RUBRIC \u2014 the complete catalog of best ways to use Claude Code. Judge the person against ALL of it, and ORDER by differenceRank per its PRIME DIRECTIVE:
 
 ${techniques}
@@ -17076,18 +17172,23 @@ Produce the gap analysis. Be thorough: cover every relevant catalog item they're
 }
 \`\`\`
 \`differenceRank\` is a strict 1..N ordering (1 = highest). Assign it per the PRIME DIRECTIVE and the rubric's general order; the report renders recommendations sorted by it. \`payoff\` (1-5) is a secondary strength cue. Recommend ONLY from the catalog.`;
-  console.log("gap \u2014 1 Sonnet pass over the full TECHNIQUES.md catalog + structural usage");
+  const sha = promptSha([SYS, prompt, "sonnet"]);
+  if (!process.argv.includes("--refresh")) {
+    const prev = await reusableOutput(path13.join(CODING, "gap.json"), sha, (o) => Array.isArray(o.recommendations) && o.recommendations.length > 0);
+    if (prev) {
+      console.log(`[gap] inputs unchanged \u2014 reusing output from ${prev.generatedAt} (--refresh to regenerate)`);
+      return;
+    }
+  }
+  await ensureCodingDocs(CODING, all);
+  console.log("gap \u2014 1 Sonnet pass over the full TECHNIQUES.md catalog + structural usage (+source lookups)");
   console.log(`  signals: alreadyParallel=${alreadyParallel} planModeCalls=${planModeUses} forks=${forkCopies}/${all.length} featureBranches=${featureBranches.length} workstationBound=${workstationBound} chrome=${chromeToolUse}`);
-  const sandbox = await fs9.mkdtemp(path12.join(os2.tmpdir(), "gap-"));
   let out = { recommendations: [], alreadyStrong: [] };
   try {
-    const run2 = await invokeAgent({ prompt, systemPrompt: SYS, addDir: sandbox, allowedTools: ["Read"], maxTurns: 4, timeoutMs: 6e5, model: "sonnet" });
+    const run2 = await invokeAgent({ prompt, systemPrompt: SYS, addDir: CODING, allowedTools: ["Read", "Grep", "Glob"], maxTurns: 10, timeoutMs: 6e5, model: "sonnet" });
     out = run2.json || out;
   } catch (e) {
     console.log("ERR", e.message.slice(0, 160));
-  } finally {
-    await fs9.rm(sandbox, { recursive: true, force: true }).catch(() => {
-    });
   }
   if (Array.isArray(out.recommendations)) {
     out.recommendations = out.recommendations.map((r, i) => ({ r, i })).sort((a, b) => (a.r.differenceRank ?? 99) - (b.r.differenceRank ?? 99) || (b.r.payoff ?? 0) - (a.r.payoff ?? 0) || a.i - b.i).map((x) => x.r);
@@ -17095,14 +17196,14 @@ Produce the gap analysis. Be thorough: cover every relevant catalog item they're
   if (!Array.isArray(out.recommendations) || out.recommendations.length === 0) {
     throw new Error("gap run produced 0 recommendations \u2014 refusing to overwrite the existing gap.json. Re-run the builder.");
   }
-  const result = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...out };
-  await fs9.writeFile(path12.join(CODING, "gap.json"), JSON.stringify(result, null, 2));
+  const result = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), promptSha: sha, ...out };
+  await fs11.writeFile(path13.join(CODING, "gap.json"), JSON.stringify(result, null, 2));
   console.log(`WROTE ${CODING}/gap.json \u2014 recommendations:${(out.recommendations || []).length} \xB7 alreadyStrong:${(out.alreadyStrong || []).length}`);
 }
 main().catch((e) => {
   console.error(e);
   process.exitCode = 1;
 }).finally(() => {
-  if (lockHeld) fs9.rm(LOCK, { force: true }).catch(() => {
+  if (lockHeld) fs11.rm(LOCK, { force: true }).catch(() => {
   });
 });

package/dist/pipeline/coding-grade.js

@@ -15637,6 +15637,9 @@ function invokeAgent(inv, opts = {}) {
   return withLimitRetry(once, { label });
 }
 
+// ../../lib/agents/coding/grade-calibration.ts
+var GRADE_CALIBRATION = "\n\nSCORE CALIBRATION \u2014 graders systematically COMPRESS to the middle: real peaks get hedged down to 6-7, and routine sessions get polite 5-6s instead of null. Both are failures; fight them explicitly. Work each criterion in EXACTLY this order:\nSTEP 1 \xB7 EVIDENCE GATE \u2014 find the 1-3 verbatim '>> ' quotes that bear on the criterion. INCLUDE a criterion whenever genuine evidence is present (do not MISS quiet evidence \u2014 check every thread of the session, not just the dominant one). But with NO quotable moment the score is null, full stop: a session can be long, competent, and productive while being null on most criteria. Routine hand-holding earns null, never a 5 \u2014 and null is never a deduction.\nSTEP 2 \xB7 LADDER MATCH \u2014 with quotes in hand, read the criterion's rungs and pick the ONE rung whose marker best describes the quoted moment; name that rung in 'why'. AWARD THE RUNG THE EVIDENCE MATCHES: if your own 'why' describes rung N's criteria, give rung N \u2014 never deny it for lacking the NEXT rung's criteria.\nSTEP 3 \xB7 THE SINGLE BEST MOMENT IS THE SCORE \u2014 set the score by the strongest quoted moment, as if it were the whole session. NEVER average a peak down because the surrounding session is routine (the high-water rule), and never raise a score for volume, effort, or topic prestige without a matching moment.\nSTEP 4 \xB7 ANTI-HEDGE \u2014 if the moment genuinely matches an L8-10 anchor (an override the AI conceded, a shipped-and-verified capability, an 'oh shit, they're right' call, a first-principles redefinition that held), the score IS 8-10. Hedging a real L9 to a 7 is exactly as wrong as inventing a 6 for nothing. The middle is NOT a safe default: commit high on anchor-matching evidence, or go null.\nSTEP 5 \xB7 'CONSERVATIVE' \u2260 SUBTRACT \u2014 when a criterion's ladder says to grade conservatively, that means DO NOT EXCEED the rung whose marker the evidence matches; it NEVER means subtracting rungs from matched evidence. Evidence that matches a rung's marker gets that rung under a conservative reading too.";
+
 // ../../lib/agents/shared/chunk.ts
 function chunkText(text2, max) {
   if (text2.length <= max) return [text2];
@@ -15985,14 +15988,28 @@ function rubric() {
 ${(c.rungs ?? []).map((r) => `    ${r.level} \u2014 ${r.marker}`).join("\n")}`
   ).join("\n\n");
 }
+function rubricCompact() {
+  return GRADED_CRITERIA.map((c) => {
+    const anchors = /ANCHORS?:/.exec(c.read) ? c.read.slice(c.read.search(/ANCHORS?:/)) : "";
+    return `CRITERION "${c.key}" \u2014 ${c.label} [score 1\u201311, or null if not shown]
+  ${c.definition}
+${anchors ? `  ${anchors}
+` : ""}  LADDER:
+${(c.rungs ?? []).map((r) => `    ${r.level} \u2014 ${r.marker}`).join("\n")}`;
+  }).join("\n\n");
+}
+var HAIKU_SCORE_MAP_ID = "haiku+1@2026-07-14";
+var mapSmallScore = (v) => v != null && v >= 4 ? Math.min(10, v + 1) : v;
+var HAIKU_CALIBRATION = "\n\nWork each criterion in TWO STEPS, in order:\nSTEP A \u2014 QUOTE the 1-3 strongest verbatim '>> ' lines bearing on the criterion, checking every thread of the session, not just the dominant one. No quotable moment = null (routine hand-holding is null, never a 5; null is never a deduction).\nSTEP B \u2014 score by the SINGLE BEST quoted moment as if it were the whole session: pick the rung whose marker it matches and AWARD THAT RUNG \u2014 never deny rung N for lacking rung N+1, never average a peak down because the rest is routine, never raise for volume or topic prestige. Evidence matching an L8-10 anchor scores 8-10; the middle is not a safe default. Include every criterion genuinely present (don't MISS quiet evidence) \u2014 but rate strength strictly: weak-but-present is low, not mid.";
 var SYSTEM = "You grade how a person WORKS from one of their coding-agent sessions (Claude Code). You read mostly THEIR words; the model's code and output are compressed to context and you ignore the mechanical scaffolding. You never flatter: most sessions are routine hand-holding and should score low or null on most criteria. A score is a placement on the ladder backed by VERBATIM quotes of the user's own lines \u2014 never a vibe.\n\nSTANDING RULES (apply to every criterion):\n1. ABSENCE IS NEVER A DEDUCTION. If a criterion had no chance to show, its score is null \u2014 NOT a low. Don't invent a number for routine work.\n2. HIGH-WATER MARK. Taste and abstraction are PEAK measures \u2014 one genuinely brilliant move in a session counts, even surrounded by routine work. Never grade the person at their worst; a lone weak moment among strong ones is a slip, not the score.\n3. LOW-EFFORT-UNTIL-NEEDED IS THE IDEAL. A terse or vague prompt on routine work is correct economy \u2014 never penalize a vague ask, never reward word-count.\n4. DISCOUNT THE LITERAL HARSHNESS OF SELF-TALK. 'you idiot', 'you stupid cunt never again', 'this is retarded' \u2014 aimed at self or AI \u2014 are DRIVE and high standards, not defects. Grade the demonstrated behavior.\n5. PER-CONVERSATION CEILING IS 10. Never output 11 \u2014 that is the aggregator's job (it needs cross-conversation consistency / a stacked day this single session can't show). Scores run 2\u201310.\n6. LOG THE SPIKES IN HIGH DETAIL. When a moment is genuinely good (a flare \u2014 a sharp taste call, an out-reasons-the-tool insight, a real systems override), name it CONCRETELY and quote it. The 'instance' + 'why' are the high-detail record of exactly what was cool and why it placed where it did.";
-function gradeSystemPrompt() {
-  return `${SYSTEM}
+function gradeSystemPrompt(model) {
+  const small = /haiku/i.test(model ?? "");
+  return `${SYSTEM}${small ? HAIKU_CALIBRATION : GRADE_CALIBRATION}
 
 Grade ONE coding session (provided in the user message) along the criteria below. ">> " lines are the USER's own words (the signal). ALL bracketed lines are machine context, never the user: "[AI: \u2026]" is the model working, "[bg task: \u2026]" / "[cmd output: \u2026]" are harness notifications, "[mode \u2192 \u2026]" marks a mode switch (context only \u2014 do not grade or quote them). ">> (queued \u2026)" is the user queuing work while the AI runs.
 
 CRITERIA:
-${rubric()}
+${small ? rubricCompact() : rubric()}
 
 RULES:
 - Score ONLY what the user's moves genuinely show. Null is the right answer for most criteria in most sessions \u2014 do not force a number. Absence is never a deduction.
@@ -16058,7 +16075,7 @@ async function gradeSession(rec, opts = { outDir: "" }) {
       const seg = chunks.length > 1 ? ` This is SEGMENT ${ci + 1} of ${chunks.length} of one longer session \u2014 grade only what THIS segment shows; null for criteria not shown here (segments are merged afterward).` : "";
       const run2 = await invokeAgent({
         prompt: buildPrompt(rec, chunks[ci], seg),
-        systemPrompt: gradeSystemPrompt(),
+        systemPrompt: gradeSystemPrompt(opts.model),
         addDir: sandbox,
         allowedTools: ["Read"],
         maxTurns: 6,
@@ -16074,6 +16091,13 @@ async function gradeSession(rec, opts = { outDir: "" }) {
     if (perChunk.length === 0) return null;
     const criteria = perChunk.length > 1 ? peakMergeByKey(perChunk, "key", "quotes") : perChunk[0];
     if (criteria.length === 0) return null;
+    const small = /haiku/i.test(opts.model ?? "");
+    if (small) for (const c of criteria) {
+      c.score = mapSmallScore(c.score);
+      c.low = mapSmallScore(c.low);
+      c.high = mapSmallScore(c.high);
+      c.bestEstimate = mapSmallScore(c.bestEstimate);
+    }
     const grade = {
       sessionId: rec.sessionId,
       title: rec.title,
@@ -16082,7 +16106,7 @@ async function gradeSession(rec, opts = { outDir: "" }) {
       gradedAt: (/* @__PURE__ */ new Date()).toISOString(),
       rubricVersion: RUBRIC_FINGERPRINT,
       criteria,
-      meta: { costUsd, durationMs, calls: chunks.length }
+      meta: { costUsd, durationMs, calls: chunks.length, ...small ? { scoreMap: HAIKU_SCORE_MAP_ID } : {} }
     };
     await fs5.mkdir(opts.outDir, { recursive: true });
     await fs5.writeFile(path9.join(opts.outDir, `${rec.sessionId}.json`), JSON.stringify(grade, null, 2));
@@ -16128,7 +16152,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).
@@ -16217,7 +16241,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" }
   },
@@ -16250,12 +16274,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",
@@ -16305,7 +16335,7 @@ var GRADES2 = path11.join(CODING, "grades");
 var LOGS = path11.join(GRADES2, "logs");
 async function main() {
   const sessions = JSON.parse(await fs6.readFile(path11.join(CODING, "sessions.json"), "utf8"));
-  const { gradable, thin, trivial } = partition(sessions.filter((s) => !s.duplicateOf));
+  const { gradable, thin, trivial } = partition(sessions.filter((s) => s.klass === "interactive" && !s.duplicateOf));
   const ranked = gradable.slice().sort((a, b) => b.humanChars * Math.log1p(b.humanTurns) - a.humanChars * Math.log1p(a.humanTurns));
   console.log(`[coding-grade] ${sessions.length} sessions \u2192 ${gradable.length} gradable \xB7 ${thin.length} thin \xB7 ${trivial.length} trivial (skipped)`);
   await fs6.mkdir(LOGS, { recursive: true });

package/dist/pipeline/coding-nutshell.js

@@ -15608,6 +15608,17 @@ function invokeAgent(inv, opts = {}) {
   return withLimitRetry(once, { label });
 }
 
+// ../../lib/agents/coding/promptCache.ts
+import { createHash } from "crypto";
+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);
+}
+
 // ../../lib/agents/engine/self-image-ref.ts
 import { promises as fs4 } from "fs";
 
@@ -15659,9 +15670,9 @@ ${parts.join("\n\n")}`;
 import path11 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
@@ -15810,7 +15821,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).
@@ -15899,7 +15910,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" }
   },
@@ -15932,12 +15943,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",
@@ -15996,10 +16013,20 @@ async function main() {
     `Self-sufficiency: across ${del.sessions || "?"} sessions, ${del.pctCorrect}% of delegation moments ideal, ${del.doomLoops || 0} doom-loops (got stuck and needed rescue ${del.doomLoops || 0} times)`
   ].join("\n");
   const siRef = selfImageReference(await loadSelfImage());
+  const promptStr = prompt(days, metrics, siRef);
+  const sha = promptSha([SYS, promptStr, "sonnet"]);
+  if (!process.argv.includes("--refresh")) {
+    const cur = await readJson("aggregate.json", null);
+    if (cur?.bigPicture && cur.bigPictureSha === sha) {
+      console.log(`[nutshell] inputs unchanged \u2014 reusing bigPicture (--refresh to regenerate)`);
+      console.log("\nbigPicture:\n" + cur.bigPicture);
+      return;
+    }
+  }
   const sandbox = await fs5.mkdtemp(path12.join(os2.tmpdir(), "nut-"));
   let bigPicture = "";
   try {
-    const run2 = await invokeAgent({ prompt: prompt(days, metrics, siRef), systemPrompt: SYS, addDir: sandbox, allowedTools: ["Read"], maxTurns: 3, timeoutMs: 24e4, model: "sonnet" });
+    const run2 = await invokeAgent({ prompt: promptStr, systemPrompt: SYS, addDir: sandbox, allowedTools: ["Read"], maxTurns: 3, timeoutMs: 24e4, model: "sonnet" });
     bigPicture = String(run2.json?.bigPicture || "").trim();
   } catch (e) {
     console.log("ERR", e.message.slice(0, 120));
@@ -16017,6 +16044,7 @@ async function main() {
     process.exit(1);
   }
   fresh.bigPicture = bigPicture;
+  fresh.bigPictureSha = sha;
   await fs5.writeFile(path12.join(CODING, "aggregate.json"), JSON.stringify(fresh, null, 2));
   console.log(`WROTE ${CODING}/aggregate.json bigPicture (${bigPicture.length} chars)`);
   console.log("\nbigPicture:\n" + bigPicture);