polymath-society 0.2.4 → 0.2.6

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
     });
@@ -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));
@@ -16116,6 +16140,171 @@ 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-14.2",
+  // = RUBRIC_FINGERPRINT of the shipped npm rubric (packages/coding-analyzer/
+  // src/grade/criteria.ts). A unit test fails loud when the rubric changes
+  // without this being updated (and re-pushed to the server).
+  rubricVersion: "f51b3a93a3",
+  // Canonical scale = the one the product owner set for the public report
+  // (11=0.01% … 8=2%), extended downward from the old report ladder. The old
+  // CodeAnalysisView / npm-viewer maps (7→10%/15%, 6→25%/30%) were drift, not
+  // intent.
+  scoreBands: [
+    { score: 11, label: "Top 0.01%" },
+    { score: 10, label: "Top 0.1%" },
+    { score: 9, label: "Top 0.5%" },
+    { score: 8, label: "Top 2%" },
+    { score: 7, label: "Top 5%" },
+    { score: 6, label: "Top 15%" },
+    { score: 5, label: "Top 50%" },
+    { score: 4, label: "Top 65%" },
+    { score: 3, label: "Top 80%" },
+    { score: 2, label: "Top 90%" },
+    { score: 1, label: "Top 97%" }
+  ],
+  minRankedScore: 6,
+  benchmarkBands: [
+    {
+      level: "11",
+      name: "Superhuman",
+      rank: "Top 0.01%",
+      oneIn: "1 in 10,000+",
+      meaning: "Beyond the normal human ceiling for the trait \u2014 the genuine power-law outlier. Almost no one earns this; when the evidence shows it, it is scored, not rounded down.",
+      foundIn: [
+        "Fields Medal and Nobel-track researchers",
+        "Founders of generational companies",
+        "The handful of people a frontier field is named after"
+      ],
+      maxTopPct: 0.01
+    },
+    {
+      level: "10",
+      name: "World-class",
+      rank: "Top 0.1%",
+      oneIn: "1 in 1,000",
+      meaning: "Among the best alive at this trait \u2014 the level entire institutions are built to find.",
+      foundIn: [
+        "Researchers at frontier AI labs",
+        "Faculty at top-5 research universities",
+        "IMO / IOI medalists",
+        "Founders backed by the top decile of venture firms"
+      ],
+      maxTopPct: 0.1
+    },
+    {
+      level: "9",
+      name: "Exceptional",
+      rank: "Top 1%",
+      oneIn: "1 in 100",
+      meaning: "Clearly exceptional \u2014 the strongest person on most strong teams.",
+      foundIn: [
+        "PhD students at top programs",
+        "Early engineers at breakout startups",
+        "YC-class founders",
+        "National olympiad finalists"
+      ],
+      maxTopPct: 1
+    },
+    {
+      level: "8",
+      name: "Strong",
+      rank: "Top 10%",
+      oneIn: "1 in 10",
+      meaning: "Strong against the whole population \u2014 the best person in most rooms, not every room.",
+      foundIn: [
+        "Senior engineers at selective tech companies",
+        "Graduates of demanding technical programs",
+        "Operators who get promoted everywhere they go"
+      ],
+      maxTopPct: 10
+    },
+    {
+      level: "5",
+      name: "Median",
+      rank: "50th percentile",
+      oneIn: "1 in 2",
+      meaning: 'The middle of the general population. The reference class is all ~8 billion humans \u2014 so even "strong" above already means top 10% of everyone.',
+      foundIn: ["The general population \u2014 most people, most places"],
+      maxTopPct: 100
+    }
+  ],
+  codingTiers: {
+    push: { median: 300, sigma: 0.91, tag: "estimated \u2014 log-normal fit", source: "Anthropic 2026 Claude Code study (400k sessions): median engaged user ~8 prompts/day at ~35 words \u2014 ~300 directed words/day; tail: a 1-in-1,000 user AVERAGES ~5k directed words/day (near-daily heavy dictation, clearly below the ~10k single-day record). AVERAGE over substantial days, cumulative not spiky." },
+    focus: { median: 0.08, sigma: 0.559, tag: "estimated \u2014 proxy-anchored", source: "median: Anthropic 20h/week engaged-user figure implies ~1h/day of true rapid exchange against an 8h working day; ceiling anchored to the ~4h/day deep-work limit (45% share = 1-in-1,000). AVERAGE share, cumulative not spiky." },
+    orchestration: { tag: "estimated \u2014 behavior bands", source: "no published concurrency distribution exists; ceiling anchored to the Claude Code lead's documented 10-15 parallel sessions" }
+  },
+  codingBenchmarks: {
+    flow: {
+      // typical knowledge worker ≈ 35% of an 8h day focused; ~4h/day is the
+      // recognized deep-work ceiling (Newport) ≈ 50% — most sit far below it.
+      typicalPctOfDay: 0.35,
+      topPctOfDay: 0.5,
+      tag: "measured",
+      source: "RescueTime 2019 (~2h48m focused/day) \xB7 Cal Newport, Deep Work (~4h/day deep-work ceiling)",
+      line: "the best spend ~half the workday in true deep flow; ~4h/day is the human ceiling"
+    },
+    longestRun: {
+      typicalHours: 0.67,
+      // ~40 min before the average worker is interrupted
+      topHours: 4,
+      tag: "measured",
+      source: "RescueTime (avg max ~40 min focus before interruption) \xB7 deep-work single-block ceiling ~3\u20134h",
+      line: "a top performer can hold a single ~3\u20134h uninterrupted block; the average worker breaks at ~40 min"
+    },
+    parallelism: {
+      topMaxConcurrent: 12,
+      // Boris Cherny ~10–15 interactive sessions
+      topAvgConcurrent: 6,
+      // time-weighted average while active (anecdotal, same source)
+      worktreesTip: "3\u20135 git worktrees at once",
+      tag: "anecdotal",
+      source: "Boris Cherny (Claude Code lead, Anthropic): ~10\u201315 concurrent sessions, 'dozens of Claudes running at all times'; 3\u20135 worktrees = 'the single biggest productivity unlock'",
+      line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
+    },
+    throughput: {
+      // Two DIFFERENT kinds of line (2026-07-14.2): topAvg is a PERCENTILE
+      // claim — what a 1-in-1,000 user AVERAGES over substantial days (5k/day:
+      // near-daily heavy dictation; a measured top dictating power user
+      // averages ~3.9k). topPeak is NOT a percentile — it is the CEILING
+      // reference, the wildest single days on record (~10k: a 14-16h
+      // launch-day marathon), rendered as "wildest single days", never
+      // "top X% peak". An avg-percentile and a peak-percentile can't both be
+      // shown at a same-ish value (avg≈peak reads broken — user call), and a
+      // peak PERCENTILE line is unknowable anyway; the record framing is
+      // honest and keeps the visual gap.
+      topAvgWordsPerDay: 5e3,
+      topPeakWordsPerDay: 1e4,
+      benchLabel: "top 0.1%",
+      // No published "words typed/day" for heavy users — the real story is OUTPUT.
+      loopsHeadline: ">1,000,000 lines of Rust at 99.8% tests passing",
+      loopsDetail: "the Bun runtime was ported Zig\u2192Rust largely autonomously \u2014 hundreds of parallel subagents, two AI reviewers per file",
+      tag: "measured",
+      source: "The Register, May 2026 (Bun Zig\u2192Rust rewrite)",
+      line: "autonomous fleets ported >1M lines of Rust at 99.8% tests passing; a while-loop agent delivered a $50k contract for $297 of compute"
+    }
+  }
+};
+
+// ../../lib/agents/coding/benchmarks.ts
+var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
+
+// ../../lib/agents/coding/profile.ts
+var ROOT = process.cwd();
+var CODING_DIR = process.env.POLYMATH_DATA_DIR ? 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,12 +16330,12 @@ 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 { gradable, thin, trivial } = partition(sessions.filter((s) => !s.duplicateOf));
+  const sessions = JSON.parse(await fs6.readFile(path11.join(CODING, "sessions.json"), "utf8"));
+  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 });
@@ -16155,12 +16344,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 +16358,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)}`);