polymath-society 0.2.12 → 0.2.14

package/dist/cli.js

@@ -1047,7 +1047,7 @@ var init_backends = __esm({
 });
 
 // src/grade/cliAdapter.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function toolTarget(input) {
   return String(input.file_path ?? input.path ?? input.pattern ?? input.query ?? input.command ?? "");
 }
@@ -1090,7 +1090,7 @@ var init_cliAdapter = __esm({
         let costUsd;
         let numTurns;
         await new Promise((resolve2, reject) => {
-          const child = spawn(bin, args, {
+          const child = spawn2(bin, args, {
             cwd: inv.cwd ?? inv.addDir,
             // scrubbed: a stray ANTHROPIC_API_KEY in the user's shell hijacks the
             // claude CLI away from their claude.ai login (coding-core/env.ts)
@@ -1193,7 +1193,12 @@ var init_cliAdapter = __esm({
 });
 
 // src/grade/codexAdapter.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
+function mapCodexTier(model, env = process.env) {
+  if (model && !/^(claude|haiku|sonnet|opus)/i.test(model)) return { model };
+  if (model && /^haiku/i.test(model)) return { model: env.POLYMATH_CODEX_MODEL_MINI || CODEX_MINI_MODEL };
+  return { model: env.POLYMATH_CODEX_MODEL || CODEX_DEFAULT_MODEL };
+}
 function composePrompt(inv, roots) {
   return [
     inv.systemPrompt ? `<system>
@@ -1204,12 +1209,14 @@ ${roots.map((r) => `  - ${r}`).join("\n")}` : "",
     inv.prompt
   ].filter(Boolean).join("\n\n");
 }
-var codexAdapter;
+var CODEX_DEFAULT_MODEL, CODEX_MINI_MODEL, codexAdapter;
 var init_codexAdapter = __esm({
   "src/grade/codexAdapter.ts"() {
     "use strict";
     init_adapter();
     init_backends();
+    CODEX_DEFAULT_MODEL = "gpt-5.5";
+    CODEX_MINI_MODEL = "gpt-5.4-mini";
     codexAdapter = {
       name: "codex",
       async run(inv) {
@@ -1227,7 +1234,7 @@ var init_codexAdapter = __esm({
           "read-only",
           "--json"
         ];
-        if (inv.model && !/^claude/i.test(inv.model)) args.push("--model", inv.model);
+        args.push("--model", mapCodexTier(inv.model).model);
         args.push(composePrompt(inv, roots));
         const started = Date.now();
         const toolCalls = [];
@@ -1235,7 +1242,7 @@ var init_codexAdapter = __esm({
         let resultText = "";
         let numTurns = 0;
         await new Promise((resolve2, reject) => {
-          const child = spawn2(bin, args, { cwd, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+          const child = spawn3(bin, args, { cwd, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
           let buf = "";
           let err = "";
           const timeoutMs = inv.timeoutMs ?? 3e5;
@@ -1541,15 +1548,15 @@ var init_exportLinks = __esm({
 });
 
 // src/notify.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 function systemNotify(title, body) {
   try {
     const opts = { stdio: "ignore" };
     if (process.platform === "darwin") {
-      spawn8("osascript", ["-e", `display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)} sound name "Glass"`], opts).on("error", () => {
+      spawn9("osascript", ["-e", `display notification ${JSON.stringify(body)} with title ${JSON.stringify(title)} sound name "Glass"`], opts).on("error", () => {
       });
     } else if (process.platform === "linux") {
-      spawn8("notify-send", [title, body], opts).on("error", () => {
+      spawn9("notify-send", [title, body], opts).on("error", () => {
       });
     }
   } catch {
@@ -2646,7 +2653,19 @@ try {
 import { promises as fs36, existsSync as existsSync7 } from "fs";
 import path41 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn9 } from "child_process";
+
+// src/openBrowser.ts
+import { spawn } from "child_process";
+function openBrowser(url, cmd) {
+  const bin = cmd ?? (process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open");
+  try {
+    const child = spawn(bin, [url], { stdio: "ignore", detached: true });
+    child.on("error", () => console.log(`  (couldn't open a browser here \u2014 open ${url} yourself)`));
+    child.unref();
+  } catch {
+    console.log(`  (couldn't open a browser here \u2014 open ${url} yourself)`);
+  }
+}
 
 // src/analyze.ts
 init_raw2();
@@ -3590,7 +3609,7 @@ var CODING_CRITERIA = [
     label: "Abstraction \u2014 seeing the load-bearing thing, and being right",
     graded: true,
     definition: "Under genuine ambiguity (an obvious path sitting right there, no answer key): did the USER see that the obvious path was subtly wrong \u2014 or that something decisive was invisible \u2014 and do the non-obvious thing that made it right, AND were they right? The graded unit is the whole move: the CATCH (noticing the fork) -> the QUESTION (formulating it) -> the CALL (resolving it). The move surfaces three interchangeable ways, scored identically: a REFRAME (collapse a mess to its real axis), a QUESTION (pose the hard thing nobody posed), or an INSTRUMENT (build the code/chart/structure that makes the truth legible, then read it). Tag the SUBSTANCE, not the medium \u2014 a chart built (technical act) to make a human-intensity call legible is a JUDGMENT catch.",
-    read: "FOUR LEVERS set the height: (1) INVISIBILITY \u2014 how non-obvious there was anything to catch; a sharp operator in the flow drives past it (the DOMINANT lever); (2) DIFFICULTY of forming the catch; (3) STAKES \u2014 'without this, things silently go wrong' is the 9-10 condition; (4) SOUNDNESS \u2014 did the call hold. THREE OVERRIDING GATES: (a) OBVIOUSNESS KILLS IT \u2014 a correct, even load-bearing catch a sharp operator reaches anyway scores LOW ('you're evaluating the person not the AI' is correct but obvious -> ~5; 'compute in the OAuth dead-time' is real but fairly obvious -> ~6). (b) LEVERAGE BEATS INSIGHT \u2014 a move whose payoff is a HIGHER RATE OF FUTURE INSIGHT (building the tool that lets him set his own boundaries; timestamp-by-timestamp structure to instruct the grader precisely) raises the bandwidth of the loop that produces every later catch, and can outrank a clean one-off reframe. (c) SOUNDNESS GATE \u2014 a confident WRONG call to a noticed fork is an ANTI-SIGNAL; an honest 'not sure, here's a range' is NOT penalized. HUNT THE FORK BLIND \u2014 reconstruct what continuing-without-noticing looked like, then check whether/why he diverged; do NOT hand yourself the fork pre-formed or you score everyone's problem-finding a 10. TAG every instance: kind = systems | judgment | both (+ optional register: human/product/measurement). Reasoning and instrument-building are the SAME criterion. ANCHORS: 10 = 'OCEAN won't change, measure effectiveness of actions' (reframe that redefines the measure) / 'don't hurt Natalie, not long-term compatible' (lived judgment, requires being the person) / 'plot it sorted, let me set the boundaries' (leverage \u2014 builds the bandwidth tool); 9 = 'word count IS the proxy \u2014 sitting there is unfakeable focus' / 'uncertainty collapses in that direction'; 8 = 'a better metric is the difficulty of content + original synthesis' (hard opening question); 7 = 'this candidate seems too strong for his judgement to be real' (real non-obvious catch, modest stakes); 6 = 'compute in the OAuth dead-time' / 'why overcomplicate it, single agent' (real but obvious); 5 = 'you're evaluating the person not the AI' (correct but obvious).",
+    read: "FOUR LEVERS set the height: (1) INVISIBILITY \u2014 how non-obvious there was anything to catch; a sharp operator in the flow drives past it (the DOMINANT lever); (2) DIFFICULTY of forming the catch; (3) STAKES \u2014 'without this, things silently go wrong' is the 9-10 condition; (4) SOUNDNESS \u2014 did the call hold. THREE OVERRIDING GATES: (a) OBVIOUSNESS KILLS IT \u2014 a correct, even load-bearing catch a sharp operator reaches anyway scores LOW ('you're evaluating the person not the AI' is correct but obvious -> ~5; 'compute in the OAuth dead-time' is real but fairly obvious -> ~6). (b) LEVERAGE BEATS INSIGHT \u2014 a move whose payoff is a HIGHER RATE OF FUTURE INSIGHT (building the tool that lets him set his own boundaries; timestamp-by-timestamp structure to instruct the grader precisely) raises the bandwidth of the loop that produces every later catch, and can outrank a clean one-off reframe. (c) SOUNDNESS GATE \u2014 a confident WRONG call to a noticed fork is an ANTI-SIGNAL; an honest 'not sure, here's a range' is NOT penalized. HUNT THE FORK BLIND \u2014 reconstruct what continuing-without-noticing looked like, then check whether/why he diverged; do NOT hand yourself the fork pre-formed or you score everyone's problem-finding a 10. TAG every instance: kind = systems | judgment | both (+ optional register: human/product/measurement). Reasoning and instrument-building are the SAME criterion. ANCHORS: 10 = 'OCEAN won't change, measure effectiveness of actions' (reframe that redefines the measure) / a human-stakes call where the person overrode the analytically-clean answer on knowledge only they could have about someone involved, and was right (lived judgment, requires being the person) / 'plot it sorted, let me set the boundaries' (leverage \u2014 builds the bandwidth tool); 9 = 'word count IS the proxy \u2014 sitting there is unfakeable focus' / 'uncertainty collapses in that direction'; 8 = 'a better metric is the difficulty of content + original synthesis' (hard opening question); 7 = 'this candidate seems too strong for his judgement to be real' (real non-obvious catch, modest stakes); 6 = 'compute in the OAuth dead-time' / 'why overcomplicate it, single agent' (real but obvious); 5 = 'you're evaluating the person not the AI' (correct but obvious).",
     rungs: [
       { level: 2, marker: "A fork existed; defers the call to the AI, or takes the obvious branch; vague." },
       { level: 4, marker: "Notices something, but the question is vague or obvious \u2014 anyone in the seat asks it." },
@@ -4173,7 +4192,10 @@ async function getAccessToken(dataDir) {
       headers: { "content-type": "application/json", apikey: supabaseAnonKey },
       body: JSON.stringify({ refresh_token: id.refreshToken })
     });
-    if (!r.ok) return null;
+    if (!r.ok) {
+      if (r.status >= 400 && r.status < 500) await signOut(dataDir);
+      return null;
+    }
     const fresh = await persistSession(dataDir, await r.json());
     return { token: fresh.accessToken, identity: fresh };
   } catch {
@@ -4183,11 +4205,11 @@ async function getAccessToken(dataDir) {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-16.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",
+  rubricVersion: "7983c01d53",
   // 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
@@ -4274,6 +4296,7 @@ var DEFAULT_CALIBRATION = {
   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." },
+    hours: { median: 3, sigma: 0.4, tag: "estimated \u2014 proxy-anchored", source: "median: RescueTime-measured ~2h48m of real productive time/day (same source as the flow benchmark) \u2248 3h of active building; shape: sustaining ~7.5h/day \u2248 top 1%, a ~12h/day average \u2248 1-in-3,000. AVERAGE work-day length, 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: {
@@ -4406,7 +4429,7 @@ import path13 from "path";
 
 // ../../lib/agents/shared/cliAdapter.ts
 init_env();
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { promises as fs7 } from "fs";
 import path7 from "path";
 
@@ -4512,7 +4535,7 @@ var cliAdapter2 = {
     let numTurns;
     let usage;
     await new Promise((resolve2, reject) => {
-      const child = spawn3(CLAUDE_BIN, args, {
+      const child = spawn4(CLAUDE_BIN, args, {
         cwd: inv.cwd ?? inv.addDir,
         // scrubbed: a stray ANTHROPIC_API_KEY in the user's shell hijacks the
         // claude CLI away from their claude.ai login (coding-core/env.ts)
@@ -4642,7 +4665,7 @@ var cliAdapter2 = {
 };
 
 // ../../lib/agents/shared/codexAdapter.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync4, statSync } from "fs";
 import path9 from "path";
 
@@ -4796,7 +4819,7 @@ var codexAdapter2 = {
     let resultText = "";
     let numTurns = 0;
     await new Promise((resolve2, reject) => {
-      const child = spawn4(bin, args, {
+      const child = spawn5(bin, args, {
         cwd,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -4874,7 +4897,7 @@ var codexAdapter2 = {
 };
 
 // ../../lib/agents/shared/cursorAdapter.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 function composePrompt3(inv, roots) {
   return [
     inv.systemPrompt ? `<system>
@@ -4897,7 +4920,7 @@ var cursorAdapter = {
     const started = Date.now();
     let out = "";
     await new Promise((resolve2, reject) => {
-      const child = spawn5(bin, args, {
+      const child = spawn6(bin, args, {
         cwd: inv.cwd ?? inv.addDir,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"]
@@ -20885,7 +20908,7 @@ var growthLens = {
     {
       key: "implementation",
       name: "Observed execution improvement",
-      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
       rungs: [
         { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
         { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },
@@ -23761,6 +23784,8 @@ async function compileCodingProfile() {
   const avgWords = aggregate?.throughput?.avgWordsPerDay ?? null;
   const pushPctl = lognPct(avgWords, tiers?.push);
   const focusPctl = lognPct(flowPctDay, tiers?.focus);
+  const workDayHrs = aggregate?.flow?.flow?.workDayHours ? Math.round(aggregate.flow.flow.workDayHours * 10) / 10 : null;
+  const hoursPctl = lognPct(workDayHrs, tiers?.hours);
   const hoursAt = (min) => Object.entries(pHist).reduce((a, [k, v]) => Number(k) >= min ? a + v : a, 0) / 60;
   const orchPctl = hoursAt(5) >= 5 || hoursAt(3) >= 10 && parallelism.queueOps >= 1e3 ? 99.5 : hoursAt(3) >= 10 ? 99 : hoursAt(2) >= 0.1 * (soloMin + parMin) / 60 ? 97 : hoursAt(2) >= 2 ? 90 : 70;
   const stackUp = [
@@ -23770,14 +23795,25 @@ async function compileCodingProfile() {
       `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",
+      "Hours you put in",
+      null,
+      workDayHrs != null ? `~${workDayHrs}h of active building on a typical work day \u2014 engaged builders average ~3h, and sustaining 7h+ day after day, week after week, is top-1% territory` : "not enough dated activity yet to measure a typical work day"
+    ),
+    sRow(
+      "Your AI parallelism",
       ceilOf("delegation"),
       soloPct != null ? `~${soloPct}% of your hours you drive a single agent (${Math.round(soloMin / 60)}h solo vs ${Math.round(parMin / 60)}h with 2+ live) \u2014 the Claude Code lead keeps 10\u201315 going at once, so this is the single biggest speed-up still on the table` : "you brief the AI sharply, but mostly drive one agent at a time \u2014 the top run 10\u201315 in parallel, a several-fold speed-up"
     ),
+    // The evidence line cites the RANKING metric (flow as a share of the work
+    // day), never absolute hours — a friend with MORE flow hours over a longer
+    // day landed a WORSE percentile and the hours-based line read as a bug
+    // (2026-07-16: "he has more hours but less percentile??"). The label says
+    // "when you work" ON PURPOSE: this chip ranks quality of the hours, and
+    // the volume of hours is its own chip above.
     sRow(
-      "How well you focus",
+      "Focus quality when you work",
       focusScore,
-      flowHrsDay != null ? `only ~${flowHrsDay}h of your day is true deep flow \u2014 the best hold ~4h in one unbroken block; yours fragments across parallel sessions, so the gain is directing your attention at one thread for longer` : "your attention scatters across parallel sessions \u2014 directing it at one thread for longer is the unlock"
+      flowPctDay != null ? `~${Math.round(flowPctDay * 100)}% of your work day is true deep flow${flowHrsDay != null ? ` (~${flowHrsDay}h)` : ""} \u2014 the very best hold ~${Math.round(BEST.flow.topPctOfDay * 100)}% of theirs in one unbroken block; yours fragments across parallel sessions, so the gain is directing your attention at one thread for longer` : "your attention scatters across parallel sessions \u2014 directing it at one thread for longer is the unlock"
     ),
     // The four estimates LEAD with a concrete moment from their own sessions, then an
     // HONEST caveat — how many graded sessions back the read. No invented weakness, no
@@ -23810,12 +23846,17 @@ async function compileCodingProfile() {
       r.metric = avgWords;
       r.curve = "push";
     }
-    if (r.label === "How well you focus" && focusPctl != null) {
+    if (r.label === "Hours you put in" && hoursPctl != null) {
+      r.percentile = hoursPctl;
+      r.metric = workDayHrs;
+      r.curve = "hours";
+    }
+    if (r.label === "Focus quality when you work" && focusPctl != null) {
       r.percentile = focusPctl;
       r.metric = flowPctDay;
       r.curve = "focus";
     }
-    if (r.label === "How well you use AI") r.percentile = orchPctl;
+    if (r.label === "Your AI parallelism") r.percentile = orchPctl;
   }
   return { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), gradedSessions: grades.length, agglomeration, outcomeCadence, dayDigest, dayChart, timeline, walkthroughs, rubric: rubric2, wordsByDay, dayThroughput, throughputCeiling: tCeiling, stackUp, criteria, parallelism, throughput, workstyle, flow, focus, expertiseMap, frontierArsenal, frontierDetail, coaching, gap, aggregate, delegationRollup, gapDist, projects };
 }
@@ -23921,7 +23962,7 @@ async function buildSkeleton(codingDir, stackUp) {
       ...thr.avgWordsPerDay ? [{ big: String(Math.round(thr.avgWordsPerDay).toLocaleString()), lab: "typed/dictated words per day, averaged (~300 for the median active user)" }] : [],
       ...thr.substantialDays ? [{ big: `${thr.substantialDays}/${thr.totalCodingDays}`, lab: "coding days were substantial (3h+ span)" }] : []
     ], moments: [] },
-    { key: "ai", label: "How they use AI", topPct: pct2("use ai"), sub: "orchestration, measured", claim: "", read: "", numbers: [
+    { key: "ai", label: "How they use AI", topPct: pct2("parallelism"), sub: "orchestration, measured", claim: "", read: "", numbers: [
       ...par.max ? [{ big: String(par.max), lab: "agents at once, peak" }] : [],
       ...par.hours2plus ? [{ big: `${par.hours2plus}h`, lab: "working 2+ live agents" }] : [],
       ...par.queueOps ? [{ big: par.queueOps.toLocaleString(), lab: "instructions queued ahead" }] : []
@@ -24341,12 +24382,15 @@ async function handlePublicCodingPageShare(dataDir, body) {
     return { status: 409, json: { error: "nothing to share yet \u2014 generate your page first" } };
   }
   const chatReport = body.includeChat === false ? null : await localChatReport();
+  const prior = await readOwnReportContent(cfg, auth.token, auth.identity.userId);
   try {
-    const payload = JSON.stringify({ format: "coding-pr1", page, ...chatReport ? { chatReport } : {} });
+    const merged = { ...prior, format: "coding-pr1", page };
+    if (chatReport) merged.chatReport = chatReport;
+    else delete merged.chatReport;
     const up = await fetch(`${cfg.supabaseUrl}/rest/v1/rpc/submit_report`, {
       method: "POST",
       headers: { apikey: cfg.supabaseAnonKey, authorization: `Bearer ${auth.token}`, "content-type": "application/json" },
-      body: JSON.stringify({ p_session_id: null, p_content: payload })
+      body: JSON.stringify({ p_session_id: null, p_content: JSON.stringify(merged) })
     });
     if (!up.ok) return { status: 502, json: { error: `share failed (HTTP ${up.status})` } };
     const verification = String(await up.json().catch(() => "unverified"));
@@ -24355,6 +24399,49 @@ async function handlePublicCodingPageShare(dataDir, body) {
     return { status: 502, json: { error: e.message.slice(0, 200) } };
   }
 }
+async function readOwnReportContent(cfg, token, userId) {
+  try {
+    const r = await fetch(`${cfg.supabaseUrl}/rest/v1/reports?user_id=eq.${encodeURIComponent(userId)}&select=content`, {
+      headers: { apikey: cfg.supabaseAnonKey, authorization: `Bearer ${token}` }
+    });
+    if (!r.ok) return {};
+    const rows = await r.json();
+    const c = rows[0]?.content;
+    return c && typeof c === "object" ? c : {};
+  } catch {
+    return {};
+  }
+}
+async function handleAnalysisShare(dataDir, kind, full) {
+  const cfg = centralConfig();
+  if (!cfg.configured) return { status: 503, json: { error: "central services are disabled in this build" } };
+  const auth = await getAccessToken(dataDir);
+  if (!auth) return { status: 401, json: { error: "sign in with Google (top right) first" } };
+  const slim = (p) => {
+    if (!p || typeof p !== "object") return p;
+    const { timeline: _t, walkthroughs: _w, dayDigest: _d, dayChart: _c, ...rest } = p;
+    return rest;
+  };
+  const value = kind === "coding" ? slim(full.coding()) : await full.chat().catch(() => null);
+  if (!value) return { status: 409, json: { error: "nothing to share yet \u2014 run the analysis first" } };
+  const prior = await readOwnReportContent(cfg, auth.token, auth.identity.userId);
+  try {
+    const merged = {
+      format: "coding-pr1",
+      ...prior,
+      [kind === "coding" ? "fullCoding" : "fullChat"]: value
+    };
+    const up = await fetch(`${cfg.supabaseUrl}/rest/v1/rpc/submit_report`, {
+      method: "POST",
+      headers: { apikey: cfg.supabaseAnonKey, authorization: `Bearer ${auth.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ p_session_id: null, p_content: JSON.stringify(merged) })
+    });
+    if (!up.ok) return { status: 502, json: { error: `share failed (HTTP ${up.status})` } };
+    return { status: 200, json: { ok: true, kind } };
+  } catch (e) {
+    return { status: 502, json: { error: e.message.slice(0, 200) } };
+  }
+}
 
 // src/server.ts
 var __dirname = path33.dirname(fileURLToPath2(import.meta.url));
@@ -24682,6 +24769,18 @@ function startServer(opts) {
         json(res, out.status, out.json);
         return;
       }
+      if (req.method === "POST" && route === "/api/analysis/share") {
+        const body = JSON.parse(await readBody(req) || "{}");
+        const out = await handleAnalysisShare(dataDir, body.kind === "chat" ? "chat" : "coding", {
+          coding: () => liveProfile,
+          chat: async () => {
+            const p = await handlePerson();
+            return p.status === 200 ? p.json : null;
+          }
+        });
+        json(res, out.status, out.json);
+        return;
+      }
       if (route.startsWith("/api/")) {
         json(res, 404, { error: `this viewer doesn't serve ${route}` });
         return;
@@ -24703,7 +24802,7 @@ function startServer(opts) {
       serverUrl = `http://${host}:${port}`;
       void getCalibration().then((cal) => {
         if (cal.source === "central" && cal.doc.rubricVersion !== RUBRIC_FINGERPRINT2) {
-          console.warn(`[polymath-society] a newer grading rubric is published (${cal.doc.rubricVersion}; this install: ${RUBRIC_FINGERPRINT2}) \u2014 update the package and re-grade to stay comparable.`);
+          console.warn(`[polymath-society] you're not on the latest version \u2014 run: npm install -g polymath-society@latest`);
         }
       }).catch(() => {
       });
@@ -24732,7 +24831,7 @@ function startServer(opts) {
 }
 
 // src/pipeline.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 import os8 from "os";
 import path36 from "path";
 import { existsSync as existsSync5, promises as fs31 } from "fs";
@@ -24993,7 +25092,7 @@ function stageInvocation(repoRoot, scriptRel, args) {
 function runStage(repoRoot, st, env, onLine) {
   return new Promise((resolve2, reject) => {
     const { cmd, argv, cwd } = stageInvocation(repoRoot, st.script, st.args);
-    const child = spawn6(cmd, argv, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn7(cmd, argv, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     const pump = (buf) => {
       if (!onLine) return;
       for (const line of buf.toString().split(/\r?\n/)) if (line.trim()) onLine(line);
@@ -25034,15 +25133,19 @@ async function evalUpToDate(codingDir, threshold, regrade) {
       (await fs31.readdir(path36.join(codingDir, "grades")).catch(() => [])).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5))
     );
     const agg = JSON.parse(await fs31.readFile(path36.join(codingDir, "aggregate.json"), "utf8").catch(() => "{}"));
-    return upToDateSkip({
-      gradableIds: gradable.map((s) => s.sessionId),
-      gradedIds: graded,
-      hasBigPicture: typeof agg.bigPicture === "string" && agg.bigPicture.trim().length > 0,
-      threshold,
-      regrade
-    });
+    const hasPriorRun = typeof agg.bigPicture === "string" && agg.bigPicture.trim().length > 0;
+    return {
+      ...upToDateSkip({
+        gradableIds: gradable.map((s) => s.sessionId),
+        gradedIds: graded,
+        hasBigPicture: hasPriorRun,
+        threshold,
+        regrade
+      }),
+      hasPriorRun
+    };
   } catch {
-    return { skip: false, pending: -1 };
+    return { skip: false, pending: -1, hasPriorRun: false };
   }
 }
 function startKeepAwake(o = {}) {
@@ -25057,7 +25160,7 @@ function startKeepAwake(o = {}) {
   const up = () => {
     if (stopped) return;
     try {
-      child = spawn6(cmd, argv, { detached: true, stdio: "ignore" });
+      child = spawn7(cmd, argv, { detached: true, stdio: "ignore" });
       child.unref();
       child.on("error", () => {
         stopped = true;
@@ -25151,6 +25254,10 @@ async function runPipeline(o) {
         o.onLine?.(
           `\u2713 report is up to date \u2014 ${gate2.pending} new session(s) since the last full run (below the ${threshold}-session threshold). Skipping the AI stages; free metrics still refresh. They'll be analyzed once ${threshold}+ accumulate (POLYMATH_MIN_NEW_SESSIONS=0 or --regrade to force now).`
         );
+      } else if (gate2.hasPriorRun) {
+        o.onLine?.(
+          `\u2713 your finished report from the last run is safe and already serving at the link below \u2014 nothing restarts from scratch. ${gate2.pending >= 0 ? `${gate2.pending} pending session(s)` : "New work"} plus any stages added by an update run on top of it, and sections refresh in place as they finish.`
+        );
       }
     }
   }
@@ -25180,7 +25287,7 @@ async function runPipeline(o) {
 
 // src/chatPipeline.ts
 init_manifest();
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import path37 from "path";
 import { existsSync as existsSync6, promises as fs32 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -25244,7 +25351,7 @@ async function finalChatArtifacts(dataRoot) {
 function runStage2(repoRoot, st, env, onLine) {
   return new Promise((resolve2, reject) => {
     const { cmd, argv, cwd } = stageInvocation2(repoRoot, st.script, st.args);
-    const child = spawn7(cmd, argv, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn8(cmd, argv, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
     const pump = (buf) => {
       if (!onLine) return;
       for (const line of buf.toString().split(/\r?\n/)) if (line.trim()) onLine(line);
@@ -25879,13 +25986,6 @@ async function maybePrintUpdateNotice(opts) {
     clearTimeout(timer);
   }
 }
-function openBrowser(url) {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  try {
-    spawn9(cmd, [url], { stdio: "ignore", detached: true }).unref();
-  } catch {
-  }
-}
 main().catch((e) => {
   console.error(e);
   process.exit(1);

package/dist/engine/chat-loops.js

@@ -551,7 +551,7 @@ var init_growth = __esm({
         {
           key: "implementation",
           name: "Observed execution improvement",
-          definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+          definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
           rungs: [
             { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
             { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },

package/dist/engine/exp-allfacets.js

@@ -16490,7 +16490,7 @@ var growthLens = {
     {
       key: "implementation",
       name: "Observed execution improvement",
-      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
       rungs: [
         { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
         { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },

package/dist/engine/exp-person.js

@@ -16412,7 +16412,7 @@ var growthLens = {
     {
       key: "implementation",
       name: "Observed execution improvement",
-      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
       rungs: [
         { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
         { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },

package/dist/engine/ingest-export.js

@@ -661,11 +661,11 @@ var GIFTS = [
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-16.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",
+  rubricVersion: "7983c01d53",
   // 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
@@ -752,6 +752,7 @@ var DEFAULT_CALIBRATION = {
   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." },
+    hours: { median: 3, sigma: 0.4, tag: "estimated \u2014 proxy-anchored", source: "median: RescueTime-measured ~2h48m of real productive time/day (same source as the flow benchmark) \u2248 3h of active building; shape: sustaining ~7.5h/day \u2248 top 1%, a ~12h/day average \u2248 1-in-3,000. AVERAGE work-day length, 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: {

package/dist/engine/peak-demos.js

@@ -530,7 +530,7 @@ var growthLens = {
     {
       key: "implementation",
       name: "Observed execution improvement",
-      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
       rungs: [
         { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
         { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },

package/dist/engine/person-dimension-summary.js

@@ -530,7 +530,7 @@ var growthLens = {
     {
       key: "implementation",
       name: "Observed execution improvement",
-      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
       rungs: [
         { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
         { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },

package/dist/engine/person-facet-lines.js

@@ -530,7 +530,7 @@ var growthLens = {
     {
       key: "implementation",
       name: "Observed execution improvement",
-      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament (often OCD-like), so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
+      definition: "The slope itself: whether diagnosed problems get attacked with experiments and whether the change in BEHAVIOR lands and sticks. Graded from dated evidence on ACTIONS, not feelings: a recurring feeling, urge, or complaint is expected base temperament and is NOT a mark against implementation \u2014 only a recurring unchanged behavior is. Credit a changed action even when the underlying feeling repeats verbatim (e.g. still dreads cold outreach but now sends it daily). A COMPULSION OR URGE IS TEMPERAMENT, NOT AN ACTION: a perfectionism / over-analysis / decision-paralysis loop is the behavioral face of base temperament, so if the person INCREASINGLY OVERRIDES it and still ships, that is temperament being managed better over time \u2014 a RISING slope, NOT a recurring unchanged action \u2014 and must NOT cap the score. Only count such a loop against implementation if the ACTION genuinely shows NO improvement across the window (still loses whole days with no rising ability to override and ship). A FIX THAT NEEDED A FORCING FUNCTION STILL COUNTS, FULLY: a change triggered by a deadline, a painful lesson, or 'getting burnt' that then LANDS and STICKS is a real fix on a legitimate route \u2014 learning from consequence is how humans change \u2014 so do NOT dock a landed, sticky fix for needing a catalyst; the catalyst is not a defect. Judge the slope over LONG horizons (weeks\u2192months across the dated record), NEVER within a single day or conversation \u2014 behavior change takes time, so the absence of same-day change is NOT a failure and must NEVER buckle the score. GRADE THE AGGREGATE SLOPE, not the one unfixed thread: humans cannot fix everything, and very few fix anything at all \u2014 so fixing several genuinely hard, DISTINCT stuck-points and making them stick across the window is exceptional and scores HIGH (9-10), and one stubborn temperament loop that is being increasingly overridden does NOT pull an otherwise broad, rising, sticky record down. The real question: across the record, did the problems they identified earlier become LESS of an issue in their later ACTIONS? Internal baselines (neuroticism, needing people to feel happy) are not the unit here \u2014 grade the actions.",
       rungs: [
         { level: 3, marker: "The same BEHAVIORS recur across the window, unchanged \u2014 recognition (if any) never becomes a change in action. (A recurring feeling alongside changed behavior does NOT belong here \u2014 that is a fix, scored higher.)" },
         { level: 5, marker: "Occasionally a fix happens \u2014 intends to solve, and sometimes it lands, but not usually." },