polymath-society 0.2.4 → 0.2.6

package/dist/index.js

@@ -2154,6 +2154,9 @@ function invokeAgent(inv, opts = {}) {
   return getAdapter(opts.adapter).run(inv);
 }
 
+// ../../lib/agents/coding/grade-calibration.ts
+var GRADE_CALIBRATION = "\n\nSCORE CALIBRATION \u2014 graders systematically COMPRESS to the middle: real peaks get hedged down to 6-7, and routine sessions get polite 5-6s instead of null. Both are failures; fight them explicitly. Work each criterion in EXACTLY this order:\nSTEP 1 \xB7 EVIDENCE GATE \u2014 find the 1-3 verbatim '>> ' quotes that bear on the criterion. INCLUDE a criterion whenever genuine evidence is present (do not MISS quiet evidence \u2014 check every thread of the session, not just the dominant one). But with NO quotable moment the score is null, full stop: a session can be long, competent, and productive while being null on most criteria. Routine hand-holding earns null, never a 5 \u2014 and null is never a deduction.\nSTEP 2 \xB7 LADDER MATCH \u2014 with quotes in hand, read the criterion's rungs and pick the ONE rung whose marker best describes the quoted moment; name that rung in 'why'. AWARD THE RUNG THE EVIDENCE MATCHES: if your own 'why' describes rung N's criteria, give rung N \u2014 never deny it for lacking the NEXT rung's criteria.\nSTEP 3 \xB7 THE SINGLE BEST MOMENT IS THE SCORE \u2014 set the score by the strongest quoted moment, as if it were the whole session. NEVER average a peak down because the surrounding session is routine (the high-water rule), and never raise a score for volume, effort, or topic prestige without a matching moment.\nSTEP 4 \xB7 ANTI-HEDGE \u2014 if the moment genuinely matches an L8-10 anchor (an override the AI conceded, a shipped-and-verified capability, an 'oh shit, they're right' call, a first-principles redefinition that held), the score IS 8-10. Hedging a real L9 to a 7 is exactly as wrong as inventing a 6 for nothing. The middle is NOT a safe default: commit high on anchor-matching evidence, or go null.\nSTEP 5 \xB7 'CONSERVATIVE' \u2260 SUBTRACT \u2014 when a criterion's ladder says to grade conservatively, that means DO NOT EXCEED the rung whose marker the evidence matches; it NEVER means subtracting rungs from matched evidence. Evidence that matches a rung's marker gets that rung under a conservative reading too.";
+
 // ../../lib/calibration/fingerprint.ts
 import { createHash } from "node:crypto";
 function rubricFingerprint(criteria) {
@@ -2464,7 +2467,7 @@ ${c.rungs.map((r) => `    ${r.level} \u2014 ${r.marker}`).join("\n")}`
 }
 var SYSTEM = "You grade how a person WORKS from one of their coding-agent sessions (Claude Code / Codex). You read mostly THEIR words; the model's code and output are compressed to context and you ignore the mechanical scaffolding. You never flatter: most sessions are routine hand-holding and should score low or null on most criteria. A score is a placement on the ladder backed by VERBATIM quotes of the user's own lines \u2014 never a vibe.\n\nSTANDING RULES (apply to every criterion):\n1. ABSENCE IS NEVER A DEDUCTION. If a criterion had no chance to show, its score is null \u2014 NOT a low. Don't invent a number for routine work.\n2. HIGH-WATER MARK. Taste and abstraction are PEAK measures \u2014 one genuinely brilliant move in a session counts, even surrounded by routine work. Never grade the person at their worst.\n3. LOW-EFFORT-UNTIL-NEEDED IS THE IDEAL. A terse or vague prompt on routine work is correct economy \u2014 never penalize a vague ask, never reward word-count.\n4. DISCOUNT THE LITERAL HARSHNESS OF SELF-TALK. Profanity aimed at self or AI is DRIVE and high standards, not defects.\n5. PER-CONVERSATION CEILING IS 10. Never output 11 \u2014 scores run 2\u201310.\n6. LOG THE SPIKES IN HIGH DETAIL. When a moment is genuinely good, name it CONCRETELY and quote it.";
 function gradeSystemPrompt() {
-  return `${SYSTEM}
+  return `${SYSTEM}${GRADE_CALIBRATION}
 
 Grade ONE coding session (provided in the user message) along the criteria below. ">> " lines are the USER's own words (the signal). ALL bracketed lines are machine context, never the user: "[AI: \u2026]" is the model working, "[bg task: \u2026]" / "[cmd output: \u2026]" are harness notifications, "[mode \u2192 \u2026]" marks a mode switch (context only \u2014 do not grade or quote them). ">> (queued \u2026)" is the user queuing work while the AI runs.
 
@@ -2647,7 +2650,7 @@ var LocalGradeProvider = class {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-12.2",
+  version: "2026-07-14.2",
   // = RUBRIC_FINGERPRINT of the shipped npm rubric (packages/coding-analyzer/
   // src/grade/criteria.ts). A unit test fails loud when the rubric changes
   // without this being updated (and re-pushed to the server).
@@ -2736,7 +2739,7 @@ var DEFAULT_CALIBRATION = {
     }
   ],
   codingTiers: {
-    push: { median: 300, sigma: 1.121, tag: "estimated \u2014 log-normal fit", source: "Anthropic 2026 Claude Code study (400k sessions): median engaged user ~8 prompts/day at ~35 words \u2014 ~300 directed words/day; tail shape from its actions-per-prompt distribution. AVERAGE over substantial days, cumulative not spiky." },
+    push: { median: 300, sigma: 0.91, tag: "estimated \u2014 log-normal fit", source: "Anthropic 2026 Claude Code study (400k sessions): median engaged user ~8 prompts/day at ~35 words \u2014 ~300 directed words/day; tail: a 1-in-1,000 user AVERAGES ~5k directed words/day (near-daily heavy dictation, clearly below the ~10k single-day record). AVERAGE over substantial days, cumulative not spiky." },
     focus: { median: 0.08, sigma: 0.559, tag: "estimated \u2014 proxy-anchored", source: "median: Anthropic 20h/week engaged-user figure implies ~1h/day of true rapid exchange against an 8h working day; ceiling anchored to the ~4h/day deep-work limit (45% share = 1-in-1,000). AVERAGE share, cumulative not spiky." },
     orchestration: { tag: "estimated \u2014 behavior bands", source: "no published concurrency distribution exists; ceiling anchored to the Claude Code lead's documented 10-15 parallel sessions" }
   },
@@ -2769,12 +2772,18 @@ var DEFAULT_CALIBRATION = {
       line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
     },
     throughput: {
-      // Top-0.1% words/day reference lines, anchored to the throughput ladder
-      // (THROUGHPUT_LADDER in throughput.ts): score 10 "world-class sustained" =
-      // 9k/day, score 11 "superhuman ceiling" = 12k/day. Calibrated to the person's
-      // own anchors, not a wild guess — but still a target, not a measured population.
-      topAvgWordsPerDay: 9e3,
-      topPeakWordsPerDay: 12e3,
+      // Two DIFFERENT kinds of line (2026-07-14.2): topAvg is a PERCENTILE
+      // claim — what a 1-in-1,000 user AVERAGES over substantial days (5k/day:
+      // near-daily heavy dictation; a measured top dictating power user
+      // averages ~3.9k). topPeak is NOT a percentile — it is the CEILING
+      // reference, the wildest single days on record (~10k: a 14-16h
+      // launch-day marathon), rendered as "wildest single days", never
+      // "top X% peak". An avg-percentile and a peak-percentile can't both be
+      // shown at a same-ish value (avg≈peak reads broken — user call), and a
+      // peak PERCENTILE line is unknowable anyway; the record framing is
+      // honest and keeps the visual gap.
+      topAvgWordsPerDay: 5e3,
+      topPeakWordsPerDay: 1e4,
       benchLabel: "top 0.1%",
       // No published "words typed/day" for heavy users — the real story is OUTPUT.
       loopsHeadline: ">1,000,000 lines of Rust at 99.8% tests passing",
@@ -2938,7 +2947,7 @@ function buildWebProfile(p, detail) {
   };
 }
 function hourlyHistogram(p) {
-  const MIN3 = 6e4;
+  const MIN4 = 6e4;
   const tz = p.tz;
   const hourMin = new Array(24).fill(0);
   const parts = (ms2) => {
@@ -2953,7 +2962,7 @@ function hourlyHistogram(p) {
           const { h, m, s } = parts(cur);
           const msToNextHour = ((59 - m) * 60 + (60 - s)) * 1e3;
           const segEnd = Math.min(b, cur + msToNextHour);
-          hourMin[h] += (segEnd - cur) / MIN3;
+          hourMin[h] += (segEnd - cur) / MIN4;
           cur = segEnd;
         }
       }
@@ -2966,7 +2975,7 @@ function buildOperate(p, detail) {
   const m = (k) => detail.criteria.find((c) => c.key === k)?.mean ?? null;
   const exp = m("expertise"), cog = m("abstraction"), fr = m("frontier");
   if (exp == null && cog == null && fr == null) return null;
-  const pick = (ladder, score, fallback = "not enough signal yet") => {
+  const pick2 = (ladder, score, fallback = "not enough signal yet") => {
     if (score == null) return fallback;
     const r = Math.round(score);
     const keys = Object.keys(ladder).map(Number).sort((a, b) => a - b);
@@ -2974,14 +2983,14 @@ function buildOperate(p, detail) {
     for (const k of keys) if (k <= r) chosen = k;
     return ladder[chosen];
   };
-  const TASTE = { 4: "mostly rubber-stamps what the AI produces", 6: "rejects the obviously-bad version and iterates toward better", 8: "makes the call the AI couldn't reach on its own \u2014 opinionated, specific, vindicated", 10: "brings a developed vision up front, and knows where not to impose it" };
-  const DELEGATION = { 4: "still uneven \u2014 sometimes under-briefs work they had opinions about", 6: "roughly calibrated on when to do the thinking themselves vs. let the AI run", 8: "well-calibrated \u2014 front-loads the specifiable, reserves correction for genuine AI errors", 10: "near-perfect prompt economy \u2014 almost everything knowable is front-loaded" };
-  const GENERATIVE = { 4: "reaches workable answers with effort", 6: "real ideas and sound tradeoff reasoning", 8: "fast collapse to the core, plus its own approach and the exact fix", 10: "out-reasons the tool \u2014 lands insights the AI itself missed" };
-  const EXPERTISE = { 2: "defers to the AI on system decisions", 4: "opinions are mostly generic best-practice", 6: "knows their own stack well and corrects the AI on real systems facts", 8: "repeatedly catches what the AI misses with specific systems calls", 10: "makes counter-intuitive, deep-operating-knowledge calls the AI would have gotten backwards" };
-  const FRONTIER = { 2: "one session at a time, default settings", 4: "occasionally runs two things; no structural tooling", 6: "routinely parallel, queuing work ahead", 8: "real leverage \u2014 overnight/remote runs, subagents, scripts that drive the AI", 10: "builds harnesses and workflows; loops and scales the AI across machines" };
+  const TASTE2 = { 4: "mostly rubber-stamps what the AI produces", 6: "rejects the obviously-bad version and iterates toward better", 8: "makes the call the AI couldn't reach on its own \u2014 opinionated, specific, vindicated", 10: "brings a developed vision up front, and knows where not to impose it" };
+  const DELEGATION2 = { 4: "still uneven \u2014 sometimes under-briefs work they had opinions about", 6: "roughly calibrated on when to do the thinking themselves vs. let the AI run", 8: "well-calibrated \u2014 front-loads the specifiable, reserves correction for genuine AI errors", 10: "near-perfect prompt economy \u2014 almost everything knowable is front-loaded" };
+  const GENERATIVE2 = { 4: "reaches workable answers with effort", 6: "real ideas and sound tradeoff reasoning", 8: "fast collapse to the core, plus its own approach and the exact fix", 10: "out-reasons the tool \u2014 lands insights the AI itself missed" };
+  const EXPERTISE2 = { 2: "defers to the AI on system decisions", 4: "opinions are mostly generic best-practice", 6: "knows their own stack well and corrects the AI on real systems facts", 8: "repeatedly catches what the AI misses with specific systems calls", 10: "makes counter-intuitive, deep-operating-knowledge calls the AI would have gotten backwards" };
+  const FRONTIER2 = { 2: "one session at a time, default settings", 4: "occasionally runs two things; no structural tooling", 6: "routinely parallel, queuing work ahead", 8: "real leverage \u2014 overnight/remote runs, subagents, scripts that drive the AI", 10: "builds harnesses and workflows; loops and scales the AI across machines" };
   const judgmentBullets = [
-    `Judgment & taste \u2014 ${pick(TASTE, m("taste"))}; on delegation, ${pick(DELEGATION, m("delegation"))}.`,
-    `Under ambiguity \u2014 ${pick(GENERATIVE, cog)}; strongest where there's no ground truth and the task is to invent what to measure.`
+    `Judgment & taste \u2014 ${pick2(TASTE2, m("taste"))}; on delegation, ${pick2(DELEGATION2, m("delegation"))}.`,
+    `Under ambiguity \u2014 ${pick2(GENERATIVE2, cog)}; strongest where there's no ground truth and the task is to invent what to measure.`
   ];
   let archetype;
   if (exp == null || cog == null) archetype = "Not enough graded signal yet to place the technical profile.";
@@ -3002,17 +3011,17 @@ function buildOperate(p, detail) {
     frontier: fr,
     judgmentBullets,
     technicalBullets: [
-      `Systems & architecture \u2014 ${pick(EXPERTISE, exp)}.`,
-      `Raw cognition \u2014 ${pick(GENERATIVE, cog)}.`,
-      `Agent fluency \u2014 ${pick(FRONTIER, fr)} (${sigSentence}).`
+      `Systems & architecture \u2014 ${pick2(EXPERTISE2, exp)}.`,
+      `Raw cognition \u2014 ${pick2(GENERATIVE2, cog)}.`,
+      `Agent fluency \u2014 ${pick2(FRONTIER2, fr)} (${sigSentence}).`
     ]
   };
 }
 
 // src/server.ts
 import http from "http";
-import { promises as fs21 } from "fs";
-import path25 from "path";
+import { promises as fs29 } from "fs";
+import path33 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/auth.ts
@@ -5154,8 +5163,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path26, errorMaps, issueData } = params;
-  const fullPath = [...path26, ...issueData.path || []];
+  const { data, path: path34, errorMaps, issueData } = params;
+  const fullPath = [...path34, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5271,11 +5280,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path26, key) {
+  constructor(parent, value, path34, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path26;
+    this._path = path34;
     this._key = key;
   }
   get path() {
@@ -18062,39 +18071,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path26 }) => `${baseURL}${path26}`,
+    url: ({ path: path34 }) => `${baseURL}${path34}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path26 }) => `${baseURL}${path26}`,
+    url: ({ path: path34 }) => `${baseURL}${path34}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path26 }) => `${baseURL}${path26}`,
+    url: ({ path: path34 }) => `${baseURL}${path34}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path26 }) => `${baseURL}${path26}`,
+    url: ({ path: path34 }) => `${baseURL}${path34}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path26 }) => `${baseURL}${path26}`,
+    url: ({ path: path34 }) => `${baseURL}${path34}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path26 }) => `${baseURL}${path26}`,
+    url: ({ path: path34 }) => `${baseURL}${path34}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -18115,7 +18124,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path26 }) => `${baseURL}${path26}`,
+      url: ({ path: path34 }) => `${baseURL}${path34}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -20795,11 +20804,11 @@ function distOf2(takes) {
   const observed = takes.filter((t) => t.score != null).length;
   const mean2 = vals.reduce((s, v) => s + v, 0) / n;
   const sorted = [...vals].sort((a, b) => a - b);
-  const median = n % 2 ? sorted[(n - 1) / 2] : (sorted[n / 2 - 1] + sorted[n / 2]) / 2;
+  const median2 = n % 2 ? sorted[(n - 1) / 2] : (sorted[n / 2 - 1] + sorted[n / 2]) / 2;
   const h = /* @__PURE__ */ new Map();
   for (const v of vals) h.set(v, (h.get(v) || 0) + 1);
   const hist = [...h.keys()].sort((a, b) => b - a).map((level) => ({ level, count: h.get(level) }));
-  return { n, observed, mean: Math.round(mean2 * 100) / 100, median, hist };
+  return { n, observed, mean: Math.round(mean2 * 100) / 100, median: median2, hist };
 }
 async function readGrowthAgent() {
   const j = await fs16.readFile(path20.join(OUT, "growth-latest.json"), "utf8").then(JSON.parse).catch(() => null);
@@ -21382,7 +21391,7 @@ function hasContent(r) {
 function coerceReport(raw, radar, level, scoreMap, nameMap, maxMap) {
   const j = raw ?? {};
   const str = (v, n = 600) => clip2(v, n);
-  const pct = (tag2, literal) => {
+  const pct2 = (tag2, literal) => {
     const k = typeof tag2 === "string" ? tag2.trim() : "";
     if (k && scoreMap && typeof scoreMap[k] === "number") return bandPercentile(scoreMap[k]) ?? void 0;
     return literal ? str(literal, 24) : void 0;
@@ -21395,7 +21404,7 @@ function coerceReport(raw, radar, level, scoreMap, nameMap, maxMap) {
   const tag = (v) => typeof v === "string" && v.trim() && scoreMap && scoreMap[v.trim()] != null ? v.trim() : void 0;
   const trait = (t) => {
     const f = tag(t?.facet);
-    const p = pct(t?.facet, t?.percentile);
+    const p = pct2(t?.facet, t?.percentile);
     const sc = scoreText(f, scoreMap, maxMap);
     const personal = t?.fromPersonalLife === true;
     return {
@@ -21413,7 +21422,7 @@ function coerceReport(raw, radar, level, scoreMap, nameMap, maxMap) {
   };
   const spikes = (Array.isArray(j.spikes) ? j.spikes : []).map((s) => {
     const f = tag(s?.facet);
-    const p = pct(s?.facet, s?.percentile);
+    const p = pct2(s?.facet, s?.percentile);
     const sc = scoreText(f, scoreMap, maxMap);
     return {
       title: str(s?.title, 160),
@@ -21646,7 +21655,7 @@ async function profilesRow(cfg, token, userId) {
   const rows = await r.json();
   return rows[0] ?? null;
 }
-async function handleVisibility(dataDir, method, body) {
+async function handleVisibility(dataDir, method, body, pool) {
   const cfg = centralConfig();
   if (!cfg.configured) return { status: 503, json: { error: "central services are disabled in this build" } };
   const auth = await getAccessToken(dataDir);
@@ -21662,6 +21671,26 @@ async function handleVisibility(dataDir, method, body) {
   const isPublic = body?.isPublic;
   if (typeof isPublic !== "boolean") return { status: 400, json: { error: "bad-input", message: "isPublic must be a boolean." } };
   try {
+    if (isPublic) {
+      const report = await loadPublicReport();
+      if (!report || !hasContent(report)) {
+        return { status: 409, json: { error: "nothing to publish yet \u2014 run the full analysis first so the public report exists, then publish" } };
+      }
+      let numbers = body?.numbers;
+      if (numbers && typeof numbers === "object" && !Array.isArray(numbers) && pool) {
+        numbers = Object.fromEntries(Object.entries(numbers).filter(([k, v]) => k in pool && v != null));
+      } else {
+        numbers = pool && Object.keys(pool).length ? pool : void 0;
+      }
+      const up = await fetch(`${cfg.supabaseUrl}/rest/v1/rpc/submit_report`, {
+        method: "POST",
+        headers: { apikey: cfg.supabaseAnonKey, authorization: `Bearer ${auth.token}`, "content-type": "application/json" },
+        body: JSON.stringify({ p_session_id: null, p_content: JSON.stringify({ format: "pr1", report, ...numbers && Object.keys(numbers).length ? { numbers } : {} }) })
+      });
+      if (!up.ok) {
+        return { status: 502, json: { error: `report upload failed (HTTP ${up.status}) \u2014 refusing to publish a link with nothing behind it` } };
+      }
+    }
     const row = await profilesRow(cfg, auth.token, auth.identity.userId);
     let slug = row?.public_slug ?? null;
     const patch = { is_public: isPublic };
@@ -21681,9 +21710,1366 @@ async function handleVisibility(dataDir, method, body) {
   }
 }
 
+// src/shareEdit.ts
+import { promises as fs21 } from "fs";
+import os5 from "os";
+import path25 from "path";
+var SYSTEM3 = `You edit a SMALL numbers-only JSON payload a person is about to share (their coding working-style summary). They tell you what to hide or change; you return the COMPLETE updated payload every time.
+ALLOWED EDITS ONLY: remove a whole section; remove a field inside a section ('don't share my words per day' \u2192 delete avgWordsPerDay); round/coarsen a number ('just say ~4000'); shorten or rename a label. FORBIDDEN: adding fields or sections, inventing numbers, increasing any score or percentile, adding text content. If asked for a forbidden edit, keep the payload unchanged and say why in the reply.
+Output ONE fenced \`\`\`json block: { "sections": { ...the complete updated payload... } } \u2014 then, AFTER the block, ONE short plain sentence describing what you changed (e.g. "Removed words-per-day and the project names.").`;
+async function handleShareEdit(pool, body) {
+  const sections = body.sections && typeof body.sections === "object" ? body.sections : null;
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const last = messages.filter((m) => m.role === "user").pop();
+  if (!sections || !last?.content?.trim()) return { status: 400, json: { error: "sections + a user instruction are required" } };
+  const convo = messages.slice(-6).map((m) => `${m.role === "user" ? "USER" : "EDITOR"}: ${m.content}`).join("\n");
+  const prompt = `CURRENT PAYLOAD (what would be shared right now):
+\`\`\`json
+${JSON.stringify(sections, null, 1)}
+\`\`\`
+
+CONVERSATION:
+${convo}
+
+Apply the user's LAST instruction and return the complete updated payload.`;
+  const sandbox = await fs21.mkdtemp(path25.join(os5.tmpdir(), "share-edit-"));
+  try {
+    const run3 = await invokeAgent({ prompt, systemPrompt: SYSTEM3, addDir: sandbox, allowedTools: [], maxTurns: 2, timeoutMs: 12e4, model: "haiku" });
+    const j = run3.json ?? null;
+    const raw = j && typeof j === "object" && "sections" in j ? j.sections : j;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { status: 502, json: { error: "the edit didn't produce a valid payload \u2014 try rephrasing" } };
+    const out = {};
+    for (const k of Object.keys(raw)) if (k in pool && raw[k] != null) out[k] = raw[k];
+    const reply = (run3.raw ?? "").split("```").pop()?.trim().split("\n").filter(Boolean).pop()?.slice(0, 300) || "Done.";
+    return { status: 200, json: { sections: out, reply } };
+  } catch (e) {
+    return { status: 502, json: { error: e.message.slice(0, 200) } };
+  } finally {
+    await fs21.rm(sandbox, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+
+// src/dataHome.ts
+import { existsSync as existsSync4 } from "fs";
+import os6 from "os";
+import path26 from "path";
+function electronAppData() {
+  const candidates = [
+    "/Applications/Polymath.app/Contents/Resources/standalone/.data",
+    path26.join(os6.homedir(), "Applications", "Polymath.app", "Contents", "Resources", "standalone", ".data")
+  ];
+  for (const c of candidates) if (existsSync4(path26.join(c, "coding"))) return c;
+  return null;
+}
+function resolveDataRoot(env = process.env, cwd = process.cwd(), appData = electronAppData) {
+  const fromEnv = env.POLYMATH_DATA_DIR;
+  if (fromEnv && fromEnv.trim()) return path26.resolve(fromEnv);
+  const local = path26.join(cwd, ".data");
+  if (existsSync4(local)) return local;
+  const fromApp = appData();
+  if (fromApp) return fromApp;
+  return path26.join(os6.homedir(), ".polymath-society", "data");
+}
+
+// src/manifest.ts
+import { promises as fs22 } from "fs";
+import path27 from "path";
+var MANIFEST_BASENAME = "exports-manifest.json";
+function manifestPath(dataDir) {
+  return path27.join(dataDir, MANIFEST_BASENAME);
+}
+async function readManifest(dataDir) {
+  const p = manifestPath(dataDir);
+  let raw;
+  try {
+    raw = await fs22.readFile(p, "utf-8");
+  } catch {
+    return null;
+  }
+  let j;
+  try {
+    j = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`${p} exists but is not valid JSON (${e.message}) \u2014 fix or delete it, refusing to guess consent`);
+  }
+  const m = j;
+  const approvedAt = typeof m.approvedAt === "string" ? m.approvedAt : (/* @__PURE__ */ new Date(0)).toISOString();
+  const KNOWN = /* @__PURE__ */ new Set(["chatgpt", "claude", "notion", "obsidian", "unknown"]);
+  const arr = (v) => Array.isArray(v) ? v.filter((f) => f && typeof f.path === "string" && KNOWN.has(f.kind)) : [];
+  if (Array.isArray(m.exports)) {
+    return { approvedAt, exports: { included: arr(m.exports), excluded: [] } };
+  }
+  const ex = m.exports ?? {};
+  const ag = m.agents;
+  const agArr = (v) => Array.isArray(v) ? v.filter((x) => x === "claude-code" || x === "codex") : [];
+  return {
+    approvedAt,
+    ...ag ? { agents: { included: agArr(ag.included), excluded: agArr(ag.excluded) } } : {},
+    exports: { included: arr(ex.included), excluded: arr(ex.excluded) }
+  };
+}
+
+// src/exportLinks.ts
+var EXPORT_LINKS = [
+  {
+    kind: "chatgpt",
+    label: "ChatGPT",
+    requestUrl: "https://chatgpt.com/#settings/DataControls",
+    buttonPath: "Settings \u2192 Data controls \u2192 Export data \u2192 Confirm export",
+    eta: "a few hours up to ~2 days \u2014 the download link arrives by email"
+  },
+  {
+    kind: "claude",
+    label: "claude.ai",
+    requestUrl: "https://claude.ai/settings/data-privacy-controls",
+    buttonPath: "Privacy settings \u2192 Export data",
+    eta: "~10 minutes \u2014 the download link arrives by email"
+  },
+  {
+    kind: "notion",
+    label: "Notion",
+    requestUrl: "https://www.notion.so/settings",
+    buttonPath: "Settings \u2192 General \u2192 Export all workspace content (Markdown & CSV)",
+    eta: "~15 minutes \u2014 the download link arrives by email"
+  },
+  {
+    kind: "obsidian",
+    label: "Obsidian",
+    requestUrl: null,
+    buttonPath: "local vault \u2014 no export needed; point the wizard at the folder",
+    eta: ""
+  }
+];
+
+// src/publicCodingPageApi.ts
+import { promises as fs28 } from "fs";
+import path32 from "path";
+
+// ../../lib/agents/coding/publicPage.ts
+import { promises as fs27 } from "fs";
+import path31 from "path";
+
+// ../../lib/agents/coding/docsDir.ts
+import { promises as fs23 } from "fs";
+import path28 from "path";
+async function writeScoreboard(codingDir, docs) {
+  const gradesDir = path28.join(codingDir, "grades");
+  let files = [];
+  try {
+    files = (await fs23.readdir(gradesDir)).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return;
+  }
+  const byCriterion = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    let g;
+    try {
+      g = JSON.parse(await fs23.readFile(path28.join(gradesDir, f), "utf8"));
+    } catch {
+      continue;
+    }
+    for (const c of g.criteria ?? []) {
+      const s = c.score ?? c.bestEstimate;
+      if (s == null) continue;
+      const line = `L${s}${c.score == null ? "~" : ""} \xB7 ${(g.date ?? "").slice(0, 10)} \xB7 ${(g.title ?? g.sessionId ?? "").replace(/\n.*/s, "").slice(0, 60)} \xB7 ${g.sessionId} \u2014 ${(c.instance ?? "").slice(0, 110)}`;
+      (byCriterion.get(c.key) ?? byCriterion.set(c.key, []).get(c.key)).push({ s, line });
+    }
+  }
+  if (!byCriterion.size) return;
+  const blocks = [...byCriterion.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(
+    ([key, rows]) => `## ${key}
+${rows.sort((a, b) => b.s - a.s).map((r) => r.line).join("\n")}`
+  );
+  await fs23.writeFile(
+    path28.join(docs, "_scoreboard.md"),
+    `# Scoreboard \u2014 every graded session per criterion, best first.
+# Lx~ = estimate. Format: level \xB7 date \xB7 title \xB7 sessionId \u2014 graded instance.
+
+${blocks.join("\n\n")}
+`
+  );
+}
+async function ensureCodingDocs(codingDir, sessions) {
+  const docs = path28.join(codingDir, "docs");
+  await fs23.mkdir(docs, { recursive: true });
+  const user = sessions.filter((s) => s.sessionId && !s.duplicateOf && (!("klass" in s) || s.klass === "interactive"));
+  let written = 0;
+  for (const s of user) {
+    const out = path28.join(docs, `${s.sessionId}.txt`);
+    try {
+      await fs23.access(out);
+      continue;
+    } catch {
+    }
+    const mat = await materializeSession2(s.file).catch(() => null);
+    if (!mat?.text) continue;
+    await fs23.writeFile(out, mat.text);
+    written++;
+  }
+  const rows = user.sort((a, b) => (a.start ?? "") < (b.start ?? "") ? -1 : 1).map((s) => `${(s.start ?? "").slice(0, 10)} \xB7 ${(s.title ?? "").replace(/\n.*/s, "").slice(0, 80)} \xB7 ${s.sessionId}`);
+  await fs23.writeFile(path28.join(docs, "_map.md"), rows.join("\n") + "\n");
+  await writeScoreboard(codingDir, docs);
+  if (written) console.log(`[docs] materialized ${written} new transcript(s) \u2192 ${docs}`);
+  return docs;
+}
+function sourceLookupNote() {
+  return `
+
+SOURCE LOOKUP \u2014 you have Read/Grep/Glob over the working directory, which holds EVERYTHING known about this person's coding work. MAPS FIRST, grep second (the engine rule): docs/_scoreboard.md ranks every graded session per criterion, best first \u2014 one glance shows where the spikes/flair are, so start there when hunting peaks or checking whether a high mark is consistent or a one-off; day-digest.json is the day-by-day story of what they did in order \u2014 read the relevant days to get the arc before searching; docs/_map.md lists every session (date \xB7 title \xB7 sessionId). Then drill down: walkthroughs/<sessionId>.json is that session's phase-by-phase account (cheap, already distilled), grades/<sessionId>.json its graded findings with quotes, and docs/<sessionId>.txt the FULL transcript (">> " = the person, "[AI]" = the model) \u2014 the ground truth, read it when the distilled layers can't settle it. Other artifacts (flow.json, delegation/, expertise/, aggregate.json) are there too if a claim depends on them. The digest you were given is the spine \u2014 use lookups when a CLAIM-MOVING question cannot be settled from it (a moment you are about to headline, a promotion/depth call, an ambiguous engagement, whether detail was vision or boilerplate). VERIFY every verbatim quote you cite by finding it in the transcript first; if you cannot find it, do not use it. Look up what changes the output \u2014 do not re-read the whole corpus.`;
+}
+
+// ../../lib/agents/coding/promptCache.ts
+import { createHash as createHash3 } from "crypto";
+import { promises as fs24 } from "fs";
+function promptSha(parts) {
+  const h = createHash3("sha256");
+  for (const p of parts) {
+    h.update(p ?? "");
+    h.update("\0");
+  }
+  return h.digest("hex").slice(0, 16);
+}
+async function reusableOutput(outPath, sha, valid, key = "promptSha") {
+  try {
+    const o = JSON.parse(await fs24.readFile(outPath, "utf8"));
+    if (o[key] === sha && valid(o)) return o;
+  } catch {
+  }
+  return null;
+}
+
+// ../../lib/agents/coding/profile.ts
+import { promises as fs26 } from "fs";
+import path30 from "path";
+
+// ../../lib/agents/coding/walkthrough.ts
+import { promises as fs25 } from "fs";
+import path29 from "path";
+var IDLE_CAP_MS = 12 * 6e4;
+async function readWalkthrough(outDir, sessionId) {
+  return fs25.readFile(path29.join(outDir, `${sessionId}.json`), "utf8").then(JSON.parse).catch(() => null);
+}
+
+// ../../lib/agents/coding/workstyle.ts
+var MIN3 = 6e4;
+var DAY_CUTOFF_H = 5;
+var FLOW_THRESHOLD_MIN = 30;
+var pct = (x) => `${Math.round(x * 100)}%`;
+var fmtN = (n) => n.toLocaleString("en-US");
+var round13 = (x) => Math.round(x * 10) / 10;
+var median = (xs) => xs.length ? [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)] : 0;
+function fmtDur2(min) {
+  return min >= 60 ? `${round13(min / 60)}h` : `${Math.round(min)}m`;
+}
+function clockLabel(h) {
+  if (h === 0) return "midnight";
+  if (h === 12) return "noon";
+  return h < 12 ? `${h}am` : `${h - 12}pm`;
+}
+function pick(ladder, score, fallback = "not enough signal yet") {
+  if (score == null) return fallback;
+  const r = Math.round(score);
+  const keys = Object.keys(ladder).map(Number).sort((a, b) => a - b);
+  let chosen = keys[0];
+  for (const k of keys) if (k <= r) chosen = k;
+  return ladder[chosen];
+}
+var TASTE = {
+  4: "mostly rubber-stamps what the AI produces",
+  5: "an ordinary reviewer's bar",
+  6: "rejects the obviously-bad version and iterates toward something better",
+  7: "holds a real, specific quality bar and pushes past the AI's first answer",
+  8: "makes the call the AI couldn't reach on its own \u2014 opinionated, specific, vindicated",
+  9: "high, particular taste \u2014 names AI slop the moment it appears",
+  10: "brings a developed vision up front, and knows where not to impose it",
+  11: "world-class taste"
+};
+var DELEGATION = {
+  4: "still uneven \u2014 sometimes under-briefs work they had opinions about",
+  6: "roughly calibrated on when to do the thinking themselves vs. let the AI run",
+  8: "well-calibrated \u2014 front-loads the specifiable, reserves correction for genuine AI errors, lets rote run",
+  10: "near-perfect prompt economy \u2014 almost everything knowable is front-loaded"
+};
+var OUTCOMES = {
+  4: "sessions often wrap before a real capability lands",
+  6: "one real, confirmed thing shipped is the typical bar",
+  8: "a substantial, verified capability per session is routine",
+  10: "ships end-to-end-checked work that unblocks a lot downstream"
+};
+var GENERATIVE = {
+  4: "reaches workable answers with effort",
+  6: "real ideas and sound tradeoff reasoning",
+  7: "collapses messy situations to their essence and reasons from first principles",
+  8: "fast collapse to the core, plus its own approach and the exact fix",
+  9: "generates frameworks and reframes others wouldn't reach",
+  10: "out-reasons the tool \u2014 lands insights the AI itself missed"
+};
+var METACOGNITION = {
+  4: "notices friction but mostly just flags it",
+  6: "spots a bottleneck and adjusts how they work for the case at hand",
+  8: "treats their own throughput as an engineering problem \u2014 names recurring friction and restructures to kill it",
+  10: "re-architects the whole way of working mid-stream to get unstuck"
+};
+var EXPERTISE = {
+  2: "defers to the AI on system decisions \u2014 no specific knowledge surfaces",
+  4: "opinions are mostly generic best-practice the AI already had",
+  6: "knows their own stack well and corrects the AI on real systems facts",
+  8: "repeatedly catches what the AI misses with specific systems/tooling calls a junior wouldn't make",
+  9: "deep, specific directives about their own infra a junior wouldn't know",
+  10: "makes counter-intuitive, deep-operating-knowledge calls the AI would have gotten backwards"
+};
+var FRONTIER = {
+  2: "one session at a time, default settings",
+  4: "occasionally runs two things; no structural tooling",
+  6: "routinely parallel, queuing work ahead and organizing sessions",
+  8: "real leverage \u2014 overnight/remote runs, subagents, scripts that drive the AI",
+  10: "builds harnesses and workflows; loops and scales the AI across machines"
+};
+function flowRunsFromSlots(slots) {
+  const fSlots = Object.keys(slots).map(Number).filter((s) => slots[String(s)] === "F").sort((a, b) => a - b);
+  const runs = [];
+  let start = null, prev = null;
+  const flush = () => {
+    if (start !== null && prev !== null) runs.push((prev - start + 1) * 10);
+  };
+  for (const s of fSlots) {
+    if (prev !== null && s === prev + 1) {
+      prev = s;
+    } else {
+      flush();
+      start = s;
+      prev = s;
+    }
+  }
+  flush();
+  return runs;
+}
+function buildFlow(runMin, ctx) {
+  const sorted = [...runMin].sort((a, b) => a - b);
+  const BUCKET_DEFS = [["\u2264 20m", 0, 30], ["30m\u20131h", 30, 60], ["1\u20132h", 60, 120], ["2h+", 120, Infinity]];
+  const flowBlocks = BUCKET_DEFS.map(([label, lo, hi]) => {
+    const inB = sorted.filter((x) => x >= lo && x < hi);
+    return { label, lo, hi, count: inB.length, min: round13(inB.reduce((a, b) => a + b, 0)) };
+  });
+  const deepBlocks = sorted.filter((x) => x >= FLOW_THRESHOLD_MIN).length;
+  const flowHoursPerDay = ctx.activeDays ? ctx.flowHoursTotal / ctx.activeDays : 0;
+  const deepBlocksPerDay = ctx.activeDays ? deepBlocks / ctx.activeDays : 0;
+  const flowCadence = ctx.flowFraction >= 0.45 && flowHoursPerDay >= 1.5 ? "frequent" : ctx.flowFraction < 0.18 ? "rare" : "interspersed";
+  const longest = sorted.length ? Math.max(...sorted) : 0;
+  const med2 = median(sorted);
+  const flowBullets = [];
+  flowBullets.push(`${round13(ctx.flowHoursTotal)}h of genuine flow over ${ctx.activeDays} working days \u2014 about ${round13(flowHoursPerDay)}h a day.`);
+  flowBullets.push(`${pct(ctx.flowFraction)} of active working time is true flow (rapid rhythm or dictation); the rest is thinking-pauses and switching.`);
+  if (flowCadence === "frequent") {
+    flowBullets.push(`Deep flow is a daily norm \u2014 ${deepBlocks} runs of ${FLOW_THRESHOLD_MIN}m+, longest ${fmtDur2(longest)}; highly productive once locked in.`);
+  } else if (flowCadence === "interspersed") {
+    flowBullets.push(`Flow comes in solid bursts \u2014 ${med2}\u2013${longest}m at a time, ${deepBlocks} runs of ${FLOW_THRESHOLD_MIN}m+ \u2014 interspersed with pauses and rapid context-switching across parallel sessions.`);
+  } else {
+    flowBullets.push(`Flow is sporadic \u2014 mostly short focused windows rather than long unbroken runs.`);
+  }
+  if (ctx.peakFlowDay) flowBullets.push(`Best day: ${round13(ctx.peakFlowDay.hours)}h in flow (${pct(ctx.peakFlowDay.fraction)} of that day's working time).`);
+  return {
+    flowSource: ctx.source,
+    flowThresholdMin: FLOW_THRESHOLD_MIN,
+    flowBlocks,
+    blockCount: sorted.length,
+    deepBlocks,
+    longestBlockMin: round13(longest),
+    medianBlockMin: round13(med2),
+    flowFraction: Math.round(ctx.flowFraction * 100) / 100,
+    flowHoursTotal: round13(ctx.flowHoursTotal),
+    flowHoursPerDay: round13(flowHoursPerDay),
+    deepBlocksPerDay: round13(deepBlocksPerDay),
+    flowCadence,
+    peakFlowDay: ctx.peakFlowDay,
+    flowBullets
+  };
+}
+function computeWorkstyle(inp) {
+  const { tz, idleGapMin } = inp;
+  const idleGapMs = idleGapMin * MIN3;
+  const all = [];
+  for (const day of inp.dayChart) for (const c of day.conversations) for (const iv of c.intervals) all.push(iv);
+  all.sort((a, b) => a[0] - b[0]);
+  const parts = (ms2) => {
+    const [h, m2, s] = new Date(ms2).toLocaleTimeString("en-GB", { timeZone: tz, hour12: false }).split(":").map(Number);
+    return { h, m: m2, s };
+  };
+  const localDate3 = (ms2) => new Date(ms2).toLocaleDateString("en-CA", { timeZone: tz });
+  const sinceCutoff = (ms2) => {
+    const { h, m: m2 } = parts(ms2);
+    let x = (h - DAY_CUTOFF_H) * 60 + m2;
+    if (x < 0) x += 1440;
+    return x;
+  };
+  const logicalDate = (ms2) => localDate3(ms2 - DAY_CUTOFF_H * 36e5);
+  const fromCutoff = (x) => {
+    const t = (x + DAY_CUTOFF_H * 60) % 1440;
+    return `${String(Math.floor(t / 60)).padStart(2, "0")}:${String(Math.round(t % 60)).padStart(2, "0")}`;
+  };
+  const hourMin = new Array(24).fill(0);
+  for (const [a, b] of all) {
+    let cur = a;
+    while (cur < b) {
+      const { h, m: m2, s } = parts(cur);
+      const msToNextHour = ((59 - m2) * 60 + (60 - s)) * 1e3;
+      const segEnd = Math.min(b, cur + msToNextHour);
+      hourMin[h] += (segEnd - cur) / MIN3;
+      cur = segEnd;
+    }
+  }
+  const hourly = hourMin.map((min, hour) => ({ hour, min: round13(min) }));
+  const totalMin = hourMin.reduce((a, b) => a + b, 0) || 1;
+  const sumHours = (hs) => hs.reduce((a, h) => a + hourMin[h], 0);
+  const shares = {
+    morning: sumHours([5, 6, 7, 8, 9, 10, 11]) / totalMin,
+    afternoon: sumHours([12, 13, 14, 15, 16, 17]) / totalMin,
+    evening: sumHours([18, 19, 20, 21]) / totalMin,
+    lateNight: sumHours([22, 23, 0, 1, 2, 3, 4]) / totalMin
+  };
+  const peakHours = [...hourMin.keys()].filter((h) => hourMin[h] > 0).sort((a, b) => hourMin[b] - hourMin[a]).slice(0, 3);
+  const peak0 = peakHours[0] ?? 12;
+  const isNightOwl = shares.lateNight >= 0.2 || peak0 >= 22 || peak0 <= 3;
+  let lunchDip = null;
+  const dipFloor = totalMin / 40;
+  for (const h of [12, 13, 14]) {
+    if (hourMin[h] < hourMin[h - 1] * 0.7 && hourMin[h] < hourMin[h + 1] * 0.7 && hourMin[h - 1] > dipFloor && hourMin[h + 1] > dipFloor) {
+      if (lunchDip == null || hourMin[h] < hourMin[lunchDip]) lunchDip = h;
+    }
+  }
+  const env = /* @__PURE__ */ new Map();
+  for (const [a, b] of all) {
+    const ld = logicalDate(a);
+    let s = sinceCutoff(a), e = sinceCutoff(b);
+    if (e < s) e += 1440;
+    const cur = env.get(ld) ?? { first: Infinity, last: -Infinity };
+    cur.first = Math.min(cur.first, s);
+    cur.last = Math.max(cur.last, e);
+    env.set(ld, cur);
+  }
+  const startsM = [...env.values()].map((v) => v.first);
+  const endsM = [...env.values()].map((v) => v.last);
+  const daysObserved = env.size;
+  const typicalStart = startsM.length ? fromCutoff(median(startsM)) : "\u2014";
+  const typicalEnd = endsM.length ? fromCutoff(median(endsM)) : "\u2014";
+  const earliestStart = startsM.length ? fromCutoff(Math.min(...startsM)) : "\u2014";
+  const latestEnd = endsM.length ? fromCutoff(Math.max(...endsM)) : "\u2014";
+  let flow;
+  if (inp.flow && inp.flow.days.length) {
+    const runs = [];
+    for (const d of inp.flow.days) runs.push(...flowRunsFromSlots(d.slots));
+    const peak = [...inp.flow.days].sort((a, b) => b.flowHours - a.flowHours)[0];
+    flow = buildFlow(runs, {
+      source: "flow.json",
+      activeDays: inp.flow.totals.activeDays,
+      flowFraction: inp.flow.totals.flowFraction,
+      flowHoursTotal: inp.flow.totals.flowSlots / 6,
+      peakFlowDay: peak ? { date: peak.date, hours: peak.flowHours, fraction: peak.flowFraction } : null
+    });
+  } else {
+    const merged = [];
+    for (const [a, b] of all) {
+      const last = merged[merged.length - 1];
+      if (last && a <= last[1] + idleGapMs) last[1] = Math.max(last[1], b);
+      else merged.push([a, b]);
+    }
+    const blocks = merged.map(([a, b]) => (b - a) / MIN3);
+    const totalBlockMin = blocks.reduce((a, b) => a + b, 0) || 1;
+    const deepMin = blocks.filter((x) => x >= FLOW_THRESHOLD_MIN).reduce((a, b) => a + b, 0);
+    flow = buildFlow(blocks, {
+      source: "intervals",
+      activeDays: daysObserved,
+      flowFraction: deepMin / totalBlockMin,
+      flowHoursTotal: deepMin / 60,
+      peakFlowDay: null
+    });
+  }
+  const m = (k) => inp.criteriaMean[k] ?? { mean: null, n: 0 };
+  const judgment = [
+    { key: "taste", label: "Taste", score: m("taste").mean, n: m("taste").n },
+    { key: "delegation", label: "Calibration", score: m("delegation").mean, n: m("delegation").n },
+    { key: "generative", label: "Under ambiguity", score: m("generative").mean, n: m("generative").n },
+    { key: "metacognition", label: "Self-direction", score: m("metacognition").mean, n: m("metacognition").n },
+    { key: "outcomes", label: "Outcomes", score: m("outcomes").mean, n: m("outcomes").n }
+  ];
+  const rhythmBullets = [];
+  const lateTail = /^(0[0-5]|2[3])/.test(latestEnd);
+  rhythmBullets.push(`Works roughly ${typicalStart}\u2013${typicalEnd} on a typical day${lateTail ? `, with sessions running as late as ${latestEnd}` : ""}.`);
+  if (isNightOwl) {
+    rhythmBullets.push(`A night owl \u2014 ${pct(shares.lateNight)} of the work lands after 10pm or in the small hours.`);
+  } else if (shares.morning >= shares.afternoon && shares.morning >= shares.evening) {
+    rhythmBullets.push(`An early bird \u2014 most of the work happens before noon (${pct(shares.morning)} of active time).`);
+  } else if (shares.afternoon >= shares.evening) {
+    rhythmBullets.push(`An afternoon worker \u2014 ${pct(shares.afternoon)} of active time falls between noon and 6pm, only ${pct(shares.lateNight)} in the small hours.`);
+  } else {
+    rhythmBullets.push(`An evening worker \u2014 work concentrates after 6pm (${pct(shares.evening)} of active time).`);
+  }
+  {
+    let txt = `Productivity peaks around ${clockLabel(peak0)}`;
+    const p1 = peakHours.find((h) => Math.abs(h - peak0) >= 3);
+    if (p1 != null) txt += `, with a second push around ${clockLabel(p1)}`;
+    rhythmBullets.push(txt + ".");
+  }
+  if (lunchDip != null) rhythmBullets.push(`Takes a visible midday breather around ${clockLabel(lunchDip)}.`);
+  const judgmentBullets = [];
+  judgmentBullets.push(`Judgment & taste \u2014 ${pick(TASTE, m("taste").mean)}; on delegation, ${pick(DELEGATION, m("delegation").mean)}.`);
+  {
+    const cad = inp.outcomeCadence ? `ships something meaningful ~${round13(inp.outcomeCadence.perWeek)}\xD7/week (${pct(inp.outcomeCadence.fraction)} of working days), and ` : "";
+    judgmentBullets.push(`High-outcome work \u2014 ${cad}${pick(OUTCOMES, m("outcomes").mean)}.`);
+  }
+  judgmentBullets.push(`Under ambiguity \u2014 ${pick(GENERATIVE, m("generative").mean)}; strongest where there's no ground truth and the task is to invent what to measure.`);
+  judgmentBullets.push(`Prioritizing the work \u2014 ${pick(METACOGNITION, m("metacognition").mean)}.`);
+  const exp = m("expertise").mean, cog = m("generative").mean, fr = m("frontier").mean;
+  const sig = inp.signals;
+  let archetype;
+  if (exp == null || cog == null) {
+    archetype = "Not enough graded signal yet to place the technical profile.";
+  } else if (cog - exp >= 1.2) {
+    archetype = "Cognition-forward \u2014 reasoning runs ahead of hands-on systems depth: thinks like a senior, with some stack-specific knowledge still leveling up.";
+  } else if (exp - cog >= 1.2) {
+    archetype = "Specialist \u2014 deep, specific systems and architecture knowledge is the anchor, ahead of raw abstraction.";
+  } else if (exp >= 8 && cog >= 8) {
+    archetype = "Deep and sharp \u2014 strong systems knowledge matched by top-tier reasoning.";
+  } else {
+    archetype = "Balanced operator \u2014 solid systems knowledge and reasoning move in step, both clearly competent.";
+  }
+  const gap = exp != null && cog != null ? cog > exp + 0.8 ? "noticeably ahead of the stack-specific knowledge" : exp > cog + 0.8 ? "with the systems depth running slightly ahead" : "roughly in step with the systems depth" : "";
+  const sigBits = [];
+  if (sig.maxConcurrency >= 2) sigBits.push(`up to \xD7${sig.maxConcurrency} sessions at once`);
+  if (sig.subagents > 0) sigBits.push(`${fmtN(sig.subagents)} subagent spawns`);
+  if (sig.queueOps > 0) sigBits.push(`${fmtN(sig.queueOps)} queue-ahead ops`);
+  if (sig.mcpTools > 0) sigBits.push(`${sig.mcpTools} MCP tool${sig.mcpTools > 1 ? "s" : ""}`);
+  const sigSentence = sigBits.length ? sigBits.join(", ") : "mostly single-session work";
+  const experienced = sig.maxConcurrency >= 3 && (sig.queueOps > 50 || sig.subagents > 0 || sig.mcpTools > 0);
+  const technical = {
+    expertise: exp,
+    cognition: cog,
+    frontier: fr,
+    signals: sig,
+    archetype,
+    bullets: [
+      `Systems & architecture \u2014 ${pick(EXPERTISE, exp)}.`,
+      `Raw cognition \u2014 ${pick(GENERATIVE, cog)}${gap ? `, ${gap}` : ""}.`,
+      `Agent fluency \u2014 ${experienced ? "clearly an experienced agent operator; " : ""}${pick(FRONTIER, fr)} (${sigSentence}).`
+    ]
+  };
+  return {
+    tz,
+    daysObserved,
+    activeHours: round13(totalMin / 60),
+    typicalStart,
+    typicalEnd,
+    earliestStart,
+    latestEnd,
+    hourly,
+    peakHours,
+    shares,
+    isNightOwl,
+    lunchDip,
+    rhythmBullets,
+    ...flow,
+    judgment,
+    judgmentBullets,
+    technical
+  };
+}
+
+// ../../lib/agents/coding/benchmarks.ts
+var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
+
+// ../../lib/agents/coding/profile.ts
+var ROOT2 = process.cwd();
+var CODING_DIR2 = process.env.POLYMATH_DATA_DIR ? path30.join(process.env.POLYMATH_DATA_DIR, "coding") : path30.join(ROOT2, ".data", "coding");
+var UMETA = /* @__PURE__ */ new Map();
+async function userMeta(sessionId, file2) {
+  const hit = UMETA.get(sessionId);
+  if (hit) return hit;
+  const msgs = await extractUserMessages(file2).catch(() => []);
+  const meta = msgs.map((m) => ({ t: m.t, words: typedWords(m.text, m.gapMs), key: m.uuid ?? `${m.t}|${m.text}` }));
+  UMETA.set(sessionId, meta);
+  return meta;
+}
+var GRADES2 = path30.join(CODING_DIR2, "grades");
+async function readJson2(p, fallback) {
+  return fs26.readFile(p, "utf8").then((s) => JSON.parse(s)).catch(() => fallback);
+}
+function cadenceScore(fraction, multiRatio) {
+  let s;
+  if (fraction >= 0.85) s = 10;
+  else if (fraction >= 0.6) s = 9;
+  else if (fraction >= 0.45) s = 8;
+  else if (fraction >= 0.3) s = 7;
+  else if (fraction >= 0.2) s = 6;
+  else if (fraction >= 0.12) s = 5;
+  else if (fraction >= 0.06) s = 4;
+  else s = 3;
+  if (s >= 10 && multiRatio >= 0.3) s = 11;
+  return s;
+}
+function distOf3(takes) {
+  const vals = takes.map((t) => t.score ?? t.best).filter((v) => v != null);
+  const n = vals.length;
+  if (!n) return { n: 0, observed: 0, mean: null, median: null, hist: [] };
+  const observed = takes.filter((t) => t.score != null).length;
+  const mean2 = Math.round(vals.reduce((a, b) => a + b, 0) / n * 100) / 100;
+  const sorted = [...vals].sort((a, b) => a - b);
+  const median2 = n % 2 ? sorted[(n - 1) / 2] : (sorted[n / 2 - 1] + sorted[n / 2]) / 2;
+  const h = /* @__PURE__ */ new Map();
+  for (const v of vals) h.set(Math.round(v), (h.get(Math.round(v)) ?? 0) + 1);
+  const hist = [...h.keys()].sort((a, b) => b - a).map((level) => ({ level, count: h.get(level) }));
+  return { n, observed, mean: mean2, median: median2, hist };
+}
+async function compileCodingProfile() {
+  const allRecords = await readJson2(path30.join(CODING_DIR2, "sessions.json"), []);
+  const dupIds = new Set(allRecords.filter((s) => s.duplicateOf).map((s) => s.sessionId));
+  const sessions = allRecords.filter((s) => !s.duplicateOf);
+  const conc = await readJson2(path30.join(CODING_DIR2, "concurrency.json"), null);
+  const renames = await readJson2(path30.join(CODING_DIR2, "renames.json"), []);
+  const byId = new Map(sessions.map((s) => [s.sessionId, s]));
+  let gradeFiles = [];
+  try {
+    gradeFiles = (await fs26.readdir(GRADES2)).filter((f) => f.endsWith(".json"));
+  } catch {
+  }
+  const grades = [];
+  for (const f of gradeFiles) {
+    const g = await readJson2(path30.join(GRADES2, f), null);
+    if (g && byId.has(g.sessionId)) grades.push(g);
+  }
+  const takesByCriterion = /* @__PURE__ */ new Map();
+  for (const g of grades) {
+    for (const c of g.criteria) {
+      const t = {
+        sessionId: g.sessionId,
+        title: g.title || byId.get(g.sessionId)?.title || g.sessionId,
+        date: (g.date || "").slice(0, 10),
+        score: c.score,
+        best: c.bestEstimate,
+        instance: c.instance,
+        why: c.why,
+        quotes: c.quotes,
+        confidence: c.confidence
+      };
+      if (c.score == null && c.bestEstimate == null) continue;
+      (takesByCriterion.get(c.key) ?? takesByCriterion.set(c.key, []).get(c.key)).push(t);
+    }
+  }
+  const criteria = CODING_CRITERIA.map((c) => {
+    const takes = (takesByCriterion.get(c.key) ?? []).sort((a, b) => (b.score ?? b.best ?? 0) - (a.score ?? a.best ?? 0));
+    return { key: c.key, label: c.label, graded: c.graded, definition: c.definition, dist: distOf3(takes), takes };
+  });
+  const tz = conc?.tz || "America/Los_Angeles";
+  const localDate3 = (iso) => iso ? new Date(Date.parse(iso)).toLocaleDateString("en-CA", { timeZone: tz }) : "";
+  let outcomeCadence = null;
+  {
+    const activeDates = new Set(sessions.map((s) => localDate3(s.start)).filter(Boolean));
+    const meaningfulPerDay = /* @__PURE__ */ new Map();
+    for (const g of grades) {
+      const date = localDate3(byId.get(g.sessionId)?.start || g.date || "");
+      if (!date) continue;
+      const out = g.criteria.find((c) => c.key === "outcomes")?.score ?? null;
+      const meta = g.criteria.find((c) => c.key === "metacognition")?.score ?? null;
+      if (out != null && out >= 6 || meta != null && meta >= 8) meaningfulPerDay.set(date, (meaningfulPerDay.get(date) ?? 0) + 1);
+    }
+    const activeDays = activeDates.size;
+    const meaningfulDays = meaningfulPerDay.size;
+    const multiMeaningfulDays = [...meaningfulPerDay.values()].filter((n) => n >= 2).length;
+    if (activeDays > 0) {
+      const dates2 = [...activeDates].sort();
+      const spanDays = Math.max(1, (Date.parse(dates2[dates2.length - 1]) - Date.parse(dates2[0])) / 864e5 + 1);
+      const fraction = meaningfulDays / activeDays;
+      outcomeCadence = {
+        activeDays,
+        meaningfulDays,
+        multiMeaningfulDays,
+        fraction: Math.round(fraction * 100) / 100,
+        perWeek: Math.round(meaningfulDays / (spanDays / 7) * 10) / 10,
+        score: cadenceScore(fraction, meaningfulDays ? multiMeaningfulDays / meaningfulDays : 0)
+      };
+    }
+  }
+  const perDayMeta = new Map((conc?.perDay ?? []).map((d) => [d.date, d]));
+  const gradeById = new Map(grades.map((g) => [g.sessionId, g]));
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const date = localDate3(s.start);
+    if (!date) continue;
+    let day = dayMap.get(date);
+    if (!day) {
+      const m = perDayMeta.get(date);
+      day = { date, peakConcurrency: m?.peakConcurrency ?? 1, sessionsStarted: m?.sessionsStarted ?? 0, activeMin: m?.activeMin ?? 0, sessions: [] };
+      dayMap.set(date, day);
+    }
+    const g = gradeById.get(s.sessionId);
+    const findings = {};
+    if (g) {
+      for (const c of g.criteria) if (c.instance && (c.score != null || c.bestEstimate != null)) findings[c.key] = { score: c.score ?? c.bestEstimate, instance: c.instance, why: c.why || "", quotes: c.quotes || [] };
+    }
+    day.sessions.push({ sessionId: s.sessionId, title: s.title, gradable: !!g, findings });
+  }
+  const timeline = [...dayMap.values()].sort((a, b) => b.date.localeCompare(a.date));
+  const levelHist = conc?.levelHistogramMin ?? {};
+  const sumFrom = (min) => Object.entries(levelHist).filter(([k]) => Number(k) >= min).reduce((a, [, v]) => a + v, 0);
+  const topWindows = (conc?.segments ?? []).slice().sort((a, b) => b.level - a.level || b.minutes - a.minutes).slice(0, 12).map((s) => ({ start: s.start, end: s.end, minutes: s.minutes, level: s.level, titles: [...new Set(s.sessions.map((x) => x.title))] }));
+  const parallelism = {
+    maxConcurrency: conc?.maxConcurrency ?? 0,
+    levelHistogramMin: levelHist,
+    minutesAt2plus: Math.round(sumFrom(2)),
+    minutesAt6plus: Math.round(sumFrom(6)),
+    topWindows,
+    queueOps: sessions.reduce((a, s) => a + s.queueOps, 0),
+    renames,
+    renamedSessions: sessions.filter((s) => s.renamed).length,
+    tz: conc?.tz ?? "",
+    idleGapMin: conc?.idleGapMin ?? 5
+  };
+  const dates = sessions.map((s) => s.start).filter(Boolean).sort();
+  const models = /* @__PURE__ */ new Map();
+  for (const s of sessions) for (const [m, n] of Object.entries(s.models)) models.set(m, (models.get(m) ?? 0) + n);
+  const topDays = (conc?.perDay ?? []).slice().sort((a, b) => b.activeMin - a.activeMin).slice(0, 12).map((d) => ({ date: d.date, activeMin: d.activeMin, sessionsStarted: d.sessionsStarted, peakConcurrency: d.peakConcurrency, firstStart: d.firstStart, lastEnd: d.lastEnd, spanMin: d.spanMin }));
+  const lateNight = (conc?.perDay ?? []).filter((d) => {
+    const h = Number(d.firstStart.slice(0, 2));
+    const e = Number(d.lastEnd.slice(0, 2));
+    return e >= 22 || e < 5 || h < 5;
+  }).length;
+  const throughput = {
+    sessions: sessions.length,
+    activeHours: Math.round(sessions.reduce((a, s) => a + s.activeMin, 0) / 60 * 10) / 10,
+    dateRange: { from: (dates[0] || "").slice(0, 10), to: (dates[dates.length - 1] || "").slice(0, 10) },
+    topDays,
+    toolCalls: sessions.reduce((a, s) => a + s.toolCalls, 0),
+    subagents: sessions.reduce((a, s) => a + s.subagentSpawns, 0),
+    models: Object.fromEntries([...models.entries()].sort((a, b) => b[1] - a[1])),
+    lateNightSessions: lateNight
+  };
+  const agglomeration = await readJson2(path30.join(CODING_DIR2, "agglomerate.json"), null);
+  const dayDigest = await readJson2(path30.join(CODING_DIR2, "day-digest.json"), null);
+  if (dayDigest?.days) dayDigest.days = dayDigest.days.map((day) => {
+    const convs = day.conversations.filter((c) => byId.has(c.sessionId));
+    return { ...day, conversations: convs, conversationsTouched: convs.length, totalMessages: convs.reduce((a, c) => a + c.messageCount, 0) };
+  }).filter((day) => day.conversations.length > 0);
+  const dayChart = await readJson2(path30.join(CODING_DIR2, "day-chart.json"), []);
+  const intervalsBy = /* @__PURE__ */ new Map();
+  const titleBy = /* @__PURE__ */ new Map();
+  const fileById = new Map(sessions.map((s) => [s.sessionId, s.file]));
+  for (const day of dayChart) for (const c of day.conversations) {
+    const arr = intervalsBy.get(c.sessionId) ?? [];
+    arr.push(...c.intervals);
+    intervalsBy.set(c.sessionId, arr);
+    titleBy.set(c.sessionId, c.title);
+  }
+  const listOverlapMs = (A, B) => {
+    let ms2 = 0;
+    for (const [a0, a1] of A) for (const [b0, b1] of B) {
+      const lo = Math.max(a0, b0), hi = Math.min(a1, b1);
+      if (hi > lo) ms2 += hi - lo;
+    }
+    return ms2;
+  };
+  const walkthroughs = {};
+  const wdir = path30.join(CODING_DIR2, "walkthroughs");
+  for (const f of await fs26.readdir(wdir).catch(() => [])) {
+    if (!f.endsWith(".json")) continue;
+    const w = await readWalkthrough(wdir, f.replace(".json", ""));
+    if (!w || !byId.has(w.sessionId)) continue;
+    const own = intervalsBy.get(w.sessionId) ?? [];
+    const ownTitle = titleBy.get(w.sessionId) ?? w.title;
+    const um = await userMeta(w.sessionId, fileById.get(w.sessionId) ?? "");
+    const sessionEnd = own.length ? Math.max(...own.map((iv) => iv[1])) : w.phases[w.phases.length - 1]?.fromMs ?? 0;
+    const phases = w.phases.map((p, i) => {
+      const w0 = p.fromMs;
+      const w1 = i + 1 < w.phases.length ? w.phases[i + 1].fromMs : sessionEnd + 1;
+      const inPhase = um.filter((m) => m.t >= w0 && m.t < w1);
+      const userPrompts = inPhase.length;
+      const words = inPhase.reduce((s, m) => s + m.words, 0);
+      const wordsPerMsg = userPrompts ? Math.round(words / userPrompts) : 0;
+      const ownInWin = own.map(([a, b]) => [Math.max(a, w0), Math.min(b, w1)]).filter(([a, b]) => b > a);
+      const durationMin = Math.round(ownInWin.reduce((s, [a, b]) => s + (b - a), 0) / 6e4);
+      const byTitle = /* @__PURE__ */ new Map();
+      for (const [sid, ivs] of intervalsBy) {
+        if (sid === w.sessionId) continue;
+        const t = titleBy.get(sid) ?? "(untitled)";
+        if (t === ownTitle) continue;
+        const ms2 = listOverlapMs(ownInWin, ivs);
+        if (ms2 >= 6e4) byTitle.set(t, (byTitle.get(t) ?? 0) + ms2);
+      }
+      const parallel = [...byTitle.entries()].map(([title, ms2]) => ({ title, overlapMin: Math.round(ms2 / 6e4) })).sort((a, b) => b.overlapMin - a.overlapMin).slice(0, 6);
+      return { what: p.what, durationMin, fromMs: w0, toMs: w1, userPrompts, words, wordsPerMsg, parallel };
+    });
+    walkthroughs[w.sessionId] = { phases, totalActiveMin: w.totalActiveMin, userTurns: w.userTurns };
+  }
+  const rubric2 = Object.fromEntries(
+    CODING_CRITERIA.filter((c) => c.graded).map((c) => [c.key, { label: c.label, definition: c.definition, read: c.read, rungs: c.rungs ?? [] }])
+  );
+  await Promise.all(sessions.map((s) => userMeta(s.sessionId, s.file)));
+  const wordsByDay = {};
+  const seenMsg = /* @__PURE__ */ new Set();
+  for (const s of sessions) for (const m of UMETA.get(s.sessionId) ?? []) {
+    if (seenMsg.has(m.key)) continue;
+    seenMsg.add(m.key);
+    const d = new Date(m.t).toLocaleDateString("en-CA", { timeZone: tz });
+    wordsByDay[d] = (wordsByDay[d] ?? 0) + m.words;
+  }
+  const dayThroughput = {};
+  for (const [d, n] of Object.entries(wordsByDay)) dayThroughput[d] = throughputScore(n);
+  const tCeiling = throughputCeiling(Object.values(wordsByDay));
+  const criteriaMean = {};
+  for (const c of criteria) criteriaMean[c.key] = { mean: c.dist.mean, n: c.dist.n };
+  const flow = await readJson2(path30.join(CODING_DIR2, "flow.json"), null);
+  const focus = await readJson2(path30.join(CODING_DIR2, "focus.json"), null);
+  const expertiseMap = await readJson2(path30.join(CODING_DIR2, "expertise.json"), null);
+  const frontierArsenal = await readJson2(path30.join(CODING_DIR2, "frontier.json"), null);
+  const frontierDetail = await readJson2(path30.join(CODING_DIR2, "frontier-detail.json"), null);
+  const coaching = await readJson2(path30.join(CODING_DIR2, "coaching.json"), null);
+  const gap = await readJson2(path30.join(CODING_DIR2, "gap.json"), null);
+  const aggregate = await readJson2(path30.join(CODING_DIR2, "aggregate.json"), null);
+  const delegationRollup = await readJson2(path30.join(CODING_DIR2, "delegation-rollup.json"), null);
+  const gapDist = await readJson2(path30.join(CODING_DIR2, "gap-dist.json"), null);
+  const projects = await readJson2(path30.join(CODING_DIR2, "projects.json"), null);
+  const workstyle = computeWorkstyle({
+    dayChart,
+    tz,
+    idleGapMin: conc?.idleGapMin ?? 5,
+    criteriaMean,
+    outcomeCadence: outcomeCadence ? { perWeek: outcomeCadence.perWeek, fraction: outcomeCadence.fraction } : null,
+    flow,
+    signals: {
+      maxConcurrency: parallelism.maxConcurrency,
+      subagents: throughput.subagents,
+      queueOps: parallelism.queueOps,
+      mcpTools: new Set(sessions.flatMap((s) => s.mcpTools ?? [])).size,
+      parallelHours: Math.round(parallelism.minutesAt2plus / 60 * 10) / 10
+    }
+  });
+  const pctOf = (sc) => {
+    if (sc == null) return null;
+    const label = bandLabel(sc, DEFAULT_CALIBRATION);
+    const m = /([\d.]+)\s*%/.exec(label);
+    return m ? 100 - parseFloat(m[1]) : null;
+  };
+  const ceilOf = (key) => {
+    const c = criteria.find((x) => x.key === key);
+    const scores = (c?.takes ?? []).map((t) => t.score ?? t.best).filter((x) => x != null).sort((a, b) => b - a);
+    return scores.length ? scores[Math.min(3, scores.length) - 1] : null;
+  };
+  const proud = (key, fallback) => {
+    const t = (criteria.find((x) => x.key === key)?.takes ?? [])[0];
+    if (!t?.instance) return fallback;
+    let h = t.instance.split(/:\s|\s[—–]\s|\swith an?\s/)[0].trim().replace(/\s+/g, " ");
+    h = h.replace(/^The user\b/, "You").replace(/\bThe user\b/g, "you").replace(/([.?!]['"’”)\]]*\s+)you\b/g, (_m, p) => p + "You");
+    if (h.length > 150) h = h.slice(0, 148).replace(/\s+\S*$/, "") + "\u2026";
+    return h;
+  };
+  const nTk = (key) => criteria.find((x) => x.key === key)?.takes.length ?? 0;
+  const peakWords = Object.values(wordsByDay).length ? Math.max(...Object.values(wordsByDay)) : 0;
+  const pHist = parallelism.levelHistogramMin || {};
+  const soloMin = pHist["1"] ?? 0;
+  const parMin = Object.entries(pHist).reduce((a, [k, v]) => Number(k) >= 2 ? a + v : a, 0);
+  const soloPct = soloMin + parMin ? Math.round(soloMin / (soloMin + parMin) * 100) : null;
+  const flowPctDay = aggregate?.flow?.flow?.pctOfWorkDay ?? null;
+  const flowHrsDay = workstyle.flowHoursPerDay ? Math.round(workstyle.flowHoursPerDay * 10) / 10 : null;
+  const focusScore = flowPctDay == null ? null : Math.max(1, Math.min(10, Math.round(2 + flowPctDay / BEST.flow.topPctOfDay * 7)));
+  const out2 = ceilOf("outcomes");
+  const unb = ceilOf("unblocking");
+  const agency = out2 != null && unb != null ? Math.round((out2 + unb) / 2) : out2 ?? unb;
+  const sRow = (label, score, gap2) => ({ label, score, percentile: pctOf(score), gap: gap2 });
+  const tiers = DEFAULT_CALIBRATION.codingTiers;
+  const phi = (z) => {
+    const t = 1 / (1 + 0.2316419 * Math.abs(z));
+    const d = 0.3989423 * Math.exp(-z * z / 2);
+    let pr = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
+    if (z > 0) pr = 1 - pr;
+    return pr;
+  };
+  const lognPct = (x, c) => x == null || !c || x <= 0 ? null : Math.round(phi(Math.log(x / c.median) / c.sigma) * 1e3) / 10;
+  const avgWords = aggregate?.throughput?.avgWordsPerDay ?? null;
+  const pushPctl = lognPct(avgWords, tiers?.push);
+  const focusPctl = lognPct(flowPctDay, tiers?.focus);
+  const hoursAt = (min) => Object.entries(pHist).reduce((a, [k, v]) => Number(k) >= min ? a + v : a, 0) / 60;
+  const orchPctl = hoursAt(5) >= 5 || hoursAt(3) >= 10 && parallelism.queueOps >= 1e3 ? 99.5 : hoursAt(3) >= 10 ? 99 : hoursAt(2) >= 0.1 * (soloMin + parMin) / 60 ? 97 : hoursAt(2) >= 2 ? 90 : 70;
+  const stackUp = [
+    sRow(
+      "How hard you push",
+      aggregate?.throughput?.score ?? tCeiling,
+      `you peak at ~${peakWords.toLocaleString()} words of pure direction in a single day \u2014 the very top sustain ~${BEST.throughput.topAvgWordsPerDay.toLocaleString()} every day, week after week; the wildest single days on record push ~${BEST.throughput.topPeakWordsPerDay.toLocaleString()}`
+    ),
+    sRow(
+      "How well you use AI",
+      ceilOf("delegation"),
+      soloPct != null ? `~${soloPct}% of your hours you drive a single agent (${Math.round(soloMin / 60)}h solo vs ${Math.round(parMin / 60)}h with 2+ live) \u2014 the Claude Code lead keeps 10\u201315 going at once, so this is the single biggest speed-up still on the table` : "you brief the AI sharply, but mostly drive one agent at a time \u2014 the top run 10\u201315 in parallel, a several-fold speed-up"
+    ),
+    sRow(
+      "How well you focus",
+      focusScore,
+      flowHrsDay != null ? `only ~${flowHrsDay}h of your day is true deep flow \u2014 the best hold ~4h in one unbroken block; yours fragments across parallel sessions, so the gain is directing your attention at one thread for longer` : "your attention scatters across parallel sessions \u2014 directing it at one thread for longer is the unlock"
+    ),
+    // The four estimates LEAD with a concrete moment from their own sessions, then an
+    // HONEST caveat — how many graded sessions back the read. No invented weakness, no
+    // claim about what they "didn't" do (false specifics churn a real user); it's an estimate.
+    sRow(
+      "Agency",
+      agency,
+      `${proud("outcomes", "you ship working systems and unblock yourself")} \u2014 one of ${nTk("outcomes")} sessions behind this read; a strong, consistent signal, still an estimate from your logs`
+    ),
+    // Judgement/Taste use the SAME numbers their ability cards prove (aggregate
+    // peak-with-consistency over near-peak instances) — a chip saying "top 1%"
+    // above a card proving 10/Top 0.1% with ten receipts reads as a bug.
+    sRow(
+      "Judgement",
+      aggregate?.ability?.abstraction?.score ?? ceilOf("generative"),
+      `${proud("generative", "you make sharp, non-obvious calls on what actually matters")} \u2014 one of ${nTk("generative")} sessions we've graded for this; clear so far, not yet a final verdict`
+    ),
+    sRow(
+      "Taste",
+      aggregate?.ability?.taste?.score ?? ceilOf("taste"),
+      `${proud("taste", "you hold a high, opinionated quality bar")} \u2014 one of ${nTk("taste")} sessions behind this read; a real signal, still an estimate`
+    )
+    // Expertise: NO chip — the scored criterion is deprecated; the real judge is
+    // the qualitative domains map (expertise-floor), and a chip must never say
+    // "top X%" while that section shows no qualifying domains.
+  ];
+  for (const r of stackUp) {
+    if (r.label === "How hard you push" && pushPctl != null) {
+      r.percentile = pushPctl;
+      r.metric = avgWords;
+      r.curve = "push";
+    }
+    if (r.label === "How well you focus" && focusPctl != null) {
+      r.percentile = focusPctl;
+      r.metric = flowPctDay;
+      r.curve = "focus";
+    }
+    if (r.label === "How well you use AI") r.percentile = orchPctl;
+  }
+  return { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), gradedSessions: grades.length, agglomeration, outcomeCadence, dayDigest, dayChart, timeline, walkthroughs, rubric: rubric2, wordsByDay, dayThroughput, throughputCeiling: tCeiling, stackUp, criteria, parallelism, throughput, workstyle, flow, focus, expertiseMap, frontierArsenal, frontierDetail, coaching, gap, aggregate, delegationRollup, gapDist, projects };
+}
+
+// ../../lib/agents/coding/publicPage.ts
+var readJson3 = async (f, d) => fs27.readFile(f, "utf8").then((t) => JSON.parse(t)).catch(() => d);
+var thirdPerson = (s) => s;
+function weeklyCadence(wordsByDay) {
+  const days = Object.keys(wordsByDay).sort();
+  const weeks = /* @__PURE__ */ new Map();
+  for (const d of days) {
+    const dt = /* @__PURE__ */ new Date(d + "T00:00:00Z");
+    const jan1 = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
+    const wk = `${dt.getUTCFullYear()}-W${String(Math.ceil(((+dt - +jan1) / 864e5 + jan1.getUTCDay() + 1) / 7)).padStart(2, "0")}`;
+    weeks.set(wk, (weeks.get(wk) ?? 0) + 1);
+  }
+  const full = [...weeks.values()].slice(1, -1);
+  const sevenStreak = (() => {
+    let best = 0, cur = 0;
+    for (const n of full) {
+      cur = n >= 7 ? cur + 1 : 0;
+      best = Math.max(best, cur);
+    }
+    return best;
+  })();
+  const recent = full.slice(-6);
+  const recentAvg = recent.length ? Math.round(recent.reduce((a, b) => a + b, 0) / recent.length * 10) / 10 : 0;
+  const first = full.slice(0, 3), firstAvg = first.length ? Math.round(first.reduce((a, b) => a + b, 0) / first.length * 10) / 10 : 0;
+  return { recentAvg, firstAvg, sevenStreak };
+}
+function rhythmFacts(wordsByDay, workstyle, flow) {
+  const days = Object.keys(wordsByDay).sort();
+  const { recentAvg, firstAvg, sevenStreak } = weeklyCadence(wordsByDay);
+  const facts = [];
+  facts.push(recentAvg >= 6.5 ? { big: "7 days a week", rest: sevenStreak >= 2 ? `${sevenStreak} consecutive weeks without a single day off` : "in recent weeks" } : { big: `${recentAvg} days a week`, rest: "averaged over the recent weeks" });
+  if (flow?.workDayHours) facts.push({ big: `${flow.workDayHours}-hour`, rest: "working days, typically" });
+  if (firstAvg && recentAvg > firstAvg + 1.5) facts.push({ big: `${Math.round(firstAvg)} \u2192 ${Math.round(recentAvg)} days/week`, rest: "the ramp from the first weeks to now" });
+  if (workstyle?.activeHours) facts.push({ big: `${Math.round(workstyle.activeHours)} hours`, rest: `hands-on across ${workstyle.daysObserved ?? days.length} observed days${flow?.flowHoursPerDay ? `, ${flow.flowHoursPerDay}h of it in deep flow daily` : ""}` });
+  return facts.slice(0, 4);
+}
+function detailedReportCards(profile) {
+  const cards = [];
+  const t = profile?.throughput;
+  if (t?.sessions) {
+    cards.push({ section: "Throughput", stats: [
+      { big: t.sessions.toLocaleString(), lab: "sessions" },
+      { big: `${Math.round(t.activeHours ?? 0)}h`, lab: "active time" },
+      { big: (t.toolCalls ?? 0).toLocaleString(), lab: `tool calls (${(t.subagents ?? 0).toLocaleString()} subagents)` },
+      { big: String(t.lateNightSessions ?? 0), lab: "late-night days (ends 22:00\u201305:00)" }
+    ] });
+  }
+  const ws = profile?.workstyle, af = profile?.aggregate?.flow;
+  const stats = [];
+  if (af?.workWindow?.typicalStart) stats.push({ big: `${af.workWindow.typicalStart}\u2013${af.workWindow.typicalEnd}`, lab: "work window, typical day" });
+  if (af?.flow?.pctOfWorkDay != null) stats.push({ big: `${Math.round(af.flow.pctOfWorkDay * 100)}%`, lab: `in flow, of the work day (${af.flow.flowHoursPerDay}h/day)` });
+  if (af?.peakWindow) stats.push({ big: String(af.peakWindow), lab: "peak flow" });
+  if (af?.parallelism?.maxConcurrent) stats.push({ big: `\xD7${af.parallelism.maxConcurrent}`, lab: "max parallel" });
+  if (ws?.blockCount) stats.push({ big: `${Math.round((ws.flowHoursTotal ?? 0) * 60 / ws.blockCount)} min`, lab: `mean unbroken stretch (${ws.blockCount} runs, ${ws.deepBlocks} \u2265${ws.flowThresholdMin ?? 30}m)` });
+  if (ws?.longestBlockMin) stats.push({ big: `${ws.longestBlockMin} min`, lab: "longest flow run, unbroken rapid exchange" });
+  const focusDays = profile?.focus?.days ?? [];
+  const rngMin = (rngs) => (rngs ?? []).reduce((a, [x, y]) => a + (y - x), 0);
+  const totalAct = focusDays.reduce((a, d) => a + rngMin(d.ranges?.act ?? []), 0);
+  const totalBrk = focusDays.reduce((a, d) => a + rngMin(d.ranges?.brk ?? []), 0);
+  if (totalAct + totalBrk > 0) stats.push({ big: `${Math.round(100 * totalBrk / (totalAct + totalBrk))}%`, lab: "of the working span spent in breaks" });
+  if (stats.length) cards.push({ section: "Flow & rhythm", stats, note: af?.insight ? String(af.insight) : void 0 });
+  return cards;
+}
+async function buildSkeleton(codingDir, stackUp) {
+  const agg = await readJson3(path31.join(codingDir, "aggregate.json"), {});
+  const coaching = await readJson3(path31.join(codingDir, "coaching.json"), {});
+  const agglom = await readJson3(path31.join(codingDir, "agglomerate.json"), {});
+  const projectsDoc = await readJson3(path31.join(codingDir, "projects.json"), {});
+  const focus = await readJson3(path31.join(codingDir, "focus.json"), {});
+  const sessions = await readJson3(path31.join(codingDir, "sessions.json"), []);
+  const profile = await compileCodingProfile().catch(() => null);
+  const wordsByDay = agg?.throughput?.wordsByDay ?? {};
+  const wbd = Object.keys(wordsByDay).length ? wordsByDay : Object.fromEntries((focus?.days ?? []).map((d) => [d.date, d.activeMin ?? 1]));
+  const pct2 = (label) => {
+    const r = (stackUp ?? []).find((x) => x.label.toLowerCase().includes(label));
+    return r?.percentile != null ? Math.round((100 - r.percentile) * 100) / 100 : null;
+  };
+  const gradedOn = (key) => (agglom?.criteria ?? []).length ? 0 : 0;
+  const interactive = sessions.filter((s) => s.klass === "interactive" && !s.duplicateOf);
+  const flow = agg?.flow?.flow ?? {};
+  const thr = agg?.throughput ?? {};
+  const par = { max: 0, hours2plus: 0, queueOps: 0 };
+  try {
+    const conc = await readJson3(path31.join(codingDir, "concurrency.json"), {});
+    par.max = conc?.maxConcurrency ?? 0;
+    par.hours2plus = Math.round((conc?.minutesAt2plus ?? 0) / 60);
+    par.queueOps = conc?.queueOps ?? 0;
+  } catch {
+  }
+  const wk = weeklyCadence(wbd);
+  const workWindow = agg?.flow?.workWindow;
+  const axes = [
+    { key: "judgement", label: "Judgement", topPct: pct2("judgement"), sub: "AI-graded on an anchored rubric", claim: "", read: "", numbers: [], moments: [] },
+    { key: "agency", label: "Agency", topPct: pct2("agency"), sub: "full ship arcs, verified", claim: "", read: "", numbers: [], moments: [] },
+    { key: "taste", label: "Taste", topPct: pct2("taste"), sub: "AI-graded on an anchored rubric", claim: "", read: "", numbers: [], moments: [] },
+    { key: "push", label: "How hard they push", topPct: pct2("push"), sub: "counted, not graded", claim: "", read: "", numbers: [
+      ...wk.recentAvg ? [{ big: wk.recentAvg >= 6.5 ? "7 days a week" : `${wk.recentAvg} days a week`, lab: "worked, averaged over recent weeks" }] : [],
+      ...workWindow?.typicalStart ? [{ big: `${workWindow.typicalStart}\u2013${workWindow.typicalEnd}`, lab: "work window, typical day" }] : [],
+      ...thr.avgWordsPerDay ? [{ big: String(Math.round(thr.avgWordsPerDay).toLocaleString()), lab: "typed/dictated words per day, averaged (~300 for the median active user)" }] : [],
+      ...thr.substantialDays ? [{ big: `${thr.substantialDays}/${thr.totalCodingDays}`, lab: "coding days were substantial (3h+ span)" }] : []
+    ], moments: [] },
+    { key: "ai", label: "How they use AI", topPct: pct2("use ai"), sub: "orchestration, measured", claim: "", read: "", numbers: [
+      ...par.max ? [{ big: String(par.max), lab: "agents at once, peak" }] : [],
+      ...par.hours2plus ? [{ big: `${par.hours2plus}h`, lab: "working 2+ live agents" }] : [],
+      ...par.queueOps ? [{ big: par.queueOps.toLocaleString(), lab: "instructions queued ahead" }] : []
+    ], moments: [] },
+    { key: "focus", label: "Focus", topPct: pct2("focus"), sub: "strict definition", claim: "", read: "", numbers: [
+      ...flow.pctOfWorkDay != null ? [{ big: `${Math.round(flow.pctOfWorkDay * 100)}%`, lab: "of the work day in strict deep flow (gaps under 6 min)" }] : [],
+      ...flow.flowHoursPerDay ? [{ big: `${flow.flowHoursPerDay}h`, lab: "deep flow per day" }] : [],
+      ...flow.totalFlowHours ? [{ big: `${Math.round(flow.totalFlowHours)}h`, lab: "total flow across the period" }] : []
+    ], moments: [] }
+  ];
+  const projects = (Array.isArray(projectsDoc?.projects) ? projectsDoc.projects : Array.isArray(projectsDoc) ? projectsDoc : []).filter((p) => (p.hours ?? 0) >= 1).slice(0, 6).map((p) => ({ name: String(p.project ?? p.name ?? ""), meta: `${p.days ?? "?"} days \xB7 ${Math.round(p.hours ?? 0)}h` }));
+  const moreNumbers = detailedReportCards(profile);
+  const page = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    verdict: thirdPerson(String(coaching?.whatYouAre?.line ?? "")),
+    provenance: { sessions: interactive.length, days: Object.keys(wbd).length, graded: 0 },
+    rhythm: { facts: rhythmFacts(wbd, profile?.workstyle ?? {}, flow) },
+    missionArc: "",
+    overall: "",
+    axes,
+    projects,
+    moreNumbers,
+    howToWork: [],
+    nutshell: String(agg?.bigPicture ?? "")
+  };
+  const evidence = [
+    `PLACEMENT VERDICT (rewrite to third person, keep the punch): ${coaching?.whatYouAre?.line ?? ""}
+EVIDENCE BEHIND IT: ${coaching?.whatYouAre?.evidence ?? ""}`,
+    `OVERALL READ (compress to 2-4 sentences, keep the behavioral signature): ${String(agglom?.overall ?? "").slice(0, 2200)}`,
+    `PER-CRITERION INSIGHTS:
+${(agglom?.criteria ?? []).map((c) => `[${c.key}] ${c.headline} \u2014 ${String(c.insight ?? "").slice(0, 400)}`).join("\n")}`,
+    `SIGNATURE MOVES (the moment pool \u2014 verify quotes at the source before using):
+${(agglom?.signatureMoves ?? []).map((m) => `- ${m.what} \xB7 ${m.session} \xB7 quote: "${m.quote}"`).join("\n")}`,
+    `FEEL-SEEN LINES (material, not to copy verbatim): ${JSON.stringify(coaching?.feelSeen ?? {})}`
+  ].join("\n\n");
+  return { page, evidence };
+}
+var SYSTEM4 = "You write the COPY for a public, hiring-manager-facing coding profile page. The skeleton (axes, numbers, percentiles) is already computed; you write the words: per-axis claims, reads, and dated concrete moments; the mission arc; the overall read; flow patterns; how-to-work-with bullets. REGISTER: third person throughout (the reader is a hiring manager, not the person). Claims are CLAIMS, not category names ('Kills the wrong metric before it gets built', never 'Strong judgement'). Every moment is dated, concrete, self-contained, and carries the person's VERBATIM words when a quote earns its place \u2014 you MUST verify every quote by finding it in the transcript (docs/<sessionId>.txt) before citing it; can't find it, don't use it. MOMENTS: every axis gets 3-4, and DIVERSE ones: different sessions, different projects, different weeks wherever the evidence allows \u2014 more distinct concrete verified moments is strictly better than fewer, but never pad with a weak restatement of a story already told on that axis. For graded axes pick the sharpest verified moments (the scoreboard ranks candidates). For counted axes (push/focus) turn the person's real peak DAYS into moments: what the day's number was and what they were building (day-digest.json tells you). The AGENCY axis must include one SELF-CONTAINED mission arc moment: what they took on, the insight that redirected it, what shipped \u2014 a stranger should get the whole story from that one entry. MISSION ARC (separate field): the same story at 2-3 sentences, self-contained, concrete. FLOW PATTERNS: from the data (focus.json day ranges, break clusters, day-digest), name what reliably precedes their longest flow runs (inFlow) and what reliably precedes breaks (outFlow) \u2014 one sentence each, evidence-grounded, no speculation. HOW TO WORK WITH THEM: 3-4 bullets derived from the measured behavioral signatures (delegation style, verification habits, standing-rule habit) \u2014 each a practical instruction to a future teammate, not praise. STYLE (hard rules): NO EM DASHES (\u2014) anywhere; use commas, periods, colons. Plain words, no jargon, no consultant-speak, no hedging. Never invent a number, date, quote, or outcome. Numbers you cite must come from the skeleton or the artifacts. Honest edges are stated plainly where the data shows them (the focus axis carries one when flow fragments). BE ECONOMICAL WITH TURNS: verify only the quotes you actually cite, batch several verifications into one Grep call (multiple patterns / one file read covers many quotes), never narrate what you are about to do, and reserve your last turns for emitting the final json block.";
+function copyPrompt(skeleton) {
+  return `THE SKELETON (numbers + axes already computed, copy fields empty):
+\`\`\`json
+${JSON.stringify(skeleton.page, null, 1)}
+\`\`\`
+
+THE DISTILLED EVIDENCE:
+${skeleton.evidence}
+
+Write the copy. Output ONE fenced json block with EXACTLY these fields:
+\`\`\`json
+{
+  "verdict": "third-person rewrite of the placement line",
+  "overall": "2-4 sentences: how they actually work",
+  "missionArc": "2-3 sentences, self-contained story",
+  "inFlow": "what reliably precedes their longest flow runs",
+  "outFlow": "what reliably precedes their breaks",
+  "howToWork": ["3-4 bullets"],
+  "axes": { "judgement": { "claim": "", "read": "", "moments": [ { "date": "YYYY-MM-DD or a range", "what": "", "quote": "verbatim, verified, omit if none earns it", "sessionId": "when known" } ], "edge": "optional honest footnote" }, "agency": {}, "taste": {}, "push": {}, "ai": {}, "focus": {} }
+}
+\`\`\``;
+}
+async function verifyQuotes(codingDir, axes) {
+  const docs = path31.join(codingDir, "docs");
+  let files = null;
+  const norm2 = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  const inDoc = async (file2, q) => norm2(await fs27.readFile(path31.join(docs, file2), "utf8").catch(() => "")).includes(norm2(q).slice(0, 80));
+  let dropped = 0;
+  for (const ax of Object.values(axes ?? {})) {
+    for (const m of ax?.moments ?? []) {
+      if (!m.quote) continue;
+      let ok = false;
+      if (m.sessionId) ok = await inDoc(`${m.sessionId}.txt`, m.quote);
+      if (!ok) {
+        files = files ?? (await fs27.readdir(docs).catch(() => [])).filter((f) => f.endsWith(".txt"));
+        for (const f of files) {
+          if (await inDoc(f, m.quote)) {
+            ok = true;
+            break;
+          }
+        }
+      }
+      if (!ok) {
+        console.log(`[public-page] DROPPED unverifiable quote: "${m.quote.slice(0, 60)}\u2026"`);
+        delete m.quote;
+        dropped++;
+      }
+    }
+  }
+  return { dropped };
+}
+async function generatePublicPage(opts) {
+  const outFile = path31.join(opts.codingDir, "coding-public.json");
+  const skeleton = await buildSkeleton(opts.codingDir, opts.stackUp);
+  if (!skeleton.page.verdict && !skeleton.evidence.includes("[")) {
+    console.log("[public-page] no upstream artifacts yet \u2014 run the analysis first");
+    return null;
+  }
+  const system = SYSTEM4 + sourceLookupNote();
+  const prompt = copyPrompt(skeleton);
+  const sha = promptSha([system, prompt, opts.model ?? "sonnet"]);
+  if (!opts.refresh) {
+    const prev = await reusableOutput(outFile, sha, (o) => !!o.verdict && (o.axes ?? []).length === 6);
+    if (prev) {
+      console.log(`[public-page] inputs unchanged \u2014 reusing page from ${prev.generatedAt} (--refresh to regenerate)`);
+      return prev;
+    }
+  }
+  await ensureCodingDocs(opts.codingDir, opts.sessions);
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    const run3 = await invokeAgent2({
+      prompt: attempt === 1 ? prompt : prompt + "\n\nREMINDER: your previous attempt contained an em dash (\u2014). That is a hard style violation. Rewrite with ZERO em dashes.",
+      systemPrompt: system,
+      // 40 turns: quote verification is turn-hungry (one grep per citation) and
+      // the run DIED at 14 twice on 2026-07-14, always mid-verification. Batch
+      // instruction in SYSTEM keeps it economical; the engine's corpus agents
+      // get 80 for the same reason.
+      addDir: opts.codingDir,
+      allowedTools: ["Read", "Grep", "Glob"],
+      maxTurns: 40,
+      timeoutMs: 6e5,
+      model: opts.model ?? "sonnet"
+    });
+    const j = run3.json;
+    if (!j?.verdict || !j?.axes) {
+      console.log(`[public-page] attempt ${attempt}: no usable copy`);
+      continue;
+    }
+    if (JSON.stringify(j).includes("\u2014")) {
+      console.log(`[public-page] attempt ${attempt}: em dash in output, retrying once`);
+      continue;
+    }
+    await verifyQuotes(opts.codingDir, j.axes);
+    const page = skeleton.page;
+    page.verdict = String(j.verdict).slice(0, 500);
+    page.overall = String(j.overall ?? "").slice(0, 900);
+    page.missionArc = String(j.missionArc ?? "").slice(0, 700);
+    page.rhythm.inFlow = String(j.inFlow ?? "").slice(0, 300) || void 0;
+    page.rhythm.outFlow = String(j.outFlow ?? "").slice(0, 300) || void 0;
+    page.howToWork = (Array.isArray(j.howToWork) ? j.howToWork : []).map((x) => String(x).slice(0, 250)).slice(0, 5);
+    for (const ax of page.axes) {
+      const c = j.axes[ax.key];
+      if (!c) continue;
+      ax.claim = String(c.claim ?? "").slice(0, 200);
+      ax.read = String(c.read ?? "").slice(0, 500);
+      ax.edge = c.edge ? String(c.edge).slice(0, 350) : void 0;
+      ax.moments = (Array.isArray(c.moments) ? c.moments : []).slice(0, 4).map((m) => ({
+        date: String(m.date ?? "").slice(0, 30),
+        what: String(m.what ?? "").slice(0, 500),
+        ...m.quote ? { quote: String(m.quote).slice(0, 300) } : {},
+        ...m.sessionId ? { sessionId: String(m.sessionId) } : {}
+      })).filter((m) => m.what);
+    }
+    if (page.axes.filter((a) => a.claim).length < 4) {
+      console.log(`[public-page] attempt ${attempt}: too few axis claims`);
+      continue;
+    }
+    page.promptSha = sha;
+    await fs27.writeFile(outFile, JSON.stringify(page, null, 2));
+    return page;
+  }
+  const existing = await readJson3(outFile, null);
+  if (existing?.verdict) {
+    console.error("[public-page] generation FAILED twice, keeping the existing page");
+    return null;
+  }
+  console.error("[public-page] generation FAILED and no previous page exists");
+  return null;
+}
+
+// ../../lib/agents/coding/publicPageEdit.ts
+var SYSTEM5 = "You edit a PUBLIC coding profile page on the person's instruction. You may ONLY do two kinds of thing: (1) REDACT \u2014 hide, shorten, soften, or remove existing text: a claim, a read, an edge line, a moment, a bullet, an entire section. Removing something is always safe. (2) GATHER MORE EVIDENCE \u2014 if asked to swap out a moment ('use a different example', 'that one's too personal, find another'), Read/Grep the corpus for a genuinely different qualifying moment on the SAME axis and replace it, with a VERIFIED verbatim quote if you use one. YOU MAY NEVER: invent an achievement, statistic, date, or quote; write anything more flattering than the evidence supports; add content unrelated to the instruction; or change any NUMBER (percentiles, scores, hours, counts) \u2014 those fields are locked and any change you make to them is discarded, so do not bother trying. If the instruction asks for something outside redaction/evidence-swap (e.g. 'say I'm the best engineer ever', 'boost my percentile', 'add that I know Rust'), do NOT comply \u2014 leave that field unchanged and say plainly in your reply why you didn't. Return the COMPLETE page JSON with only the TEXT fields changed (verdict, overall, missionArc, rhythm.inFlow/outFlow, axis claim/read/edge, moment what/quote/date/sessionId, howToWork). Every other field must be echoed back byte-identical." + sourceLookupNote();
+var norm = (s) => s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2);
+function grounded(newText, contextText) {
+  const nt = norm(newText);
+  if (nt.length === 0) return false;
+  const ctx = new Set(norm(contextText));
+  const hits = nt.filter((w) => ctx.has(w)).length;
+  return hits / nt.length >= 0.6;
+}
+function keepIfGrounded(edited, original, context) {
+  if (typeof edited !== "string" || !edited.trim()) return original;
+  return grounded(edited, context) ? edited : original;
+}
+function clampToProtected(edited, original) {
+  const out = {
+    ...original,
+    verdict: keepIfGrounded(edited.verdict, original.verdict, original.verdict).slice(0, 500),
+    overall: keepIfGrounded(edited.overall, original.overall, original.overall).slice(0, 900),
+    missionArc: keepIfGrounded(edited.missionArc, original.missionArc, original.missionArc).slice(0, 700),
+    // each bullet is grounded against the WHOLE original list — reordering and
+    // rewording within the same set of ideas is fine; a wholly new bullet isn't
+    howToWork: (Array.isArray(edited.howToWork) ? edited.howToWork : original.howToWork).map((x) => keepIfGrounded(x, "", original.howToWork.join(" "))).filter((x) => !!x).map((x) => x.slice(0, 250)).slice(0, 5) || original.howToWork,
+    rhythm: {
+      facts: original.rhythm.facts,
+      // counters: NEVER editable
+      inFlow: keepIfGrounded(edited.rhythm?.inFlow, original.rhythm.inFlow ?? "", original.rhythm.inFlow ?? "").slice(0, 300) || void 0,
+      outFlow: keepIfGrounded(edited.rhythm?.outFlow, original.rhythm.outFlow ?? "", original.rhythm.outFlow ?? "").slice(0, 300) || void 0
+    },
+    // PROTECTED, always restored: provenance, projects, moreNumbers (raw stats)
+    provenance: original.provenance,
+    projects: original.projects,
+    moreNumbers: original.moreNumbers,
+    nutshell: original.nutshell
+    // the local report owns this; not editable here
+  };
+  const editedAxes = new Map((edited.axes ?? []).map((a) => [a.key, a]));
+  out.axes = original.axes.map((orig) => {
+    const e = editedAxes.get(orig.key);
+    const axisCtx = `${orig.claim} ${orig.read} ${orig.moments.map((m) => m.what).join(" ")}`;
+    const base2 = {
+      ...orig,
+      // topPct, sub, numbers: PROTECTED, always from orig
+      claim: keepIfGrounded(e?.claim, orig.claim, axisCtx).slice(0, 200),
+      read: keepIfGrounded(e?.read, orig.read, axisCtx).slice(0, 500),
+      edge: e?.edge === void 0 ? orig.edge : e.edge ? keepIfGrounded(e.edge, orig.edge ?? "", `${orig.edge ?? ""} ${axisCtx}`).slice(0, 350) || void 0 : void 0
+    };
+    const origById = new Map(orig.moments.filter((m) => m.sessionId).map((m) => [m.sessionId, m]));
+    base2.moments = (Array.isArray(e?.moments) ? e.moments : orig.moments).slice(0, 3).map((m) => {
+      const matched = m?.sessionId ? origById.get(String(m.sessionId)) : void 0;
+      if (matched) return matched;
+      return {
+        date: String(m?.date ?? "").slice(0, 30),
+        what: String(m?.what ?? "").slice(0, 500),
+        ...m?.quote ? { quote: String(m.quote).slice(0, 300) } : {},
+        ...m?.sessionId ? { sessionId: String(m.sessionId) } : {}
+      };
+    }).filter((m) => m.what && (origById.has(m.sessionId ?? "") || m.quote));
+    return base2;
+  });
+  return out;
+}
+async function editPublicPage(opts) {
+  const last = opts.messages.filter((m) => m.role === "user").pop();
+  if (!last?.content?.trim()) return { status: 400, json: { error: "an instruction is required" } };
+  const convo = opts.messages.slice(-6).map((m) => `${m.role === "user" ? "USER" : "EDITOR"}: ${m.content}`).join("\n");
+  const prompt = `CURRENT PAGE:
+\`\`\`json
+${JSON.stringify(opts.page, null, 1)}
+\`\`\`
+
+CONVERSATION:
+${convo}
+
+Apply the user's LAST instruction within your allowed actions (redact, or gather-more-evidence). Output ONE fenced json block: { "page": <complete page, text fields updated>, "reply": "one short plain sentence on what you did or why you declined" }`;
+  try {
+    const run3 = await invokeAgent2({
+      prompt,
+      systemPrompt: SYSTEM5,
+      addDir: opts.codingDir,
+      allowedTools: ["Read", "Grep", "Glob"],
+      maxTurns: 10,
+      timeoutMs: 24e4,
+      model: opts.model ?? "sonnet"
+    });
+    const j = run3.json;
+    if (!j?.page) return { status: 502, json: { error: "the edit didn't produce a valid page \u2014 try rephrasing" } };
+    const clamped = clampToProtected(j.page, opts.page);
+    const originalIds = new Set(opts.page.axes.flatMap((a) => a.moments.map((m) => m.sessionId).filter(Boolean)));
+    await verifyQuotes(opts.codingDir, clamped.axes);
+    for (const ax of clamped.axes) ax.moments = ax.moments.filter((m) => m.sessionId && originalIds.has(m.sessionId) || m.quote);
+    return { status: 200, json: { page: clamped, reply: String(j.reply ?? "Done.").slice(0, 300) } };
+  } catch (e) {
+    return { status: 502, json: { error: e.message.slice(0, 200) } };
+  }
+}
+
+// src/publicCodingPageApi.ts
+var readJson4 = async (f, d) => fs28.readFile(f, "utf8").then((t) => JSON.parse(t)).catch(() => d);
+async function localChatReport() {
+  const rep = await loadPublicReport().catch(() => null);
+  return rep && hasContent(rep) ? rep : null;
+}
+async function handlePublicCodingPageGet(dataDir) {
+  const page = await readJson4(path32.join(dataDir, "coding", "coding-public.json"), null);
+  const chatReport = await localChatReport();
+  return { status: 200, json: { page, chatReport } };
+}
+async function handlePublicCodingPageGenerate(dataDir, liveProfile) {
+  const codingDir = path32.join(dataDir, "coding");
+  const stackUp = liveProfile?.stackUp ?? null;
+  const sessions = await readJson4(path32.join(codingDir, "sessions.json"), []);
+  try {
+    const page = await generatePublicPage({ codingDir, stackUp, sessions });
+    if (!page) return { status: 502, json: { error: "generation failed \u2014 see the server log, or run the analysis first" } };
+    return { status: 200, json: { page } };
+  } catch (e) {
+    return { status: 502, json: { error: e.message.slice(0, 300) } };
+  }
+}
+async function handlePublicCodingPageEdit(dataDir, body) {
+  const page = body.page;
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  if (!page || !Array.isArray(page.axes)) return { status: 400, json: { error: "page + messages are required" } };
+  const out = await editPublicPage({ page, messages, codingDir: path32.join(dataDir, "coding") });
+  return out;
+}
+async function handlePublicCodingPageShare(dataDir, body) {
+  const cfg = centralConfig();
+  if (!cfg.configured) return { status: 503, json: { error: "central services are disabled in this build" } };
+  const auth = await getAccessToken(dataDir);
+  if (!auth) return { status: 401, json: { error: "sign in with Google (top right) to share with Polymath" } };
+  const page = body.page;
+  if (!page?.verdict || !Array.isArray(page.axes) || page.axes.length < 4) {
+    return { status: 409, json: { error: "nothing to share yet \u2014 generate your page first" } };
+  }
+  const chatReport = body.includeChat === false ? null : await localChatReport();
+  try {
+    const payload = JSON.stringify({ format: "coding-pr1", page, ...chatReport ? { chatReport } : {} });
+    const up = await fetch(`${cfg.supabaseUrl}/rest/v1/rpc/submit_report`, {
+      method: "POST",
+      headers: { apikey: cfg.supabaseAnonKey, authorization: `Bearer ${auth.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ p_session_id: null, p_content: payload })
+    });
+    if (!up.ok) return { status: 502, json: { error: `share failed (HTTP ${up.status})` } };
+    const verification = String(await up.json().catch(() => "unverified"));
+    return { status: 200, json: { ok: true, includedChat: !!chatReport, verification } };
+  } catch (e) {
+    return { status: 502, json: { error: e.message.slice(0, 200) } };
+  }
+}
+
 // src/server.ts
-var __dirname = path25.dirname(fileURLToPath2(import.meta.url));
-var UI_DIR = path25.join(__dirname, "web");
+var __dirname = path33.dirname(fileURLToPath2(import.meta.url));
+var UI_DIR = path33.join(__dirname, "web");
 var DEFAULT_SHARE_URL = "https://polymathsociety.us/api/coding-share";
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -21714,19 +23100,19 @@ async function readBody(req, maxBytes = 8e6) {
 async function serveStatic(res, urlPath) {
   const clean = urlPath.split("?")[0];
   const rel = clean === "/" ? "index.html" : clean.replace(/^\/+/, "");
-  const full = path25.normalize(path25.join(UI_DIR, rel));
+  const full = path33.normalize(path33.join(UI_DIR, rel));
   if (!full.startsWith(UI_DIR)) {
     res.writeHead(403).end("forbidden");
     return;
   }
   try {
-    const data = await fs21.readFile(full);
-    res.writeHead(200, { "content-type": MIME[path25.extname(full)] ?? "application/octet-stream" });
+    const data = await fs29.readFile(full);
+    res.writeHead(200, { "content-type": MIME[path33.extname(full)] ?? "application/octet-stream" });
     res.end(data);
   } catch {
-    if (!path25.extname(full)) {
+    if (!path33.extname(full)) {
       try {
-        const idx = await fs21.readFile(path25.join(UI_DIR, "index.html"));
+        const idx = await fs29.readFile(path33.join(UI_DIR, "index.html"));
         res.writeHead(200, { "content-type": MIME[".html"] }).end(idx);
         return;
       } catch {
@@ -21751,11 +23137,17 @@ async function handleShare(res, body, opts, dataDir) {
     res.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ ok: false, error: "bad JSON" }));
     return;
   }
-  const all = opts.profile?.sections ?? {};
-  const wanted = parsed.all ? Object.keys(all) : Array.isArray(parsed.sections) ? parsed.sections : [];
+  const all = opts.shareSections ?? opts.profile?.sections ?? {};
   const sections = {};
-  for (const key of wanted) {
-    if (key in all && all[key] != null) sections[key] = all[key];
+  if (parsed.sectionsData && typeof parsed.sectionsData === "object" && !Array.isArray(parsed.sectionsData)) {
+    for (const key of Object.keys(parsed.sectionsData)) {
+      if (key in all && parsed.sectionsData[key] != null) sections[key] = parsed.sectionsData[key];
+    }
+  } else {
+    const wanted = parsed.all ? Object.keys(all) : Array.isArray(parsed.sections) ? parsed.sections : [];
+    for (const key of wanted) {
+      if (key in all && all[key] != null) sections[key] = all[key];
+    }
   }
   if (Object.keys(sections).length === 0) {
     res.writeHead(400, { "content-type": "application/json" }).end(JSON.stringify({ ok: false, error: "no shareable sections selected" }));
@@ -21791,8 +23183,11 @@ async function handleShare(res, body, opts, dataDir) {
   }
 }
 function startServer(opts) {
+  let liveProfile = opts.profile;
+  let liveProgress = {};
+  let profileRev = 0;
   const host = opts.host ?? "127.0.0.1";
-  const dataDir = opts.dataDir ?? path25.join(process.cwd(), ".data");
+  const dataDir = opts.dataDir ?? resolveDataRoot();
   let serverUrl = "";
   const json = (res, status, body) => res.writeHead(status, { "content-type": MIME[".json"] }).end(JSON.stringify(body));
   const server = http.createServer(async (req, res) => {
@@ -21800,7 +23195,17 @@ function startServer(opts) {
       const url = req.url ?? "/";
       const route = url.split("?")[0];
       if (req.method === "GET" && (url === "/api/coding" || url === "/profile.json" || url.startsWith("/profile.json?"))) {
-        res.writeHead(200, { "content-type": MIME[".json"] }).end(JSON.stringify(opts.profile));
+        res.writeHead(200, { "content-type": MIME[".json"] }).end(JSON.stringify(liveProfile));
+        return;
+      }
+      if (req.method === "GET" && url === "/api/progress") {
+        res.writeHead(200, { "content-type": MIME[".json"] }).end(JSON.stringify({ ...liveProgress, profileRev }));
+        return;
+      }
+      if (req.method === "GET" && route === "/api/exports-manifest") {
+        const m = await readManifest(dataDir).catch(() => null);
+        const kinds = new Set((m?.exports?.included ?? []).map((e) => e.kind));
+        json(res, 200, { connectedKinds: [...kinds], links: EXPORT_LINKS });
         return;
       }
       if (req.method === "GET" && route === "/meta.json") {
@@ -21818,6 +23223,10 @@ function startServer(opts) {
             submit: central.configured,
             auth: central.configured,
             share: true,
+            shareEdit: true,
+            // the review modal's chat editor (/api/share/edit)
+            publicCodingPage: true,
+            // the hiring-manager page (/api/public-coding-page*)
             person: true,
             // the chat-analysis tab's /api/person* routes
             publicReport: true
@@ -21934,13 +23343,14 @@ function startServer(opts) {
       }
       if (route === "/api/profile/visibility" && (req.method === "GET" || req.method === "POST")) {
         const body = req.method === "POST" ? JSON.parse(await readBody(req) || "{}") : void 0;
-        const out = await handleVisibility(dataDir, req.method, body);
+        const pool = opts.shareSections ?? opts.profile?.sections ?? {};
+        const out = await handleVisibility(dataDir, req.method, body, pool);
         json(res, out.status, out.json);
         return;
       }
       if (route === "/api/coding/chat" && req.method === "POST") {
         const body = JSON.parse(await readBody(req) || "{}");
-        await handleCodingChat(opts.profile, dataDir, body, res);
+        await handleCodingChat(liveProfile, dataDir, body, res);
         return;
       }
       if (req.method === "POST" && url === "/share") {
@@ -21948,6 +23358,35 @@ function startServer(opts) {
         await handleShare(res, body, opts, dataDir);
         return;
       }
+      if (req.method === "POST" && route === "/api/share/edit") {
+        const body = JSON.parse(await readBody(req) || "{}");
+        const pool = opts.shareSections ?? opts.profile?.sections ?? {};
+        const out = await handleShareEdit(pool, body);
+        json(res, out.status, out.json);
+        return;
+      }
+      if (req.method === "GET" && route === "/api/public-coding-page") {
+        const out = await handlePublicCodingPageGet(dataDir);
+        json(res, out.status, out.json);
+        return;
+      }
+      if (req.method === "POST" && route === "/api/public-coding-page/generate") {
+        const out = await handlePublicCodingPageGenerate(dataDir, liveProfile);
+        json(res, out.status, out.json);
+        return;
+      }
+      if (req.method === "POST" && route === "/api/public-coding-page/edit") {
+        const body = JSON.parse(await readBody(req) || "{}");
+        const out = await handlePublicCodingPageEdit(dataDir, body);
+        json(res, out.status, out.json);
+        return;
+      }
+      if (req.method === "POST" && route === "/api/public-coding-page/share") {
+        const body = JSON.parse(await readBody(req) || "{}");
+        const out = await handlePublicCodingPageShare(dataDir, body);
+        json(res, out.status, out.json);
+        return;
+      }
       if (route.startsWith("/api/")) {
         json(res, 404, { error: `this viewer doesn't serve ${route}` });
         return;
@@ -21976,7 +23415,17 @@ function startServer(opts) {
       resolve2({
         url: serverUrl,
         port,
-        close: () => new Promise((r) => server.close(() => r()))
+        close: () => new Promise((r) => server.close(() => r())),
+        setProfile: (p) => {
+          liveProfile = p;
+          profileRev++;
+        },
+        setShareSections: (s) => {
+          opts.shareSections = s;
+        },
+        setProgress: (p) => {
+          liveProgress = p;
+        }
       });
     });
   });