polymath-society 0.2.12 → 0.2.13

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,7 @@ var init_cliAdapter = __esm({
 });
 
 // src/grade/codexAdapter.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 function composePrompt(inv, roots) {
   return [
     inv.systemPrompt ? `<system>
@@ -1235,7 +1235,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 +1541,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 +2646,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 +3602,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." },
@@ -4183,11 +4195,11 @@ async function getAccessToken(dataDir) {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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
@@ -4406,7 +4418,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 +4524,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 +4654,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 +4808,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 +4886,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 +4909,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 +20897,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." },
@@ -24732,7 +24744,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 +25005,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);
@@ -25057,7 +25069,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;
@@ -25180,7 +25192,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 +25256,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 +25891,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-15.1",
   // = 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

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." },

package/dist/engine/person-headline.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-report.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-self-image.js

@@ -616,7 +616,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/public-report.js

@@ -15656,11 +15656,11 @@ var ENGINE_DATA = process.env.POLYMATH_DATA_DIR ? path10.resolve(process.env.POL
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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
@@ -16201,7 +16201,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/run-analysis.js

@@ -15818,7 +15818,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/index.js

@@ -2219,7 +2219,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." },
@@ -2671,11 +2671,11 @@ var LocalGradeProvider = class {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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
@@ -19655,7 +19655,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/pipeline/coding-agglomerate.js

@@ -15674,7 +15674,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." },
@@ -16127,11 +16127,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-aggregate.js

@@ -324,7 +324,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." },
@@ -431,11 +431,11 @@ var IDLE_CAP_MS = 12 * 6e4;
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-build.js

@@ -1138,7 +1138,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." },
@@ -1294,11 +1294,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-coaching.js

@@ -15672,7 +15672,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." },
@@ -16290,11 +16290,11 @@ function computeWorkstyle(inp) {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-day-digest.js

@@ -15922,7 +15922,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." },
@@ -16033,11 +16033,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-delegation.js

@@ -16329,7 +16329,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." },
@@ -16440,11 +16440,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-expertise.js

@@ -15939,7 +15939,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." },
@@ -16050,11 +16050,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-flow.js

@@ -287,7 +287,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." },
@@ -394,11 +394,11 @@ var IDLE_CAP_MS = 12 * 6e4;
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-frontier-detail.js

@@ -15905,7 +15905,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." },
@@ -16016,11 +16016,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-frontier.js

@@ -47,7 +47,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." },
@@ -203,11 +203,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-gap-dist.js

@@ -287,7 +287,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." },
@@ -394,11 +394,11 @@ var IDLE_CAP_MS = 12 * 6e4;
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-gap.js

@@ -15673,7 +15673,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." },
@@ -16291,11 +16291,11 @@ function computeWorkstyle(inp) {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-grade.js

@@ -15753,7 +15753,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." },
@@ -16209,11 +16209,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-nutshell.js

@@ -15731,7 +15731,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." },
@@ -15842,11 +15842,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-projects.js

@@ -49,7 +49,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." },
@@ -205,11 +205,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/pipeline/coding-walkthrough.js

@@ -15995,7 +15995,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." },
@@ -16103,11 +16103,11 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/dist/web/app.js

@@ -8331,11 +8331,11 @@ function ReportChatSidebar({ endpoint = "/api/coding/chat" } = {}) {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-14.2",
+  version: "2026-07-15.1",
   // = 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polymath-society",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "description": "Deterministic metrics from your local Claude Code / Codex agent logs — parallelism, flow, throughput, projects. Zero LLM, zero server, on-device.",
   "license": "UNLICENSED",
   "type": "module",