polymath-society 0.2.4

package/dist/pipeline/coding-build.js

@@ -0,0 +1,1168 @@
+import{createRequire as __cr}from'module';const require=__cr(import.meta.url);
+
+// ../../scripts/coding-build.mts
+import { promises as fs3 } from "fs";
+import path2 from "path";
+
+// ../coding-core/dist/raw.js
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+
+// ../coding-core/dist/injected.js
+var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var INJECTED_RES = [
+  /<task-notification>[\s\S]*?<\/task-notification>/g,
+  /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
+  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g,
+  /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g
+];
+var HARNESS_TURN_RES = [
+  /^Non user activity$/i,
+  /^<<autonomous-loop(-dynamic)?>>$/,
+  /^This session is being continued from a previous conversation/,
+  // the loop skill's expanded wake-up prompt — older CLI versions wrote it as a
+  // plain user turn with no isMeta flag (found counting 601 words, 2026-07-07)
+  /^(-{3,}\s*)?#\s*Autonomous loop (check|tick)/
+];
+function stripInjected(t) {
+  for (const re of INJECTED_RES)
+    t = t.replace(re, "");
+  return t.replace(SYSTEM_REMINDER_RE, "");
+}
+function isHarnessTurn(t) {
+  const s = t.trim();
+  return HARNESS_TURN_RES.some((re) => re.test(s));
+}
+function humanTypedText(t) {
+  const s = stripInjected(t).trim();
+  return s && !isHarnessTurn(s) ? s : "";
+}
+function isHarnessEntry(e) {
+  return e.isMeta === true || e.isCompactSummary === true;
+}
+
+// ../coding-core/dist/raw.js
+var SOURCE_ROOT_ENV_VARS = [
+  "CLAUDE_PROJECTS_DIR",
+  "CODEX_SESSIONS_DIR",
+  "CURSOR_WORKSPACE_DIR",
+  "CURSOR_PROJECTS_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(os.homedir(), ...defaultSegments);
+}
+var claudeProjectsRoot = () => resolveSourceRoot("CLAUDE_PROJECTS_DIR", ".claude", "projects");
+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 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/;
+var OUTPUT_CONTRACT_RES = [
+  /\b(output|return|respond|reply|answer|emit)\b[^\n.]{0,80}\b(only|single|exactly)\b[\s\S]{0,160}?(```|fenced|json)\b/i,
+  /\b(reply|respond|answer) with only\b/i,
+  /\bONLY a (fenced|```)/i,
+  /output a single fenced/i
+];
+var CAPS_HEADER_RE = /^[A-Z]{2,}[^\n]{0,100}?(?::|\s[–—-])\s/gm;
+function machineShape(fh) {
+  if (PERSONA_RE.test(fh))
+    return "shape:persona-opener";
+  if (OUTPUT_CONTRACT_RES.some((re) => re.test(fh)))
+    return "shape:output-contract";
+  const headers = new Set((fh.match(CAPS_HEADER_RE) ?? []).map((h) => h.split(/[\s:(]/)[0]));
+  if (headers.size >= 2)
+    return "shape:caps-scaffold";
+  return null;
+}
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const item of content) {
+      if (item && typeof item === "object" && item.type === "text") {
+        parts.push(item.text || "");
+      } else if (typeof item === "string")
+        parts.push(item);
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+function humanText(content) {
+  if (Array.isArray(content) && content.some((c) => c && typeof c === "object" && c.type === "tool_result")) {
+    const t2 = humanTypedText(extractText(content));
+    return t2.length > 0 && !content.every((c) => c.type === "tool_result") ? t2 : null;
+  }
+  const t = humanTypedText(extractText(content));
+  return t.length > 0 ? t : null;
+}
+var PING_RE = /^(reply\s*(with|only|:)|say (ok|the word)|acknowledge (session|setup|request)|ok|okay|k|yes|sure|got it|ls|auth_ok|ready|done)\b/i;
+function classify(s) {
+  if (s.cwd && AGENT_CWD_RE.test(s.cwd))
+    return { klass: "agent", reason: `cwd:${s.cwd}` };
+  if (s.humanTurns === 0)
+    return { klass: "agent", reason: "no-human-text" };
+  if (s.humanTurns <= 2 && s.humanChars > 8e3)
+    return { klass: "agent", reason: "mega-prompt" };
+  const fh = s.firstHuman.trim();
+  if (s.humanTurns <= 2 && fh.length <= 50 && PING_RE.test(fh))
+    return { klass: "agent", reason: "ping/ack" };
+  if (s.humanTurns <= 2) {
+    const shape = machineShape(fh);
+    if (shape)
+      return { klass: "agent", reason: shape };
+  }
+  return { klass: "interactive", reason: "human-session" };
+}
+function pushDedup(arr, v) {
+  if (v && arr[arr.length - 1] !== v)
+    arr.push(v);
+}
+function blank(sessionId, source, file) {
+  return {
+    sessionId,
+    source,
+    file,
+    cwd: null,
+    gitBranch: null,
+    entrypoint: null,
+    originator: null,
+    versions: [],
+    events: [],
+    titles: [],
+    modes: [],
+    permissionModes: [],
+    collaborationModes: [],
+    attachments: 0,
+    imageAttachments: 0,
+    queueOps: 0,
+    subagentSpawns: 0,
+    sidechainTurns: 0,
+    mcpTools: [],
+    toolCounts: {},
+    models: {},
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 },
+    humanTurns: 0,
+    humanChars: 0,
+    aiTurns: 0,
+    firstHuman: "",
+    klass: "interactive",
+    klassReason: ""
+  };
+}
+var ms = (ts) => {
+  if (typeof ts !== "string")
+    return null;
+  const n = Date.parse(ts);
+  return Number.isFinite(n) ? n : null;
+};
+function parseClaudeCode(raw, sessionId, file) {
+  const s = blank(sessionId, "claude-code", file);
+  const seen = /* @__PURE__ */ new Set();
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof e.cwd === "string" && !s.cwd)
+      s.cwd = e.cwd;
+    if (typeof e.gitBranch === "string" && !s.gitBranch)
+      s.gitBranch = e.gitBranch;
+    if (typeof e.entrypoint === "string" && !s.entrypoint)
+      s.entrypoint = e.entrypoint;
+    if (typeof e.version === "string" && !s.versions.includes(e.version))
+      s.versions.push(e.version);
+    if (typeof e.permissionMode === "string")
+      pushDedup(s.permissionModes, e.permissionMode);
+    if (e.isSidechain === true && e.type === "assistant")
+      s.sidechainTurns++;
+    const t = ms(e.timestamp);
+    const type = e.type;
+    if (type === "ai-title") {
+      pushDedup(s.titles, e.aiTitle);
+      continue;
+    }
+    if (type === "mode") {
+      pushDedup(s.modes, e.mode ?? null);
+      continue;
+    }
+    if (type === "queue-operation") {
+      if (e.operation === "enqueue" && typeof e.content === "string" && humanTypedText(e.content)) {
+        s.queueOps++;
+        if (t)
+          s.events.push({ t, k: "queue" });
+      }
+      continue;
+    }
+    if (type === "attachment") {
+      s.attachments++;
+      const at = e.attachment?.type;
+      if (at === "image" || at === "pasted_image")
+        s.imageAttachments++;
+      continue;
+    }
+    if (type === "user") {
+      if (isHarnessEntry(e))
+        continue;
+      const msg = e.message ?? {};
+      const dedupKey = typeof e.uuid === "string" ? `u:${e.uuid}` : "";
+      if (dedupKey && seen.has(dedupKey))
+        continue;
+      if (dedupKey)
+        seen.add(dedupKey);
+      const ht = humanText(msg.content);
+      if (ht) {
+        s.humanTurns++;
+        s.humanChars += ht.length;
+        if (!s.firstHuman)
+          s.firstHuman = ht.slice(0, 4e3);
+        if (t)
+          s.events.push({ t, k: "human" });
+      }
+      continue;
+    }
+    if (type === "assistant") {
+      const msg = e.message ?? {};
+      s.aiTurns++;
+      if (t)
+        s.events.push({ t, k: "ai" });
+      if (typeof msg.model === "string")
+        s.models[msg.model] = (s.models[msg.model] ?? 0) + 1;
+      const u = msg.usage ?? {};
+      s.tokens.input += u.input_tokens ?? 0;
+      s.tokens.output += u.output_tokens ?? 0;
+      s.tokens.cacheRead += u.cache_read_input_tokens ?? 0;
+      s.tokens.cacheCreation += u.cache_creation_input_tokens ?? 0;
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item && typeof item === "object" && item.type === "tool_use") {
+            const name = String(item.name ?? "tool");
+            s.toolCounts[name] = (s.toolCounts[name] ?? 0) + 1;
+            if (name === "Agent" || name === "Task")
+              s.subagentSpawns++;
+            if (name.startsWith("mcp__") && !s.mcpTools.includes(name))
+              s.mcpTools.push(name);
+            if (t)
+              s.events.push({ t, k: "tool" });
+          }
+        }
+      }
+      continue;
+    }
+  }
+  if (s.events.length === 0 && s.humanTurns === 0)
+    return null;
+  s.events.sort((a, b) => a.t - b.t);
+  const c = classify(s);
+  s.klass = c.klass;
+  s.klassReason = c.reason;
+  return s;
+}
+function codexText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const item of content) {
+      if (typeof item === "string") {
+        parts.push(item);
+        continue;
+      }
+      if (item && typeof item === "object") {
+        const it = item;
+        if (it.type === "input_text" || it.type === "output_text" || it.type === "text")
+          parts.push(it.text || "");
+      }
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+var CODEX_INJECTED_RE = /^\s*<(environment_context|user_instructions)>/;
+function parseCodex(raw, file) {
+  let sessionId = path.basename(file, ".jsonl");
+  const s = blank(sessionId, "codex", file);
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const t = ms(e.timestamp);
+    const p = e.payload ?? {};
+    if (e.type === "session_meta") {
+      if (typeof p.id === "string") {
+        s.sessionId = p.id;
+        sessionId = p.id;
+      }
+      if (typeof p.cwd === "string")
+        s.cwd = p.cwd;
+      if (typeof p.originator === "string")
+        s.originator = p.originator;
+      if (typeof p.cli_version === "string" && !s.versions.includes(p.cli_version))
+        s.versions.push(p.cli_version);
+      continue;
+    }
+    if (e.type === "event_msg" && p.type === "task_started") {
+      if (typeof p.collaboration_mode_kind === "string")
+        pushDedup(s.collaborationModes, p.collaboration_mode_kind);
+      continue;
+    }
+    if (e.type === "response_item") {
+      const ptype = p.type;
+      if (ptype === "message") {
+        const role = p.role;
+        const text = codexText(p.content).replace(SYSTEM_REMINDER_RE, "").trim();
+        if (role === "user") {
+          if (text && !CODEX_INJECTED_RE.test(text)) {
+            s.humanTurns++;
+            s.humanChars += text.length;
+            if (!s.firstHuman)
+              s.firstHuman = text.slice(0, 4e3);
+            if (t)
+              s.events.push({ t, k: "human" });
+          }
+        } else if (role === "assistant") {
+          s.aiTurns++;
+          if (t)
+            s.events.push({ t, k: "ai" });
+        }
+        continue;
+      }
+      if (ptype === "function_call" || ptype === "local_shell_call" || ptype === "custom_tool_call") {
+        const name = String(p.name ?? ptype);
+        s.toolCounts[name] = (s.toolCounts[name] ?? 0) + 1;
+        if (t)
+          s.events.push({ t, k: "tool" });
+        continue;
+      }
+    }
+  }
+  if (s.events.length === 0 && s.humanTurns === 0)
+    return null;
+  s.events.sort((a, b) => a.t - b.t);
+  const c = classify(s);
+  s.klass = c.klass;
+  s.klassReason = c.reason;
+  return s;
+}
+async function readClaudeCode() {
+  const base = claudeProjectsRoot();
+  const out = [];
+  if (!base)
+    return out;
+  let dirs = [];
+  try {
+    dirs = await fs.readdir(base);
+  } catch {
+    return out;
+  }
+  for (const dir of dirs) {
+    if (SKIP_DIR_RE.test(dir))
+      continue;
+    const full = path.join(base, dir);
+    let files = [];
+    try {
+      files = (await fs.readdir(full)).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      const file = path.join(full, f);
+      let raw;
+      try {
+        raw = await fs.readFile(file, "utf-8");
+      } catch {
+        continue;
+      }
+      const s = parseClaudeCode(raw, path.basename(f, ".jsonl"), file);
+      if (s)
+        out.push(s);
+    }
+  }
+  return out;
+}
+async function walkJsonl(dir, acc) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const ent of entries) {
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory())
+      await walkJsonl(full, acc);
+    else if (ent.name.endsWith(".jsonl"))
+      acc.push(full);
+  }
+}
+async function readCodex() {
+  const base = codexSessionsRoot();
+  if (!base)
+    return [];
+  const files = [];
+  await walkJsonl(base, files);
+  const out = [];
+  for (const file of files) {
+    let raw;
+    try {
+      raw = await fs.readFile(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const s = parseCodex(raw, file);
+    if (s)
+      out.push(s);
+  }
+  return out;
+}
+var CURSOR_USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/;
+function fileUriToPath(uri) {
+  if (typeof uri !== "string" || !uri)
+    return null;
+  let s = uri.replace(/^file:\/\//, "");
+  try {
+    s = decodeURIComponent(s);
+  } catch {
+  }
+  return s || null;
+}
+function cursorSlug(folderPath) {
+  return folderPath.replace(/^\//, "").replace(/[^A-Za-z0-9]+/g, "-").replace(/-+$/, "");
+}
+var NODE_SQLITE = "node:sqlite";
+async function openCursorDb(dbPath) {
+  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;
+    }
+  }
+  return {
+    get(key) {
+      try {
+        const row = db.prepare("SELECT value FROM ItemTable WHERE key = ?").get(key);
+        if (!row || row.value == null)
+          return [];
+        const txt = typeof row.value === "string" ? row.value : Buffer.from(row.value).toString("utf-8");
+        const parsed = JSON.parse(txt);
+        return Array.isArray(parsed) ? parsed : Object.values(parsed ?? {});
+      } catch {
+        return [];
+      }
+    },
+    close() {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  };
+}
+async function readCursorWorkspaces() {
+  const base = cursorWorkspaceRoot();
+  const out = /* @__PURE__ */ new Map();
+  if (!base)
+    return out;
+  let dirs = [];
+  try {
+    dirs = await fs.readdir(base, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const d of dirs) {
+    if (!d.isDirectory())
+      continue;
+    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);
+    } catch {
+    }
+    if (!folder)
+      continue;
+    const dbFile = path.join(wsDir, "state.vscdb");
+    try {
+      await fs.access(dbFile);
+    } catch {
+      continue;
+    }
+    const db = await openCursorDb(dbFile);
+    if (!db)
+      continue;
+    const tsByText = /* @__PURE__ */ new Map();
+    const generations = [];
+    const prompts = [];
+    try {
+      for (const item of db.get("aiService.generations")) {
+        if (!item || typeof item !== "object")
+          continue;
+        const it = item;
+        const text = String(it.textDescription ?? "").trim();
+        const t = Number(it.unixMs ?? 0);
+        if (!text || !t)
+          continue;
+        generations.push({ text, t });
+        const prev = tsByText.get(text);
+        if (prev == null || t < prev)
+          tsByText.set(text, t);
+      }
+      for (const item of db.get("aiService.prompts")) {
+        if (!item || typeof item !== "object")
+          continue;
+        const text = String(item.text ?? "").trim();
+        if (text)
+          prompts.push(text);
+      }
+    } finally {
+      db.close();
+    }
+    generations.sort((a, b) => a.t - b.t);
+    const slug = cursorSlug(folder);
+    const existing = out.get(slug);
+    if (existing) {
+      for (const g of generations)
+        existing.generations.push(g);
+      for (const [k, v] of tsByText) {
+        const p = existing.tsByText.get(k);
+        if (p == null || v < p)
+          existing.tsByText.set(k, v);
+      }
+      for (const p of prompts)
+        existing.prompts.push(p);
+      existing.generations.sort((a, b) => a.t - b.t);
+    } else {
+      out.set(slug, { folder, slug, tsByText, generations, prompts });
+    }
+  }
+  return out;
+}
+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 humanIdx = 0;
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const role = e.role;
+    let text = extractText(e.message?.content).replace(SYSTEM_REMINDER_RE, "").trim();
+    const m = text.match(CURSOR_USER_QUERY_RE);
+    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);
+      humanIdx++;
+      s.humanTurns++;
+      s.humanChars += text.length;
+      if (!s.firstHuman)
+        s.firstHuman = text.slice(0, 4e3);
+      s.events.push({ t: cursor, k: "human" });
+    } else if (role === "assistant") {
+      cursor += 1;
+      s.aiTurns++;
+      s.events.push({ t: cursor, k: "ai" });
+    }
+  }
+  if (s.events.length === 0 && s.humanTurns === 0)
+    return null;
+  s.events.sort((a, b) => a.t - b.t);
+  const c = classify(s);
+  s.klass = c.klass;
+  s.klassReason = c.reason;
+  return s;
+}
+function cursorWorkspaceSession(ws, idx) {
+  if (ws.generations.length === 0)
+    return null;
+  const s = blank(`cursor-${cursorSlug(ws.folder).slice(0, 12)}-${idx}`, "cursor", `cursor-workspace:${ws.folder}`);
+  s.cwd = ws.folder;
+  for (const g of ws.generations) {
+    s.humanTurns++;
+    s.humanChars += g.text.length;
+    if (!s.firstHuman)
+      s.firstHuman = g.text.slice(0, 4e3);
+    s.aiTurns++;
+    s.events.push({ t: g.t, k: "human" });
+    s.events.push({ t: g.t, k: "ai" });
+  }
+  if (s.events.length === 0)
+    return null;
+  s.events.sort((a, b) => a.t - b.t);
+  const c = classify(s);
+  s.klass = c.klass;
+  s.klassReason = c.reason;
+  return s;
+}
+async function readCursor() {
+  const workspaces = await readCursorWorkspaces();
+  const out = [];
+  const projects = cursorProjectsRoot();
+  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 ws = workspaces.get(slug);
+    if (!ws)
+      continue;
+    usedSlugs.add(slug);
+    for (const c of composers) {
+      if (!c.isDirectory())
+        continue;
+      const composerId = c.name;
+      const jf = path.join(transcriptsDir, composerId, `${composerId}.jsonl`);
+      let raw;
+      let mtime = Date.now();
+      try {
+        raw = await fs.readFile(jf, "utf-8");
+      } catch {
+        continue;
+      }
+      try {
+        mtime = (await fs.stat(jf)).mtimeMs;
+      } catch {
+      }
+      const s = parseCursorTranscript(raw, composerId, jf, ws, mtime);
+      if (s)
+        out.push(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);
+  }
+  return out;
+}
+var FANOUT_PREFIX = 80;
+var FANOUT_MIN_SESSIONS = 3;
+function demoteTemplateFanouts(sessions) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    if (s.klass !== "interactive" || s.humanTurns > 2)
+      continue;
+    const key = s.firstHuman.replace(/\s+/g, " ").trim().slice(0, FANOUT_PREFIX);
+    if (key.length < FANOUT_PREFIX)
+      continue;
+    (groups.get(key) ?? groups.set(key, []).get(key)).push(s);
+  }
+  for (const g of groups.values()) {
+    if (g.length < FANOUT_MIN_SESSIONS)
+      continue;
+    for (const s of g) {
+      s.klass = "agent";
+      s.klassReason = `template-fanout(x${g.length})`;
+    }
+  }
+}
+async function readAllSessions(opts = {}) {
+  const [cc, cx, cr] = await Promise.all([
+    readClaudeCode(),
+    opts.codex === false ? Promise.resolve([]) : readCodex(),
+    opts.cursor === false ? Promise.resolve([]) : readCursor()
+  ]);
+  const all = [...cc, ...cx, ...cr];
+  demoteTemplateFanouts(all);
+  return all;
+}
+
+// ../coding-core/dist/deterministic.js
+var DEFAULT_IDLE_GAP_MIN = 5;
+var DEFAULT_TZ = process.env.CODING_TZ || "America/Los_Angeles";
+function activeIntervals(times, idleGapMs) {
+  if (times.length === 0)
+    return [];
+  const xs = [...times].sort((a, b) => a - b);
+  const out = [];
+  let start = xs[0];
+  let prev = xs[0];
+  for (let i = 1; i < xs.length; i++) {
+    if (xs[i] - prev > idleGapMs) {
+      out.push([start, prev]);
+      start = xs[i];
+    }
+    prev = xs[i];
+  }
+  out.push([start, prev]);
+  return out;
+}
+var MIN = 6e4;
+var round1 = (x) => Math.round(x * 10) / 10;
+var round2 = (x) => Math.round(x * 100) / 100;
+function localDate(ms2, tz) {
+  return new Date(ms2).toLocaleDateString("en-CA", { timeZone: tz });
+}
+function localTime(ms2, tz) {
+  return new Date(ms2).toLocaleTimeString("en-GB", { timeZone: tz, hour12: false });
+}
+function toSessionRecords(sessions, idleGapMin2 = DEFAULT_IDLE_GAP_MIN) {
+  const idleGapMs = idleGapMin2 * MIN;
+  return sessions.map((s) => {
+    const times = s.events.map((e) => e.t);
+    const intervals = activeIntervals(times, idleGapMs);
+    const start = times.length ? Math.min(...times) : 0;
+    const end = times.length ? Math.max(...times) : 0;
+    const activeMs = intervals.reduce((a, [x, y]) => a + (y - x), 0);
+    const toolCalls = Object.values(s.toolCounts).reduce((a, b) => a + b, 0);
+    return {
+      sessionId: s.sessionId,
+      source: s.source,
+      project: s.cwd,
+      gitBranch: s.gitBranch,
+      title: s.titles[s.titles.length - 1] || s.firstHuman.slice(0, 60) || "(untitled)",
+      titleHistory: s.titles,
+      renamed: s.titles.length > 1,
+      start: start ? new Date(start).toISOString() : "",
+      end: end ? new Date(end).toISOString() : "",
+      durationMin: round1((end - start) / MIN),
+      activeMin: round1(activeMs / MIN),
+      idleSplits: Math.max(0, intervals.length - 1),
+      humanTurns: s.humanTurns,
+      humanChars: s.humanChars,
+      aiTurns: s.aiTurns,
+      toolCalls,
+      toolCounts: s.toolCounts,
+      models: s.models,
+      tokens: s.tokens,
+      modes: s.modes,
+      permissionModes: s.permissionModes,
+      collaborationModes: s.collaborationModes,
+      queueOps: s.queueOps,
+      attachments: s.attachments,
+      imageAttachments: s.imageAttachments,
+      subagentSpawns: s.subagentSpawns,
+      sidechainTurns: s.sidechainTurns,
+      mcpTools: s.mcpTools,
+      klass: s.klass,
+      klassReason: s.klassReason,
+      file: s.file
+    };
+  });
+}
+function detectRenames(sessions) {
+  const out = [];
+  for (const s of sessions) {
+    for (let i = 1; i < s.titles.length; i++) {
+      out.push({ sessionId: s.sessionId, index: i - 1, from: s.titles[i - 1], to: s.titles[i] });
+    }
+  }
+  return out;
+}
+function buildConcurrency(sessions, records, opts = {}) {
+  const idleGapMin2 = opts.idleGapMin ?? DEFAULT_IDLE_GAP_MIN;
+  const tz = opts.tz ?? DEFAULT_TZ;
+  const idleGapMs = idleGapMin2 * MIN;
+  const titleById = new Map(records.map((r) => [r.sessionId, r.title]));
+  const intervals = [];
+  for (const s of sessions) {
+    const title = titleById.get(s.sessionId) ?? "(untitled)";
+    for (const [start, end] of activeIntervals(s.events.map((e) => e.t), idleGapMs)) {
+      intervals.push({ id: s.sessionId, title, start, end: end === start ? end + 1e3 : end });
+    }
+  }
+  const pts = intervals.flatMap((iv) => [{ t: iv.start, d: 1, iv }, { t: iv.end, d: -1, iv }]).sort((a, b) => a.t - b.t || a.d - b.d);
+  const active = /* @__PURE__ */ new Map();
+  const segments = [];
+  const levelHist = {};
+  let prevT = pts.length ? pts[0].t : 0;
+  const flush = (upto) => {
+    const level = active.size;
+    if (level > 0 && upto > prevT) {
+      const minutes = (upto - prevT) / MIN;
+      levelHist[level] = (levelHist[level] ?? 0) + minutes;
+      if (level >= 2) {
+        segments.push({
+          start: new Date(prevT).toISOString(),
+          end: new Date(upto).toISOString(),
+          minutes: round2(minutes),
+          level,
+          sessions: [...active.entries()].map(([id, title]) => ({ id, title }))
+        });
+      }
+    }
+  };
+  for (const p of pts) {
+    flush(p.t);
+    if (p.d === 1)
+      active.set(p.iv.id, p.iv.title);
+    else
+      active.delete(p.iv.id);
+    prevT = p.t;
+  }
+  for (const k of Object.keys(levelHist))
+    levelHist[k] = round1(levelHist[k]);
+  const maxConcurrency = Object.keys(levelHist).reduce((m, k) => Math.max(m, Number(k)), 0);
+  return {
+    idleGapMin: idleGapMin2,
+    tz,
+    maxConcurrency,
+    levelHistogramMin: levelHist,
+    segments,
+    perDay: perDayMetrics(intervals, records, tz)
+  };
+}
+function perDayMetrics(intervals, records, tz) {
+  const byDay = /* @__PURE__ */ new Map();
+  for (const iv of intervals) {
+    let cur = iv.start;
+    while (cur < iv.end) {
+      const day = localDate(cur, tz);
+      const dayEnd = nextLocalMidnight(cur, tz);
+      const segEnd = Math.min(iv.end, dayEnd);
+      (byDay.get(day) ?? byDay.set(day, []).get(day)).push({ iv, start: cur, end: segEnd });
+      cur = segEnd;
+    }
+  }
+  const startsByDay = /* @__PURE__ */ new Map();
+  const humanByDay = /* @__PURE__ */ new Map();
+  const toolsByDay = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (!r.start)
+      continue;
+    const day = localDate(Date.parse(r.start), tz);
+    startsByDay.set(day, (startsByDay.get(day) ?? 0) + 1);
+    humanByDay.set(day, (humanByDay.get(day) ?? 0) + r.humanTurns);
+    toolsByDay.set(day, (toolsByDay.get(day) ?? 0) + r.toolCalls);
+  }
+  const out = [];
+  for (const [date, segs] of [...byDay.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    const pts = segs.flatMap((s) => [{ t: s.start, d: 1 }, { t: s.end, d: -1 }]).sort((a, b) => a.t - b.t || a.d - b.d);
+    let live = 0, prevT = pts.length ? pts[0].t : 0, activeMs = 0, overlapMs = 0, peak = 0;
+    for (const p of pts) {
+      if (p.t > prevT) {
+        if (live >= 1)
+          activeMs += p.t - prevT;
+        if (live >= 2)
+          overlapMs += p.t - prevT;
+      }
+      live += p.d;
+      peak = Math.max(peak, live);
+      prevT = p.t;
+    }
+    const starts = segs.map((s) => s.iv.start);
+    const ends = segs.map((s) => s.iv.end);
+    const firstStartMs = Math.min(...starts);
+    const lastEndMs = Math.max(...ends);
+    out.push({
+      date,
+      sessionsStarted: startsByDay.get(date) ?? 0,
+      activeMin: round1(activeMs / MIN),
+      overlapMin: round1(overlapMs / MIN),
+      overlapRatio: activeMs > 0 ? round2(overlapMs / activeMs) : 0,
+      peakConcurrency: peak,
+      firstStart: localTime(firstStartMs, tz),
+      lastEnd: localTime(lastEndMs, tz),
+      spanMin: round1((lastEndMs - firstStartMs) / MIN),
+      humanTurns: humanByDay.get(date) ?? 0,
+      toolCalls: toolsByDay.get(date) ?? 0
+    });
+  }
+  return out;
+}
+function buildDayChart(sessions, records, opts = {}) {
+  const idleGapMs = (opts.idleGapMin ?? DEFAULT_IDLE_GAP_MIN) * MIN;
+  const tz = opts.tz ?? DEFAULT_TZ;
+  const titleById = new Map(records.map((r) => [r.sessionId, r.title]));
+  const byDate = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    for (const [start, rawEnd] of activeIntervals(s.events.map((e) => e.t), idleGapMs)) {
+      const end = rawEnd === start ? start + 3e4 : rawEnd;
+      let cur = start;
+      while (cur < end) {
+        const date = localDate(cur, tz);
+        const segEnd = Math.min(end, nextLocalMidnight(cur, tz));
+        const day = byDate.get(date) ?? byDate.set(date, /* @__PURE__ */ new Map()).get(date);
+        const conv = day.get(s.sessionId) ?? day.set(s.sessionId, { sessionId: s.sessionId, title: titleById.get(s.sessionId) ?? "(untitled)", intervals: [] }).get(s.sessionId);
+        conv.intervals.push([cur, segEnd]);
+        cur = segEnd;
+      }
+    }
+  }
+  const out = [];
+  for (const [date, convs] of byDate) {
+    const all = [...convs.values()].flatMap((c) => c.intervals);
+    if (!all.length)
+      continue;
+    const start = Math.min(...all.map((i) => i[0]));
+    const end = Math.max(...all.map((i) => i[1]));
+    const conversations = [...convs.values()].sort((a, b) => Math.min(...a.intervals.map((i) => i[0])) - Math.min(...b.intervals.map((i) => i[0])));
+    out.push({ date, start, end, conversations });
+  }
+  return out.sort((a, b) => b.date.localeCompare(a.date));
+}
+function nextLocalMidnight(fromMs, tz) {
+  const day = localDate(fromMs, tz);
+  for (let h = 1; h <= 26; h++) {
+    const probe = fromMs + h * 60 * MIN;
+    if (localDate(probe, tz) !== day) {
+      let lo = fromMs, hi = probe;
+      while (hi - lo > MIN) {
+        const mid = (lo + hi) / 2;
+        if (localDate(mid, tz) === day)
+          lo = mid;
+        else
+          hi = mid;
+      }
+      return hi;
+    }
+  }
+  return fromMs + 24 * 60 * MIN;
+}
+
+// ../coding-core/dist/gate.js
+var GATE = {
+  minHumanChars: 800,
+  // the user must have actually said something substantial
+  minHumanTurns: 3,
+  // …over enough back-and-forth to reveal how they work
+  trivialHumanChars: 300,
+  // below this = a one-liner, definitely trivial
+  trivialHumanTurns: 2
+};
+function isGradable(s) {
+  return s.humanChars >= GATE.minHumanChars && s.humanTurns >= GATE.minHumanTurns;
+}
+function isTrivial(s) {
+  return s.humanTurns < GATE.trivialHumanTurns || s.humanChars < GATE.trivialHumanChars;
+}
+function partition(sessions) {
+  const gradable = [], thin = [], trivial = [];
+  for (const s of sessions)
+    (isGradable(s) ? gradable : isTrivial(s) ? trivial : thin).push(s);
+  return { gradable, thin, trivial };
+}
+
+// ../coding-core/dist/messages.js
+import { promises as fs2 } from "fs";
+function extractText2(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.filter((c) => c && typeof c === "object" && c.type === "text").map((c) => c.text || "").join("\n");
+  return "";
+}
+function isToolResultOnly(content) {
+  return Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
+}
+async function extractUserMessages(file) {
+  let raw;
+  try {
+    raw = await fs2.readFile(file, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  const userTexts = /* @__PURE__ */ new Set();
+  const seenUuids = /* @__PURE__ */ new Set();
+  let lastTs = null;
+  for (const line of raw.split("\n")) {
+    const s = line.trim();
+    if (!s)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(s);
+    } catch {
+      continue;
+    }
+    const t = typeof e.timestamp === "string" ? Date.parse(e.timestamp) : NaN;
+    const gapMs = Number.isFinite(t) && lastTs != null ? t - lastTs : NaN;
+    if (Number.isFinite(t))
+      lastTs = t;
+    if (e.type === "queue-operation" && e.operation === "enqueue" && typeof e.content === "string") {
+      const qt = humanTypedText(e.content);
+      if (qt && Number.isFinite(t))
+        out.push({ t, text: qt, gapMs, q: true });
+      continue;
+    }
+    if (e.type === "user") {
+      if (isHarnessEntry(e))
+        continue;
+      const uuid = typeof e.uuid === "string" ? e.uuid : "";
+      if (uuid && seenUuids.has(uuid))
+        continue;
+      const content = e.message?.content;
+      if (isToolResultOnly(content))
+        continue;
+      const text = humanTypedText(extractText2(content));
+      if (text && Number.isFinite(t)) {
+        if (uuid)
+          seenUuids.add(uuid);
+        userTexts.add(text);
+        out.push({ t, text, gapMs, uuid: uuid || void 0 });
+      }
+    }
+  }
+  return out.filter((m) => !(m.q && userTexts.has(m.text))).map(({ q, ...m }) => m).sort((a, b) => a.t - b.t);
+}
+
+// ../coding-core/dist/dedup.js
+var THRESHOLD = 0.9;
+var MIN_MSGS = 3;
+async function markDuplicates(records) {
+  const sets = /* @__PURE__ */ new Map();
+  await Promise.all(records.map(async (r) => {
+    const m = await extractUserMessages(r.file).catch(() => []);
+    sets.set(r.sessionId, new Set(m.map((x) => x.text.trim()).filter(Boolean)));
+  }));
+  const sorted = [...records].sort((a, b) => sets.get(b.sessionId).size - sets.get(a.sessionId).size);
+  let count = 0;
+  for (let i = 0; i < sorted.length; i++) {
+    const A = sorted[i];
+    const aSet = sets.get(A.sessionId);
+    if (aSet.size < MIN_MSGS)
+      continue;
+    for (let j = 0; j < i; j++) {
+      const B = sorted[j];
+      if (B.duplicateOf)
+        continue;
+      const bSet = sets.get(B.sessionId);
+      let inB = 0;
+      for (const t of aSet)
+        if (bSet.has(t))
+          inB++;
+      if (inB / aSet.size >= THRESHOLD) {
+        A.duplicateOf = B.sessionId;
+        count++;
+        break;
+      }
+    }
+  }
+  return count;
+}
+
+// ../../scripts/coding-build.mts
+var args = process.argv.slice(2);
+var codex = !args.includes("--no-codex");
+var idleGapMin = Number(args[args.indexOf("--idle") + 1]) || DEFAULT_IDLE_GAP_MIN;
+var OUT = path2.join(process.cwd(), ".data", "coding");
+function fmt(n) {
+  return n.toLocaleString("en-US");
+}
+async function main() {
+  console.log(`[coding] reading raw logs (codex=${codex}, idleGap=${idleGapMin}m, tz=${DEFAULT_TZ}) \u2026`);
+  const t0 = Date.now();
+  const raw = await readAllSessions({ codex });
+  console.log(`[coding] parsed ${fmt(raw.length)} sessions in ${((Date.now() - t0) / 1e3).toFixed(1)}s`);
+  const interactive = raw.filter((s) => s.klass === "interactive");
+  const agent = raw.filter((s) => s.klass === "agent");
+  console.log(`[coding] interactive=${fmt(interactive.length)}  agent/excluded=${fmt(agent.length)}`);
+  const reasons = /* @__PURE__ */ new Map();
+  for (const s of agent) {
+    const key = s.klassReason.startsWith("cwd:") ? "cwd:<agent-dir>" : s.klassReason;
+    reasons.set(key, (reasons.get(key) ?? 0) + 1);
+  }
+  console.log(`[coding] excluded-by-reason:`, Object.fromEntries([...reasons.entries()].sort((a, b) => b[1] - a[1])));
+  const records = toSessionRecords(interactive, idleGapMin);
+  const dupCount = await markDuplicates(records);
+  const dupSet = new Set(records.filter((r) => r.duplicateOf).map((r) => r.sessionId));
+  const canonRaw = interactive.filter((s) => !dupSet.has(s.sessionId));
+  const canonRecords = records.filter((r) => !r.duplicateOf);
+  console.log(`[coding] duplicate (resume-copy) sessions: ${dupCount} \u2192 excluded from all counts`);
+  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(path2.join(OUT, "sessions.json"), JSON.stringify(records, null, 2));
+  await fs3.writeFile(path2.join(OUT, "concurrency.json"), JSON.stringify(conc, null, 2));
+  await fs3.writeFile(path2.join(OUT, "renames.json"), JSON.stringify(renames, null, 2));
+  await fs3.writeFile(path2.join(OUT, "day-chart.json"), JSON.stringify(dayChart));
+  await fs3.writeFile(
+    path2.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)
+  );
+  const bySource = (k) => records.filter((r) => r.source === k).length;
+  const totalActive = records.reduce((a, r) => a + r.activeMin, 0);
+  const totalTools = records.reduce((a, r) => a + r.toolCalls, 0);
+  const totalQueue = records.reduce((a, r) => a + r.queueOps, 0);
+  const totalSub = records.reduce((a, r) => a + r.subagentSpawns, 0);
+  const models = /* @__PURE__ */ new Map();
+  for (const r of records) for (const [m, n] of Object.entries(r.models)) models.set(m, (models.get(m) ?? 0) + n);
+  const dates = records.map((r) => r.start).filter(Boolean).sort();
+  const topConcDays = [...conc.perDay].sort((a, b) => b.peakConcurrency - a.peakConcurrency || b.overlapMin - a.overlapMin).slice(0, 8);
+  const split = partition(records);
+  console.log(`
+========== DETERMINISTIC CODING SUMMARY ==========`);
+  console.log(`interactive sessions: ${fmt(records.length)}  (claude-code=${bySource("claude-code")}, codex=${bySource("codex")})`);
+  console.log(`gradable: ${fmt(split.gradable.length)} \xB7 thin: ${fmt(split.thin.length)} \xB7 trivial (never graded): ${fmt(split.trivial.length)}  \u2014 all ${fmt(records.length)} still count for parallelism/throughput`);
+  if (dates.length) console.log(`date range: ${dates[0].slice(0, 10)} \u2192 ${dates[dates.length - 1].slice(0, 10)}`);
+  console.log(`active work time: ${(totalActive / 60).toFixed(1)} h   tool calls: ${fmt(totalTools)}   subagents spawned: ${fmt(totalSub)}   queue-ahead ops: ${fmt(totalQueue)}`);
+  console.log(`renames: ${fmt(renames.length)}   sessions with >1 title: ${fmt(records.filter((r) => r.renamed).length)}`);
+  console.log(`models:`, Object.fromEntries([...models.entries()].sort((a, b) => b[1] - a[1])));
+  console.log(`
+PARALLELISM  (idle-gap ${idleGapMin}m, tz ${conc.tz})`);
+  console.log(`  max concurrent sessions: ${conc.maxConcurrency}`);
+  console.log(`  minutes spent at each concurrency level:`, conc.levelHistogramMin);
+  console.log(`  highest-parallelism days:`);
+  for (const d of topConcDays)
+    console.log(`    ${d.date}  peak\xD7${d.peakConcurrency}  active ${(d.activeMin / 60).toFixed(1)}h  overlap ${(d.overlapMin / 60).toFixed(1)}h (${Math.round(d.overlapRatio * 100)}%)  ${d.firstStart}\u2192${d.lastEnd}  ${d.sessionsStarted} sessions`);
+  console.log(`
+wrote \u2192 ${path2.relative(process.cwd(), OUT)}/{sessions,concurrency,renames,_classified}.json`);
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});