polymath-society 0.2.4 → 0.2.5

package/dist/pipeline/coding-grade.js

@@ -135,7 +135,7 @@ var require_secure_json_parse = __commonJS({
 
 // ../../scripts/coding-grade.mts
 import { promises as fs6 } from "fs";
-import path10 from "path";
+import path11 from "path";
 
 // ../../lib/agents/coding/grade.ts
 import { promises as fs5 } from "fs";
@@ -2155,8 +2155,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2272,11 +2272,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() {
@@ -15063,39 +15063,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
   });
@@ -15116,7 +15116,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
     });
@@ -16116,6 +16116,165 @@ function partition(sessions) {
   return { gradable, thin, trivial };
 }
 
+// ../../lib/agents/coding/profile.ts
+import path10 from "path";
+
+// ../../lib/agents/coding/walkthrough.ts
+var IDLE_CAP_MS = 12 * 6e4;
+
+// ../coding-core/dist/words.js
+var NOTE = "((ran|created|edited|read|wrote|searched) (a|an|\\d+) [a-z]+|updated todos)";
+var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s*thought for .{1,30}$`, "im");
+
+// ../../lib/calibration/index.ts
+var DEFAULT_CALIBRATION = {
+  version: "2026-07-12.2",
+  // = RUBRIC_FINGERPRINT of the shipped npm rubric (packages/coding-analyzer/
+  // src/grade/criteria.ts). A unit test fails loud when the rubric changes
+  // without this being updated (and re-pushed to the server).
+  rubricVersion: "f51b3a93a3",
+  // Canonical scale = the one the product owner set for the public report
+  // (11=0.01% … 8=2%), extended downward from the old report ladder. The old
+  // CodeAnalysisView / npm-viewer maps (7→10%/15%, 6→25%/30%) were drift, not
+  // intent.
+  scoreBands: [
+    { score: 11, label: "Top 0.01%" },
+    { score: 10, label: "Top 0.1%" },
+    { score: 9, label: "Top 0.5%" },
+    { score: 8, label: "Top 2%" },
+    { score: 7, label: "Top 5%" },
+    { score: 6, label: "Top 15%" },
+    { score: 5, label: "Top 50%" },
+    { score: 4, label: "Top 65%" },
+    { score: 3, label: "Top 80%" },
+    { score: 2, label: "Top 90%" },
+    { score: 1, label: "Top 97%" }
+  ],
+  minRankedScore: 6,
+  benchmarkBands: [
+    {
+      level: "11",
+      name: "Superhuman",
+      rank: "Top 0.01%",
+      oneIn: "1 in 10,000+",
+      meaning: "Beyond the normal human ceiling for the trait \u2014 the genuine power-law outlier. Almost no one earns this; when the evidence shows it, it is scored, not rounded down.",
+      foundIn: [
+        "Fields Medal and Nobel-track researchers",
+        "Founders of generational companies",
+        "The handful of people a frontier field is named after"
+      ],
+      maxTopPct: 0.01
+    },
+    {
+      level: "10",
+      name: "World-class",
+      rank: "Top 0.1%",
+      oneIn: "1 in 1,000",
+      meaning: "Among the best alive at this trait \u2014 the level entire institutions are built to find.",
+      foundIn: [
+        "Researchers at frontier AI labs",
+        "Faculty at top-5 research universities",
+        "IMO / IOI medalists",
+        "Founders backed by the top decile of venture firms"
+      ],
+      maxTopPct: 0.1
+    },
+    {
+      level: "9",
+      name: "Exceptional",
+      rank: "Top 1%",
+      oneIn: "1 in 100",
+      meaning: "Clearly exceptional \u2014 the strongest person on most strong teams.",
+      foundIn: [
+        "PhD students at top programs",
+        "Early engineers at breakout startups",
+        "YC-class founders",
+        "National olympiad finalists"
+      ],
+      maxTopPct: 1
+    },
+    {
+      level: "8",
+      name: "Strong",
+      rank: "Top 10%",
+      oneIn: "1 in 10",
+      meaning: "Strong against the whole population \u2014 the best person in most rooms, not every room.",
+      foundIn: [
+        "Senior engineers at selective tech companies",
+        "Graduates of demanding technical programs",
+        "Operators who get promoted everywhere they go"
+      ],
+      maxTopPct: 10
+    },
+    {
+      level: "5",
+      name: "Median",
+      rank: "50th percentile",
+      oneIn: "1 in 2",
+      meaning: 'The middle of the general population. The reference class is all ~8 billion humans \u2014 so even "strong" above already means top 10% of everyone.',
+      foundIn: ["The general population \u2014 most people, most places"],
+      maxTopPct: 100
+    }
+  ],
+  codingTiers: {
+    push: { median: 300, sigma: 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." },
+    focus: { median: 0.08, sigma: 0.559, tag: "estimated \u2014 proxy-anchored", source: "median: Anthropic 20h/week engaged-user figure implies ~1h/day of true rapid exchange against an 8h working day; ceiling anchored to the ~4h/day deep-work limit (45% share = 1-in-1,000). AVERAGE share, cumulative not spiky." },
+    orchestration: { tag: "estimated \u2014 behavior bands", source: "no published concurrency distribution exists; ceiling anchored to the Claude Code lead's documented 10-15 parallel sessions" }
+  },
+  codingBenchmarks: {
+    flow: {
+      // typical knowledge worker ≈ 35% of an 8h day focused; ~4h/day is the
+      // recognized deep-work ceiling (Newport) ≈ 50% — most sit far below it.
+      typicalPctOfDay: 0.35,
+      topPctOfDay: 0.5,
+      tag: "measured",
+      source: "RescueTime 2019 (~2h48m focused/day) \xB7 Cal Newport, Deep Work (~4h/day deep-work ceiling)",
+      line: "the best spend ~half the workday in true deep flow; ~4h/day is the human ceiling"
+    },
+    longestRun: {
+      typicalHours: 0.67,
+      // ~40 min before the average worker is interrupted
+      topHours: 4,
+      tag: "measured",
+      source: "RescueTime (avg max ~40 min focus before interruption) \xB7 deep-work single-block ceiling ~3\u20134h",
+      line: "a top performer can hold a single ~3\u20134h uninterrupted block; the average worker breaks at ~40 min"
+    },
+    parallelism: {
+      topMaxConcurrent: 12,
+      // Boris Cherny ~10–15 interactive sessions
+      topAvgConcurrent: 6,
+      // time-weighted average while active (anecdotal, same source)
+      worktreesTip: "3\u20135 git worktrees at once",
+      tag: "anecdotal",
+      source: "Boris Cherny (Claude Code lead, Anthropic): ~10\u201315 concurrent sessions, 'dozens of Claudes running at all times'; 3\u20135 worktrees = 'the single biggest productivity unlock'",
+      line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
+    },
+    throughput: {
+      // 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,
+      benchLabel: "top 0.1%",
+      // No published "words typed/day" for heavy users — the real story is OUTPUT.
+      loopsHeadline: ">1,000,000 lines of Rust at 99.8% tests passing",
+      loopsDetail: "the Bun runtime was ported Zig\u2192Rust largely autonomously \u2014 hundreds of parallel subagents, two AI reviewers per file",
+      tag: "measured",
+      source: "The Register, May 2026 (Bun Zig\u2192Rust rewrite)",
+      line: "autonomous fleets ported >1M lines of Rust at 99.8% tests passing; a while-loop agent delivered a $50k contract for $297 of compute"
+    }
+  }
+};
+
+// ../../lib/agents/coding/benchmarks.ts
+var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
+
+// ../../lib/agents/coding/profile.ts
+var ROOT = process.cwd();
+var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path10.join(process.env.POLYMATH_DATA_DIR, "coding") : path10.join(ROOT, ".data", "coding");
+var GRADES = path10.join(CODING_DIR, "grades");
+
 // ../../scripts/coding-grade.mts
 var argv = process.argv.slice(2);
 var flag = (n, d) => {
@@ -16141,11 +16300,11 @@ function makeLimiter(max) {
     }
   };
 }
-var CODING = path10.join(process.cwd(), ".data", "coding");
-var GRADES = path10.join(CODING, "grades");
-var LOGS = path10.join(GRADES, "logs");
+var CODING = CODING_DIR;
+var GRADES2 = path11.join(CODING, "grades");
+var LOGS = path11.join(GRADES2, "logs");
 async function main() {
-  const sessions = JSON.parse(await fs6.readFile(path10.join(CODING, "sessions.json"), "utf8"));
+  const sessions = JSON.parse(await fs6.readFile(path11.join(CODING, "sessions.json"), "utf8"));
   const { gradable, thin, trivial } = partition(sessions.filter((s) => !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)`);
@@ -16155,12 +16314,13 @@ async function main() {
   for (const s of ranked) {
     if (picked.length >= limit) break;
     if (!REGRADE) {
-      const done = await fs6.readFile(path10.join(GRADES, `${s.sessionId}.json`), "utf8").catch(() => null);
+      const done = await fs6.readFile(path11.join(GRADES2, `${s.sessionId}.json`), "utf8").catch(() => null);
       if (done) continue;
     }
     picked.push(s);
   }
   console.log(`[coding-grade] grading ${picked.length}${ALL ? " (ALL gradable, resuming)" : ""} on ${MODEL}, conc ${CONC}\u2026`);
+  console.log(`  (each session below is a single small ${MODEL} call \u2014 a long run is many tiny calls, not a huge one)`);
   const lim = makeLimiter(CONC);
   startRun("coding-grade", picked.length);
   let doneN = 0, sumUsd = 0, sumCalls = 0;
@@ -16168,19 +16328,19 @@ async function main() {
   await Promise.all(picked.map((s) => lim(async () => {
     const t0 = Date.now();
     try {
-      const g = await gradeSession(s, { model: MODEL, outDir: GRADES, logDir: LOGS });
+      const g = await gradeSession(s, { model: MODEL, outDir: GRADES2, logDir: LOGS });
       tick(!!g);
       if (!g) {
         console.log(`  \u2022 "${s.title.slice(0, 48)}" \u2014 skipped (no usable grade)`);
         return;
       }
       const scored = g.criteria.filter((c) => c.score != null).map((c) => `${c.key}=${c.score}`).join(" ");
-      console.log(`  \u2022 "${s.title.slice(0, 48)}" done ${(Date.now() - t0) / 1e3 | 0}s $${g.meta.costUsd?.toFixed(2) ?? "?"} \xB7 ${g.meta.calls ?? "?"} call(s) \u2192 ${scored || "(all null)"}`);
+      console.log(`  \u2022 "${s.title.slice(0, 48)}" done ${(Date.now() - t0) / 1e3 | 0}s \u2192 ${scored || "(all null)"}`);
       doneN++;
       sumUsd += g.meta.costUsd ?? 0;
       sumCalls += g.meta.calls ?? 0;
       const elapsedMin = (Date.now() - runT0) / 6e4;
-      console.log(`    \u03A3 ${doneN}/${picked.length} \xB7 $${sumUsd.toFixed(2)} \xB7 ${sumCalls} calls \xB7 ${elapsedMin.toFixed(0)}m \u2192 projected $${(sumUsd / doneN * picked.length).toFixed(0)} / ${(elapsedMin / doneN * picked.length / 60).toFixed(1)}h for this run`);
+      console.log(`    \u03A3 ${doneN}/${picked.length} \xB7 ${elapsedMin.toFixed(0)}m elapsed \u2192 ~${(elapsedMin / doneN * picked.length / 60).toFixed(1)}h total for this run (small ${MODEL} calls)`);
     } catch (e) {
       tick(false);
       console.log(`  \u2022 "${s.title.slice(0, 48)}" ERROR ${e.message.slice(0, 60)}`);