polymath-society 0.2.20 → 0.2.21

package/dist/pipeline/coding-aggregate.js

@@ -1,8 +1,8 @@
 import{createRequire as __cr}from'module';const require=__cr(import.meta.url);
 
 // ../../scripts/coding-aggregate.mts
-import { promises as fs2 } from "fs";
-import path2 from "path";
+import { promises as fs3 } from "fs";
+import path3 from "path";
 
 // ../../lib/agents/shared/cliAdapter.ts
 var CLAUDE_BIN = process.env.CLAUDE_BIN || "claude";
@@ -50,7 +50,7 @@ var LIBERAL = [
 var ALS = new AsyncLocalStorage();
 
 // ../coding-core/dist/messages.js
-import { promises as fs } from "fs";
+import { promises as fs2 } from "fs";
 
 // ../coding-core/dist/injected.js
 var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -176,6 +176,274 @@ function extractCodexEvents(raw) {
   return out;
 }
 
+// ../coding-core/dist/cursor.js
+import { promises as fs } from "fs";
+var NODE_SQLITE = "node:sqlite";
+async function openCursorSqlite(dbPath) {
+  try {
+    await fs.access(dbPath);
+  } catch {
+    return null;
+  }
+  let mod;
+  try {
+    mod = await import(NODE_SQLITE);
+  } catch {
+    return null;
+  }
+  const DatabaseSync = mod?.DatabaseSync;
+  if (!DatabaseSync)
+    return null;
+  let db;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+  } catch {
+    try {
+      db = new DatabaseSync(dbPath);
+    } catch {
+      return null;
+    }
+  }
+  const asText = (v) => v == null ? null : typeof v === "string" ? v : Buffer.from(v).toString("utf-8");
+  return {
+    prefix(prefix) {
+      try {
+        const rows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE ? ESCAPE '\\'").all(likePrefix(prefix));
+        return rows.map((r) => ({ key: r.key, value: asText(r.value) ?? "" }));
+      } catch {
+        return [];
+      }
+    },
+    get(key) {
+      try {
+        const row = db.prepare("SELECT value FROM cursorDiskKV WHERE key = ?").get(key);
+        return row ? asText(row.value) : null;
+      } catch {
+        return null;
+      }
+    },
+    close() {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  };
+}
+function likePrefix(prefix) {
+  return prefix.replace(/[\\%_]/g, (c) => "\\" + c) + "%";
+}
+var CURSOR_USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+function cleanUserText(raw) {
+  let t = raw.replace(SYSTEM_REMINDER_RE, "");
+  const m = t.match(CURSOR_USER_QUERY_RE);
+  if (m)
+    t = m[1];
+  return t.trim();
+}
+var msFrom = (v) => {
+  if (typeof v === "number" && Number.isFinite(v))
+    return v;
+  if (typeof v === "string") {
+    const n = Date.parse(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+};
+function readCursorComposer(db, composerId) {
+  const cdRaw = db.get(`composerData:${composerId}`);
+  if (!cdRaw)
+    return null;
+  let cd;
+  try {
+    cd = JSON.parse(cdRaw);
+  } catch {
+    return null;
+  }
+  const headers = Array.isArray(cd.fullConversationHeadersOnly) ? cd.fullConversationHeadersOnly : [];
+  if (headers.length === 0)
+    return null;
+  const bubbles = /* @__PURE__ */ new Map();
+  for (const row of db.prefix(`bubbleId:${composerId}:`)) {
+    const bid = row.key.slice(`bubbleId:${composerId}:`.length);
+    try {
+      bubbles.set(bid, JSON.parse(row.value));
+    } catch {
+    }
+  }
+  const turns = [];
+  let clock = msFrom(cd.createdAt) ?? 0;
+  for (const h of headers) {
+    const b = bubbles.get(h.bubbleId);
+    if (!b)
+      continue;
+    const type = h.type === 1 ? 1 : 2;
+    const tool = type === 2 && b.toolFormerData && typeof b.toolFormerData.name === "string" ? b.toolFormerData.name : null;
+    const rawText = typeof b.text === "string" ? b.text : "";
+    const text = type === 1 ? cleanUserText(rawText) : rawText.replace(SYSTEM_REMINDER_RE, "").trim();
+    if (!text && !tool)
+      continue;
+    const t = msFrom(b.createdAt);
+    clock = Math.max(clock, t ?? clock + 1);
+    const model = b.modelInfo && typeof b.modelInfo.modelName === "string" ? b.modelInfo.modelName : null;
+    turns.push({ t: clock, type, text, tool, model });
+  }
+  if (turns.length === 0)
+    return null;
+  const gitRepo = Array.isArray(cd.trackedGitRepos) && cd.trackedGitRepos[0] && typeof cd.trackedGitRepos[0].repoPath === "string" ? cd.trackedGitRepos[0].repoPath : null;
+  return {
+    composerId,
+    createdAt: msFrom(cd.createdAt),
+    updatedAt: msFrom(cd.lastUpdatedAt),
+    name: typeof cd.name === "string" && cd.name.trim() ? cd.name.trim() : null,
+    gitRepo,
+    turns
+  };
+}
+function sniffCursorRaw(raw) {
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    try {
+      const e = JSON.parse(line);
+      return (e.role === "user" || e.role === "assistant") && typeof e.message === "object" && e.message !== null && "content" in e.message && !("type" in e);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function jsonlText(content) {
+  const parts = [];
+  const tools = [];
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (!item || typeof item !== "object")
+        continue;
+      const it = item;
+      if (it.type === "text" && it.text)
+        parts.push(it.text);
+      else if (it.type === "tool_use" && it.name)
+        tools.push(it.name);
+    }
+  } else if (typeof content === "string")
+    parts.push(content);
+  return { text: parts.join("\n"), tools };
+}
+function parseCursorJsonl(raw, base) {
+  const turns = [];
+  let clock = base;
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.role !== "user" && e.role !== "assistant")
+      continue;
+    const { text: rawText, tools } = jsonlText(e.message?.content);
+    const type = e.role === "user" ? 1 : 2;
+    const text = type === 1 ? cleanUserText(rawText) : rawText.replace(SYSTEM_REMINDER_RE, "").trim();
+    if (type === 2 && tools.length) {
+      for (const tool of tools) {
+        clock += 1;
+        turns.push({ t: clock, type: 2, text: "", tool, model: null });
+      }
+    }
+    if (!text)
+      continue;
+    clock += 1;
+    turns.push({ t: clock, type, text, tool: null, model: null });
+  }
+  if (turns.length === 0)
+    return null;
+  return { composerId: "", createdAt: base, updatedAt: clock, name: null, gitRepo: null, turns };
+}
+function cursorMessages(c) {
+  const out = [];
+  let aiStart = 0;
+  let aiParts = [];
+  const flushAI = () => {
+    if (!aiParts.length)
+      return;
+    out.push({ t: aiStart, role: "ai", text: aiParts.join("\n") });
+    aiParts = [];
+  };
+  for (const turn of c.turns) {
+    if (turn.type === 1) {
+      flushAI();
+      out.push({ t: turn.t, role: "user", text: turn.text });
+    } else {
+      if (aiParts.length === 0)
+        aiStart = turn.t;
+      if (turn.text)
+        aiParts.push(turn.text);
+    }
+  }
+  flushAI();
+  return out;
+}
+function composerIdFromFile(file) {
+  const m = file.match(/agent-transcripts\/([^/]+)\/[^/]+\.jsonl$/);
+  return m ? m[1] : null;
+}
+async function loadCursorComposer(file, raw, dbPath) {
+  const cid = composerIdFromFile(file);
+  if (cid && dbPath) {
+    const db = await openCursorSqlite(dbPath);
+    if (db) {
+      try {
+        const c = readCursorComposer(db, cid);
+        if (c)
+          return c;
+      } finally {
+        db.close();
+      }
+    }
+  }
+  return parseCursorJsonl(raw, 0);
+}
+
+// ../coding-core/dist/raw.js
+import path from "path";
+import os2 from "os";
+var SOURCE_ROOT_ENV_VARS = [
+  "CLAUDE_PROJECTS_DIR",
+  "CODEX_SESSIONS_DIR",
+  "CURSOR_WORKSPACE_DIR",
+  "CURSOR_PROJECTS_DIR",
+  // Cursor's globalStorage dir (holds state.vscdb — the composer bubbles that
+  // carry a Cursor session's real per-turn timestamps + content). Same
+  // isolation contract: overriding any root disables every unset source.
+  "CURSOR_GLOBAL_DIR"
+];
+var anyRootOverridden = () => SOURCE_ROOT_ENV_VARS.some((v) => !!process.env[v]);
+function resolveSourceRoot(envVar, ...defaultSegments) {
+  const explicit = process.env[envVar];
+  if (explicit)
+    return explicit;
+  if (anyRootOverridden())
+    return null;
+  return path.join(os2.homedir(), ...defaultSegments);
+}
+var cursorGlobalRoot = () => resolveSourceRoot("CURSOR_GLOBAL_DIR", "Library", "Application Support", "Cursor", "User", "globalStorage");
+function cursorGlobalDbPath() {
+  const root = cursorGlobalRoot();
+  return root === null ? null : path.join(root, "state.vscdb");
+}
+var MACHINE_CURSOR_FILE_RE = /^(.*[/\\]machines[/\\][^/\\]+[/\\]\.cursor)[/\\]projects[/\\]/;
+function cursorDbPathForFile(file) {
+  const m = file.match(MACHINE_CURSOR_FILE_RE);
+  if (m)
+    return path.join(m[1], "globalStorage", "state.vscdb");
+  return cursorGlobalDbPath();
+}
+
 // ../coding-core/dist/messages.js
 function extractText(content) {
   if (typeof content === "string")
@@ -243,12 +511,16 @@ function extractMessagesCodex(raw) {
 async function extractMessages(file) {
   let raw;
   try {
-    raw = await fs.readFile(file, "utf-8");
+    raw = await fs2.readFile(file, "utf-8");
   } catch {
     return [];
   }
   if (sniffCodexRaw(raw))
     return extractMessagesCodex(raw);
+  if (sniffCursorRaw(raw)) {
+    const c = await loadCursorComposer(file, raw, cursorDbPathForFile(file));
+    return c ? cursorMessages(c) : [];
+  }
   const out = [];
   const userTexts = /* @__PURE__ */ new Set();
   const seenUuids = /* @__PURE__ */ new Set();
@@ -415,9 +687,13 @@ function throughputCeiling(dayWords, proof = 3) {
     return 0;
   return scores[Math.min(proof, scores.length) - 1];
 }
+function throughputMeanDays(activeDays, spanHByDate, spanHourMin) {
+  const substantial = activeDays.filter((d) => (spanHByDate[d] || 0) >= spanHourMin);
+  return substantial.length ? substantial : activeDays;
+}
 
 // ../../lib/agents/coding/profile.ts
-import path from "path";
+import path2 from "path";
 
 // ../../lib/calibration/fingerprint.ts
 import { createHash } from "node:crypto";
@@ -567,7 +843,7 @@ var IDLE_CAP_MS = 12 * 6e4;
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-16.2",
+  version: "2026-07-21.1",
   // = RUBRIC_FINGERPRINT of the shipped npm rubric (packages/coding-analyzer/
   // src/grade/criteria.ts). A unit test fails loud when the rubric changes
   // without this being updated (and re-pushed to the server).
@@ -663,13 +939,14 @@ var DEFAULT_CALIBRATION = {
   },
   codingBenchmarks: {
     flow: {
-      // typical knowledge worker ≈ 35% of an 8h day focused; ~4h/day is the
-      // recognized deep-work ceiling (Newport) ≈ 50% — most sit far below it.
+      // typical knowledge worker ≈ 35% of an 8h day focused; the ~4h/day
+      // deep-work ceiling (Newport) sits nearer ~40% of a real (9-10h) top
+      // performer's day — 50% overstated it (owner call 2026-07-21).
       typicalPctOfDay: 0.35,
-      topPctOfDay: 0.5,
+      topPctOfDay: 0.4,
       tag: "measured",
-      source: "RescueTime 2019 (~2h48m focused/day) \xB7 Cal Newport, Deep Work (~4h/day deep-work ceiling)",
-      line: "the best spend ~half the workday in true deep flow; ~4h/day is the human ceiling"
+      source: "RescueTime 2019 (~2h48m focused/day) \xB7 Cal Newport, Deep Work (~4h/day deep-work ceiling against a 9-10h day)",
+      line: "the best spend ~40% of the workday in true deep flow; ~4h/day is the human ceiling"
     },
     longestRun: {
       typicalHours: 0.67,
@@ -718,15 +995,15 @@ var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
 
 // ../../lib/agents/coding/profile.ts
 var ROOT = process.cwd();
-var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path.join(process.env.POLYMATH_DATA_DIR, "coding") : path.join(ROOT, ".data", "coding");
-var GRADES = path.join(CODING_DIR, "grades");
+var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path2.join(process.env.POLYMATH_DATA_DIR, "coding") : path2.join(ROOT, ".data", "coding");
+var GRADES = path2.join(CODING_DIR, "grades");
 
 // ../../scripts/coding-aggregate.mts
 var CODING = CODING_DIR;
 var TZ = "America/Los_Angeles";
 var readJson = async (f, d) => {
   try {
-    return JSON.parse(await fs2.readFile(path2.join(CODING, f), "utf8"));
+    return JSON.parse(await fs3.readFile(path3.join(CODING, f), "utf8"));
   } catch {
     return d;
   }
@@ -738,7 +1015,7 @@ async function throughputAvg(spanHourMin) {
     const slots = Object.keys(d.slots || {}).map(Number);
     spanH[d.date] = slots.length ? (Math.max(...slots) - Math.min(...slots) + 1) / 6 : 0;
   }
-  const sess = JSON.parse(await fs2.readFile(path2.join(CODING, "sessions.json"), "utf8")).filter((s) => !s.duplicateOf && s.klass === "interactive");
+  const sess = JSON.parse(await fs3.readFile(path3.join(CODING, "sessions.json"), "utf8")).filter((s) => !s.duplicateOf && s.klass === "interactive");
   const wordsByDay = {};
   const firstSeen = createMessageDeduper();
   for (const s of sess) {
@@ -756,7 +1033,7 @@ async function throughputAvg(spanHourMin) {
   const dates = Object.keys(wordsByDay).filter((d) => wordsByDay[d] > 0);
   const mean = (a) => a.length ? Math.round(a.reduce((x, y) => x + y, 0) / a.length) : 0;
   const substantial = dates.filter((d) => (spanH[d] || 0) >= spanHourMin);
-  const avgWords = mean(substantial.map((d) => wordsByDay[d]));
+  const avgWords = mean(throughputMeanDays(dates, spanH, spanHourMin).map((d) => wordsByDay[d]));
   const sens = {};
   for (const h of [2, 3, 4, 5, 6]) {
     const ds = dates.filter((d) => (spanH[d] || 0) >= h);
@@ -768,14 +1045,14 @@ async function throughputAvg(spanHourMin) {
   return { spanHourMin, substantialDays: substantial.length, totalCodingDays: dates.length, avgWordsPerDay: avgWords, score, label, ceiling: throughputCeiling(dates.map((d) => wordsByDay[d])), daySensitivity: sens };
 }
 async function abilityCeiling() {
-  const dir = path2.join(CODING, "grades");
-  const files = (await fs2.readdir(dir).catch(() => [])).filter((f) => f.endsWith(".json"));
+  const dir = path3.join(CODING, "grades");
+  const files = (await fs3.readdir(dir).catch(() => [])).filter((f) => f.endsWith(".json"));
   const collect = (key) => [];
   const byKey = { generative: [], taste: [] };
   for (const f of files) {
     let j;
     try {
-      j = JSON.parse(await fs2.readFile(path2.join(dir, f), "utf8"));
+      j = JSON.parse(await fs3.readFile(path3.join(dir, f), "utf8"));
     } catch {
       continue;
     }
@@ -831,10 +1108,11 @@ async function flowStats() {
     }
   }
   const peakWindow = bestSum > 0 ? `${hm(bestStart * 6)}\u2013${hm((bestStart + 3) * 6)}` : null;
-  const perDay = conc.perDay || {};
+  const perDayRaw = conc.perDay || {};
+  const perDay = Array.isArray(perDayRaw) ? Object.fromEntries(perDayRaw.filter((r) => r?.date).map((r) => [r.date, r])) : perDayRaw;
   const concOf = (date) => {
     const v = perDay[date];
-    return typeof v === "number" ? v : v?.peak ?? v?.max ?? v?.maxConcurrency ?? 1;
+    return typeof v === "number" ? v : v?.peakConcurrency ?? v?.peak ?? v?.max ?? v?.maxConcurrency ?? 1;
   };
   const tiers = { "solo (\xD71)": { fracs: [] }, "light (\xD72\u20133)": { fracs: [] }, "heavy (\xD74+)": { fracs: [] } };
   for (const d of days) {
@@ -850,9 +1128,15 @@ async function flowStats() {
   const pctOfWorkDay = workDayHours > 0 ? Math.round(flowHoursPerDay / workDayHours * 100) / 100 : null;
   const bestTier = [...byParallelism].sort((a, b) => b.avgFlowFraction - a.avgFlowFraction)[0];
   const insight = peakWindow ? `Flow peaks ${peakWindow}; deepest on ${bestTier ? bestTier.tier : "\u2014"} days (${bestTier ? Math.round(bestTier.avgFlowFraction * 100) : 0}% in flow).` : "Not enough flow data yet.";
+  const avgConcurrent = (hist) => {
+    const total = Object.values(hist || {}).reduce((a, v) => a + Number(v || 0), 0);
+    if (total <= 0) return 0;
+    const weighted = Object.entries(hist || {}).reduce((a, [k, v]) => a + Number(k) * Number(v || 0), 0);
+    return Math.round(weighted / total * 10) / 10;
+  };
   return {
     workWindow: { typicalStart: starts.length ? hm(med(starts)) : null, typicalEnd: ends.length ? hm(med(ends)) : null, activeDays: days.length },
-    parallelism: { maxConcurrent: conc.maxConcurrency || 0 },
+    parallelism: { maxConcurrent: conc.maxConcurrency || 0, avgConcurrent: avgConcurrent(conc.levelHistogramMin || {}) },
     flow: { fractionOfActiveTime: flow.totals?.flowFraction ?? null, pctOfWorkDay, workDayHours, flowHoursPerDay, totalFlowHours },
     peakWindow,
     flowByHour,
@@ -866,7 +1150,7 @@ async function main() {
   const throughput = await throughputAvg(4);
   const prev = await readJson("aggregate.json", {});
   const out = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ability, flow, throughput, ...prev.bigPicture ? { bigPicture: prev.bigPicture, ...prev.bigPictureSha ? { bigPictureSha: prev.bigPictureSha } : {} } : {} };
-  await fs2.writeFile(path2.join(CODING, "aggregate.json"), JSON.stringify(out, null, 2));
+  await fs3.writeFile(path3.join(CODING, "aggregate.json"), JSON.stringify(out, null, 2));
   console.log("aggregate.json written" + (prev.bigPicture ? " (bigPicture preserved)" : " (no bigPicture present \u2014 run coding-nutshell.mts)"));
   console.log(`  Throughput AVG (start\u2192finish span \u2265${throughput.spanHourMin}h): ${throughput.score}/11 (${throughput.label}) \xB7 ${throughput.avgWordsPerDay} words/day over ${throughput.substantialDays}/${throughput.totalCodingDays} days \xB7 [peak ceiling was ${throughput.ceiling}]`);
   console.log(`  day sensitivity:`, throughput.daySensitivity);