polymath-society 0.2.20 → 0.2.22

package/dist/pipeline/coding-build.js

@@ -1,11 +1,11 @@
 import{createRequire as __cr}from'module';const require=__cr(import.meta.url);
 
 // ../../scripts/coding-build.mts
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 import path3 from "path";
 
 // ../coding-core/dist/raw.js
-import { promises as fs } from "fs";
+import { promises as fs2 } from "fs";
 import path from "path";
 import os from "os";
 
@@ -133,12 +133,225 @@ 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 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
 var SOURCE_ROOT_ENV_VARS = [
   "CLAUDE_PROJECTS_DIR",
   "CODEX_SESSIONS_DIR",
   "CURSOR_WORKSPACE_DIR",
-  "CURSOR_PROJECTS_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) {
@@ -153,6 +366,18 @@ var claudeProjectsRoot = () => resolveSourceRoot("CLAUDE_PROJECTS_DIR", ".claude
 var codexSessionsRoot = () => resolveSourceRoot("CODEX_SESSIONS_DIR", ".codex", "sessions");
 var cursorWorkspaceRoot = () => resolveSourceRoot("CURSOR_WORKSPACE_DIR", "Library", "Application Support", "Cursor", "User", "workspaceStorage");
 var cursorProjectsRoot = () => resolveSourceRoot("CURSOR_PROJECTS_DIR", ".cursor", "projects");
+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();
+}
 var SKIP_DIR_RE = /(private-var-folders|-T-ps-|--data(-|$)|-sources(-|$)|--conversations|-node-modules-|-tmp(-|$)|-polymath-rehearsal-|-polymath-overnight-)/;
 var AGENT_CWD_RE = /(\/\.data(\/|$)|\.polymath-society|\/sources(\/|$)|\/var\/folders\/|\/T\/ps-|\/timeline(\/|$)|onboarding-digest|engine-pilot|polymath-rehearsal|polymath-overnight)/;
 var PERSONA_RE = /^You are (a|an|the|\w+ing)\b/;
@@ -454,14 +679,13 @@ function parseCodex(raw, file) {
   s.klassReason = c.reason;
   return s;
 }
-async function readClaudeCode() {
-  const base = claudeProjectsRoot();
+async function readClaudeCodeAt(base, machine) {
   const out = [];
   if (!base)
     return out;
   let dirs = [];
   try {
-    dirs = await fs.readdir(base);
+    dirs = await fs2.readdir(base);
   } catch {
     return out;
   }
@@ -471,7 +695,7 @@ async function readClaudeCode() {
     const full = path.join(base, dir);
     let files = [];
     try {
-      files = (await fs.readdir(full)).filter((f) => f.endsWith(".jsonl"));
+      files = (await fs2.readdir(full)).filter((f) => f.endsWith(".jsonl"));
     } catch {
       continue;
     }
@@ -479,21 +703,27 @@ async function readClaudeCode() {
       const file = path.join(full, f);
       let raw;
       try {
-        raw = await fs.readFile(file, "utf-8");
+        raw = await fs2.readFile(file, "utf-8");
       } catch {
         continue;
       }
       const s = parseClaudeCode(raw, path.basename(f, ".jsonl"), file);
-      if (s)
+      if (s) {
+        if (machine)
+          s.machine = machine;
         out.push(s);
+      }
     }
   }
   return out;
 }
+async function readClaudeCode() {
+  return readClaudeCodeAt(claudeProjectsRoot(), null);
+}
 async function walkJsonl(dir, acc) {
   let entries = [];
   try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
+    entries = await fs2.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -505,8 +735,7 @@ async function walkJsonl(dir, acc) {
       acc.push(full);
   }
 }
-async function readCodex() {
-  const base = codexSessionsRoot();
+async function readCodexAt(base, machine) {
   if (!base)
     return [];
   const files = [];
@@ -515,17 +744,58 @@ async function readCodex() {
   for (const file of files) {
     let raw;
     try {
-      raw = await fs.readFile(file, "utf-8");
+      raw = await fs2.readFile(file, "utf-8");
     } catch {
       continue;
     }
     const s = parseCodex(raw, file);
-    if (s)
+    if (s) {
+      if (machine)
+        s.machine = machine;
       out.push(s);
+    }
   }
   return out;
 }
-var CURSOR_USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+async function readCodex() {
+  return readCodexAt(codexSessionsRoot(), null);
+}
+function machinesRoot() {
+  const d = process.env.POLYMATH_DATA_DIR;
+  if (!d || !d.trim())
+    return null;
+  return path.join(d, "machines");
+}
+async function readMachines(opts) {
+  const root = machinesRoot();
+  if (!root)
+    return [];
+  let labels = [];
+  try {
+    labels = await fs2.readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const ent of labels) {
+    if (!ent.isDirectory() || ent.name.startsWith("."))
+      continue;
+    const label = ent.name;
+    const b = path.join(root, label);
+    out.push(...await readClaudeCodeAt(path.join(b, ".claude", "projects"), label));
+    if (opts.codex !== false)
+      out.push(...await readCodexAt(path.join(b, ".codex", "sessions"), label));
+    if (opts.cursor !== false) {
+      out.push(...await readCursorAt({
+        workspace: path.join(b, ".cursor", "workspaceStorage"),
+        projects: path.join(b, ".cursor", "projects"),
+        globalDb: path.join(b, ".cursor", "globalStorage", "state.vscdb")
+      }, label));
+    }
+  }
+  return out;
+}
+var CURSOR_USER_QUERY_RE2 = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
 function fileUriToPath(uri) {
   if (typeof uri !== "string" || !uri)
     return null;
@@ -539,11 +809,11 @@ function fileUriToPath(uri) {
 function cursorSlug(folderPath) {
   return folderPath.replace(/^\//, "").replace(/[^A-Za-z0-9]+/g, "-").replace(/-+$/, "");
 }
-var NODE_SQLITE = "node:sqlite";
+var NODE_SQLITE2 = "node:sqlite";
 async function openCursorDb(dbPath) {
   let mod;
   try {
-    mod = await import(NODE_SQLITE);
+    mod = await import(NODE_SQLITE2);
   } catch {
     return null;
   }
@@ -581,14 +851,13 @@ async function openCursorDb(dbPath) {
     }
   };
 }
-async function readCursorWorkspaces() {
-  const base = cursorWorkspaceRoot();
+async function readCursorWorkspaces(base) {
   const out = /* @__PURE__ */ new Map();
   if (!base)
     return out;
   let dirs = [];
   try {
-    dirs = await fs.readdir(base, { withFileTypes: true });
+    dirs = await fs2.readdir(base, { withFileTypes: true });
   } catch {
     return out;
   }
@@ -598,14 +867,14 @@ async function readCursorWorkspaces() {
     const wsDir = path.join(base, d.name);
     let folder = null;
     try {
-      folder = fileUriToPath(JSON.parse(await fs.readFile(path.join(wsDir, "workspace.json"), "utf-8")).folder);
+      folder = fileUriToPath(JSON.parse(await fs2.readFile(path.join(wsDir, "workspace.json"), "utf-8")).folder);
     } catch {
     }
     if (!folder)
       continue;
     const dbFile = path.join(wsDir, "state.vscdb");
     try {
-      await fs.access(dbFile);
+      await fs2.access(dbFile);
     } catch {
       continue;
     }
@@ -659,10 +928,40 @@ async function readCursorWorkspaces() {
   }
   return out;
 }
+function rawSessionFromCursorComposer(c, file, cwd) {
+  const s = blank(c.composerId, "cursor", file);
+  s.cwd = cwd;
+  if (c.name)
+    pushDedup(s.titles, c.name);
+  for (const turn of c.turns) {
+    if (turn.type === 1) {
+      s.humanTurns++;
+      s.humanChars += turn.text.length;
+      if (!s.firstHuman)
+        s.firstHuman = turn.text.slice(0, 4e3);
+      s.events.push({ t: turn.t, k: "human" });
+    } else {
+      s.aiTurns++;
+      if (turn.model)
+        s.models[turn.model] = (s.models[turn.model] ?? 0) + 1;
+      if (turn.tool) {
+        s.toolCounts[turn.tool] = (s.toolCounts[turn.tool] ?? 0) + 1;
+        s.events.push({ t: turn.t, k: "tool" });
+      } else {
+        s.events.push({ t: turn.t, k: "ai" });
+      }
+    }
+  }
+  s.events.sort((a, b) => a.t - b.t);
+  const cl = classify(s);
+  s.klass = cl.klass;
+  s.klassReason = cl.reason;
+  return s;
+}
 function parseCursorTranscript(raw, composerId, file, ws, fileMtime) {
   const s = blank(composerId, "cursor", file);
   s.cwd = ws.folder;
-  let cursor = ws.generations.length ? ws.generations[0].t : fileMtime;
+  let cursor2 = ws.generations.length ? ws.generations[0].t : fileMtime;
   let humanIdx = 0;
   for (const lineRaw of raw.split("\n")) {
     const line = lineRaw.trim();
@@ -676,24 +975,24 @@ function parseCursorTranscript(raw, composerId, file, ws, fileMtime) {
     }
     const role = e.role;
     let text = extractText(e.message?.content).replace(SYSTEM_REMINDER_RE, "").trim();
-    const m = text.match(CURSOR_USER_QUERY_RE);
+    const m = text.match(CURSOR_USER_QUERY_RE2);
     if (m)
       text = m[1].trim();
     if (!text)
       continue;
     if (role === "user") {
-      const ts = ws.tsByText.get(text) ?? (humanIdx < ws.generations.length ? ws.generations[humanIdx].t : cursor + 1);
-      cursor = Math.max(cursor, ts);
+      const ts = ws.tsByText.get(text) ?? (humanIdx < ws.generations.length ? ws.generations[humanIdx].t : cursor2 + 1);
+      cursor2 = Math.max(cursor2, ts);
       humanIdx++;
       s.humanTurns++;
       s.humanChars += text.length;
       if (!s.firstHuman)
         s.firstHuman = text.slice(0, 4e3);
-      s.events.push({ t: cursor, k: "human" });
+      s.events.push({ t: cursor2, k: "human" });
     } else if (role === "assistant") {
-      cursor += 1;
+      cursor2 += 1;
       s.aiTurns++;
-      s.events.push({ t: cursor, k: "ai" });
+      s.events.push({ t: cursor2, k: "ai" });
     }
   }
   if (s.events.length === 0 && s.humanTurns === 0)
@@ -726,67 +1025,89 @@ function cursorWorkspaceSession(ws, idx) {
   s.klassReason = c.reason;
   return s;
 }
-async function readCursor() {
-  const workspaces = await readCursorWorkspaces();
+async function readCursorAt(roots, machine) {
+  const workspaces = await readCursorWorkspaces(roots.workspace);
   const out = [];
-  const projects = cursorProjectsRoot();
+  const add = (s) => {
+    if (machine)
+      s.machine = machine;
+    out.push(s);
+  };
+  const projects = roots.projects;
   const usedSlugs = /* @__PURE__ */ new Set();
-  let dirs = [];
-  if (projects) {
-    try {
-      dirs = await fs.readdir(projects, { withFileTypes: true });
-    } catch {
-      dirs = [];
-    }
-  }
-  for (const d of dirs) {
-    if (!d.isDirectory())
-      continue;
-    const slug = d.name;
-    if (SKIP_DIR_RE.test(slug))
-      continue;
-    const transcriptsDir = path.join(projects, slug, "agent-transcripts");
-    let composers = [];
-    try {
-      composers = await fs.readdir(transcriptsDir, { withFileTypes: true });
-    } catch {
-      continue;
+  const dbPath = roots.globalDb;
+  const db = dbPath ? await openCursorSqlite(dbPath) : null;
+  try {
+    let dirs = [];
+    if (projects) {
+      try {
+        dirs = await fs2.readdir(projects, { withFileTypes: true });
+      } catch {
+        dirs = [];
+      }
     }
-    const ws = workspaces.get(slug);
-    if (!ws)
-      continue;
-    usedSlugs.add(slug);
-    for (const c of composers) {
-      if (!c.isDirectory())
+    for (const d of dirs) {
+      if (!d.isDirectory())
         continue;
-      const composerId = c.name;
-      const jf = path.join(transcriptsDir, composerId, `${composerId}.jsonl`);
-      let raw;
-      let mtime = Date.now();
+      const slug = d.name;
+      if (SKIP_DIR_RE.test(slug))
+        continue;
+      const transcriptsDir = path.join(projects, slug, "agent-transcripts");
+      let composers = [];
       try {
-        raw = await fs.readFile(jf, "utf-8");
+        composers = await fs2.readdir(transcriptsDir, { withFileTypes: true });
       } catch {
         continue;
       }
-      try {
-        mtime = (await fs.stat(jf)).mtimeMs;
-      } catch {
+      const ws = workspaces.get(slug);
+      usedSlugs.add(slug);
+      for (const c of composers) {
+        if (!c.isDirectory())
+          continue;
+        const composerId = c.name;
+        const jf = path.join(transcriptsDir, composerId, `${composerId}.jsonl`);
+        const composer = db ? readCursorComposer(db, composerId) : null;
+        if (composer) {
+          const cwd = ws?.folder ?? composer.gitRepo;
+          if (cwd) {
+            add(rawSessionFromCursorComposer(composer, jf, cwd));
+            continue;
+          }
+        }
+        if (!ws)
+          continue;
+        let raw;
+        let mtime = Date.now();
+        try {
+          raw = await fs2.readFile(jf, "utf-8");
+        } catch {
+          continue;
+        }
+        try {
+          mtime = (await fs2.stat(jf)).mtimeMs;
+        } catch {
+        }
+        const s = parseCursorTranscript(raw, composerId, jf, ws, mtime);
+        if (s)
+          add(s);
       }
-      const s = parseCursorTranscript(raw, composerId, jf, ws, mtime);
+    }
+    let i = 0;
+    for (const ws of workspaces.values()) {
+      if (usedSlugs.has(ws.slug))
+        continue;
+      const s = cursorWorkspaceSession(ws, i++);
       if (s)
-        out.push(s);
+        add(s);
     }
-  }
-  let i = 0;
-  for (const ws of workspaces.values()) {
-    if (usedSlugs.has(ws.slug))
-      continue;
-    const s = cursorWorkspaceSession(ws, i++);
-    if (s)
-      out.push(s);
+  } finally {
+    db?.close();
   }
   return out;
 }
+async function readCursor() {
+  return readCursorAt({ workspace: cursorWorkspaceRoot(), projects: cursorProjectsRoot(), globalDb: cursorGlobalDbPath() }, null);
+}
 var FANOUT_PREFIX = 80;
 var FANOUT_MIN_SESSIONS = 3;
 function demoteTemplateFanouts(sessions) {
@@ -809,12 +1130,14 @@ function demoteTemplateFanouts(sessions) {
   }
 }
 async function readAllSessions(opts = {}) {
-  const [cc, cx, cr] = await Promise.all([
+  const [cc, cx, cr, mm] = await Promise.all([
     readClaudeCode(),
     opts.codex === false ? Promise.resolve([]) : readCodex(),
-    opts.cursor === false ? Promise.resolve([]) : readCursor()
+    opts.cursor === false ? Promise.resolve([]) : readCursor(),
+    readMachines({ codex: opts.codex, cursor: opts.cursor })
+    // imported second-machine logs under the data home
   ]);
-  const all = [...cc, ...cx, ...cr];
+  const all = [...cc, ...cx, ...cr, ...mm];
   demoteTemplateFanouts(all);
   return all;
 }
@@ -848,6 +1171,16 @@ function localDate(ms2, tz) {
 function localTime(ms2, tz) {
   return new Date(ms2).toLocaleTimeString("en-GB", { timeZone: tz, hour12: false });
 }
+function deriveMachine(cwd) {
+  if (!cwd)
+    return null;
+  const m = /^\/(?:Users|home)\/([^/]+)/.exec(cwd);
+  if (m)
+    return m[1];
+  if (/^\/root(\/|$)/.test(cwd))
+    return "root";
+  return null;
+}
 function toSessionRecords(sessions, idleGapMin2 = DEFAULT_IDLE_GAP_MIN) {
   const idleGapMs = idleGapMin2 * MIN;
   return sessions.map((s) => {
@@ -861,6 +1194,9 @@ function toSessionRecords(sessions, idleGapMin2 = DEFAULT_IDLE_GAP_MIN) {
       sessionId: s.sessionId,
       source: s.source,
       project: s.cwd,
+      // an imported machine stamps its folder label on the RawSession; local
+      // logs leave it undefined, so the tag falls back to the cwd home segment.
+      machine: s.machine ?? deriveMachine(s.cwd),
       gitBranch: s.gitBranch,
       title: s.titles[s.titles.length - 1] || s.firstHuman.slice(0, 60) || "(untitled)",
       titleHistory: s.titles,
@@ -1086,7 +1422,7 @@ function partition(sessions) {
 }
 
 // ../coding-core/dist/messages.js
-import { promises as fs2 } from "fs";
+import { promises as fs3 } from "fs";
 function extractText2(content) {
   if (typeof content === "string")
     return content;
@@ -1113,15 +1449,35 @@ function extractUserMessagesCodex(raw) {
   }
   return out.sort((a, b) => a.t - b.t);
 }
+function extractUserMessagesCursor(c) {
+  const out = [];
+  let lastTs = null;
+  for (const turn of c.turns) {
+    const t = turn.t;
+    const gapMs = Number.isFinite(t) && lastTs != null ? t - lastTs : NaN;
+    if (Number.isFinite(t))
+      lastTs = t;
+    if (turn.type !== 1)
+      continue;
+    const text = humanTypedText(turn.text);
+    if (text && Number.isFinite(t))
+      out.push({ t, text, gapMs });
+  }
+  return out.sort((a, b) => a.t - b.t);
+}
 async function extractUserMessages(file) {
   let raw;
   try {
-    raw = await fs2.readFile(file, "utf-8");
+    raw = await fs3.readFile(file, "utf-8");
   } catch {
     return [];
   }
   if (sniffCodexRaw(raw))
     return extractUserMessagesCodex(raw);
+  if (sniffCursorRaw(raw)) {
+    const c = await loadCursorComposer(file, raw, cursorDbPathForFile(file));
+    return c ? extractUserMessagesCursor(c) : [];
+  }
   const out = [];
   const userTexts = /* @__PURE__ */ new Set();
   const seenUuids = /* @__PURE__ */ new Set();
@@ -1402,7 +1758,7 @@ var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s
 
 // ../../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).
@@ -1498,13 +1854,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,
@@ -1560,15 +1917,16 @@ var GRADES = path2.join(CODING_DIR, "grades");
 var args = process.argv.slice(2);
 var codex = !args.includes("--no-codex");
 var claude = !args.includes("--no-claude");
+var cursor = !args.includes("--no-cursor");
 var idleGapMin = Number(args[args.indexOf("--idle") + 1]) || DEFAULT_IDLE_GAP_MIN;
 var OUT = CODING_DIR;
 function fmt(n) {
   return n.toLocaleString("en-US");
 }
 async function main() {
-  console.log(`[coding] reading raw logs (claude=${claude}, codex=${codex}, idleGap=${idleGapMin}m, tz=${DEFAULT_TZ}) \u2026`);
+  console.log(`[coding] reading raw logs (claude=${claude}, codex=${codex}, cursor=${cursor}, idleGap=${idleGapMin}m, tz=${DEFAULT_TZ}) \u2026`);
   const t0 = Date.now();
-  let raw = await readAllSessions({ codex });
+  let raw = await readAllSessions({ codex, cursor });
   if (!claude) {
     const dropped = raw.filter((s) => s.source === "claude-code").length;
     raw = raw.filter((s) => s.source !== "claude-code");
@@ -1593,12 +1951,12 @@ async function main() {
   const conc = buildConcurrency(canonRaw, canonRecords, { idleGapMin, tz: DEFAULT_TZ });
   const renames = detectRenames(canonRaw);
   const dayChart = buildDayChart(canonRaw, canonRecords, { idleGapMin, tz: DEFAULT_TZ });
-  await fs3.mkdir(OUT, { recursive: true });
-  await fs3.writeFile(path3.join(OUT, "sessions.json"), JSON.stringify(records, null, 2));
-  await fs3.writeFile(path3.join(OUT, "concurrency.json"), JSON.stringify(conc, null, 2));
-  await fs3.writeFile(path3.join(OUT, "renames.json"), JSON.stringify(renames, null, 2));
-  await fs3.writeFile(path3.join(OUT, "day-chart.json"), JSON.stringify(dayChart));
-  await fs3.writeFile(
+  await fs4.mkdir(OUT, { recursive: true });
+  await fs4.writeFile(path3.join(OUT, "sessions.json"), JSON.stringify(records, null, 2));
+  await fs4.writeFile(path3.join(OUT, "concurrency.json"), JSON.stringify(conc, null, 2));
+  await fs4.writeFile(path3.join(OUT, "renames.json"), JSON.stringify(renames, null, 2));
+  await fs4.writeFile(path3.join(OUT, "day-chart.json"), JSON.stringify(dayChart));
+  await fs4.writeFile(
     path3.join(OUT, "_classified.json"),
     JSON.stringify(raw.map((s) => ({ id: s.sessionId, source: s.source, klass: s.klass, reason: s.klassReason, cwd: s.cwd, firstHuman: s.firstHuman.slice(0, 120) })), null, 2)
   );