polymath-society 0.2.19 → 0.2.21

package/dist/pipeline/coding-delegation.js

@@ -134,13 +134,13 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-delegation.mts
-import { promises as fs9 } from "fs";
-import path12 from "path";
+import { promises as fs10 } from "fs";
+import path13 from "path";
 
 // ../../lib/agents/coding/delegation/detect.ts
-import { promises as fs6 } from "fs";
-import os2 from "os";
-import path9 from "path";
+import { promises as fs7 } from "fs";
+import os3 from "os";
+import path10 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -508,6 +508,13 @@ ${report}`);
 }
 
 // ../../lib/agents/shared/codexAdapter.ts
+var CODEX_DEFAULT_MODEL = "gpt-5.5";
+var CODEX_MINI_MODEL = "gpt-5.4-mini";
+function mapCodexTier(model, env = process.env) {
+  if (model && !/^(claude|haiku|sonnet|opus)/i.test(model)) return model;
+  if (model && /^haiku/i.test(model)) return env.POLYMATH_CODEX_MODEL_MINI || CODEX_MINI_MODEL;
+  return env.POLYMATH_CODEX_MODEL || CODEX_DEFAULT_MODEL;
+}
 function composePrompt(inv, roots) {
   return [
     inv.systemPrompt ? `<system>
@@ -548,7 +555,7 @@ var codexAdapter = {
       "read-only",
       "--json"
     ];
-    if (inv.model && !/^claude/i.test(inv.model)) args.push("--model", inv.model);
+    args.push("--model", mapCodexTier(inv.model));
     args.push(composePrompt(inv, roots));
     const started = Date.now();
     const toolCalls = [];
@@ -2176,8 +2183,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path14, errorMaps, issueData } = params;
+  const fullPath = [...path14, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2293,11 +2300,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path14, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path14;
     this._key = key;
   }
   get path() {
@@ -15084,39 +15091,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -15137,7 +15144,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path13 }) => `${baseURL}${path13}`,
+      url: ({ path: path14 }) => `${baseURL}${path14}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -15659,7 +15666,7 @@ function invokeAgent(inv, opts = {}) {
 }
 
 // ../../lib/agents/coding/materialize.ts
-import { promises as fs4 } from "fs";
+import { promises as fs5 } from "fs";
 
 // ../coding-core/dist/injected.js
 var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -15694,8 +15701,392 @@ function isHarnessEntry(e) {
   return e.isMeta === true || e.isCompactSummary === true;
 }
 
-// ../../lib/agents/coding/materialize.ts
+// ../coding-core/dist/codex.js
 var SYSTEM_REMINDER_RE2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var CODEX_INJECTED_TEXT_RE = /^\s*(<(environment_context|user_instructions|ENVIRONMENT_CONTEXT|turn_aborted)\b|#\s*AGENTS\.md instructions\b)/;
+function isCodexInjectedUserText(text2) {
+  return CODEX_INJECTED_TEXT_RE.test(text2);
+}
+function codexContentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  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");
+}
+function sniffCodexRaw(raw) {
+  let checked = 0;
+  for (const lineRaw of raw.split("\n")) {
+    const line = lineRaw.trim();
+    if (!line)
+      continue;
+    if (checked++ >= 5)
+      break;
+    try {
+      const e = JSON.parse(line);
+      if (e.type === "session_meta" || e.type === "response_item" || e.type === "turn_context")
+        return true;
+      if (e.type === "user" || e.type === "assistant" || e.type === "summary" || e.type === "queue-operation")
+        return false;
+    } catch {
+    }
+  }
+  return false;
+}
+var EXIT_CODE_RE = /(?:Process exited with code|Exit code:)\s+(\d+)/;
+function extractCodexEvents(raw) {
+  const out = [];
+  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.type !== "response_item")
+      continue;
+    const p = e.payload ?? {};
+    const t = typeof e.timestamp === "string" ? Date.parse(e.timestamp) : NaN;
+    const ptype = p.type;
+    if (ptype === "message") {
+      const role = p.role;
+      const text2 = codexContentText(p.content).replace(SYSTEM_REMINDER_RE2, "").trim();
+      if (!text2)
+        continue;
+      if (role === "user") {
+        if (isCodexInjectedUserText(text2))
+          continue;
+        out.push({ kind: "user", t, text: text2 });
+      } else if (role === "assistant") {
+        out.push({ kind: "assistant", t, text: text2 });
+      }
+      continue;
+    }
+    if (ptype === "function_call" || ptype === "custom_tool_call" || ptype === "local_shell_call") {
+      const name17 = typeof p.name === "string" && p.name ? p.name : ptype === "local_shell_call" ? "shell" : String(ptype);
+      const input = typeof p.arguments === "string" ? p.arguments : typeof p.input === "string" ? p.input : "";
+      out.push({ kind: "tool", t, name: name17, input });
+      continue;
+    }
+    if (ptype === "function_call_output" || ptype === "custom_tool_call_output") {
+      const output = typeof p.output === "string" ? p.output : "";
+      const m = EXIT_CODE_RE.exec(output.slice(0, 200));
+      out.push({ kind: "tool_output", t, output, isError: !!m && m[1] !== "0" });
+    }
+  }
+  return out;
+}
+function codexPatchFiles(input) {
+  const files = [];
+  const re2 = /\*\*\*\s+(?:Update|Add|Delete)\s+File:\s+(.+)/g;
+  let m;
+  while (m = re2.exec(input)) {
+    const short = m[1].trim().split("/").slice(-2).join("/");
+    if (short && !files.includes(short))
+      files.push(short);
+  }
+  return files;
+}
+var CODEX_MUTATORS = /* @__PURE__ */ new Set(["apply_patch"]);
+var CODEX_INVESTIGATORS = /* @__PURE__ */ new Set(["exec_command", "shell", "local_shell_call", "read_file", "list_dir", "grep", "web_search", "view_image"]);
+
+// ../coding-core/dist/cursor.js
+import { promises as fs4 } from "fs";
+var NODE_SQLITE = "node:sqlite";
+async function openCursorSqlite(dbPath) {
+  try {
+    await fs4.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 tool2 = type === 2 && b.toolFormerData && typeof b.toolFormerData.name === "string" ? b.toolFormerData.name : null;
+    const rawText = typeof b.text === "string" ? b.text : "";
+    const text2 = type === 1 ? cleanUserText(rawText) : rawText.replace(SYSTEM_REMINDER_RE, "").trim();
+    if (!text2 && !tool2)
+      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: text2, tool: tool2, 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 text2 = type === 1 ? cleanUserText(rawText) : rawText.replace(SYSTEM_REMINDER_RE, "").trim();
+    if (type === 2 && tools.length) {
+      for (const tool2 of tools) {
+        clock += 1;
+        turns.push({ t: clock, type: 2, text: "", tool: tool2, model: null });
+      }
+    }
+    if (!text2)
+      continue;
+    clock += 1;
+    turns.push({ t: clock, type, text: text2, tool: null, model: null });
+  }
+  if (turns.length === 0)
+    return null;
+  return { composerId: "", createdAt: base, updatedAt: clock, name: null, gitRepo: null, turns };
+}
+var AI_GIST = 500;
+function renderCursorTranscript(c) {
+  const lines = [];
+  let humanTurns = 0, humanChars = 0;
+  let aiProse = "";
+  const aiTools = /* @__PURE__ */ new Map();
+  const flushAI = () => {
+    if (!aiProse && aiTools.size === 0)
+      return;
+    const tools = [...aiTools.entries()].map(([n, k]) => k > 1 ? `${n}\xD7${k}` : n).join(", ");
+    const gist = aiProse ? aiProse.length > AI_GIST ? aiProse.slice(0, AI_GIST) + "\u2026" : aiProse : "";
+    const bits = [];
+    if (gist)
+      bits.push(gist);
+    if (tools)
+      bits.push(`ran ${tools}`);
+    lines.push(`[AI: ${bits.join(" \xB7 ")}]`);
+    aiProse = "";
+    aiTools.clear();
+  };
+  for (const turn of c.turns) {
+    if (turn.type === 1) {
+      flushAI();
+      humanTurns++;
+      humanChars += turn.text.length;
+      lines.push(`>> ${turn.text}`);
+    } else {
+      if (turn.tool)
+        aiTools.set(turn.tool, (aiTools.get(turn.tool) ?? 0) + 1);
+      if (turn.text)
+        aiProse = turn.text.replace(/\s+/g, " ").trim();
+    }
+  }
+  flushAI();
+  return { text: lines.join("\n"), humanTurns, humanChars };
+}
+function composerIdFromFile(file2) {
+  const m = file2.match(/agent-transcripts\/([^/]+)\/[^/]+\.jsonl$/);
+  return m ? m[1] : null;
+}
+async function loadCursorComposer(file2, raw, dbPath) {
+  const cid = composerIdFromFile(file2);
+  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 path9 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 path9.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 : path9.join(root, "state.vscdb");
+}
+var MACHINE_CURSOR_FILE_RE = /^(.*[/\\]machines[/\\][^/\\]+[/\\]\.cursor)[/\\]projects[/\\]/;
+function cursorDbPathForFile(file2) {
+  const m = file2.match(MACHINE_CURSOR_FILE_RE);
+  if (m)
+    return path9.join(m[1], "globalStorage", "state.vscdb");
+  return cursorGlobalDbPath();
+}
+
+// ../../lib/agents/coding/materialize.ts
+var SYSTEM_REMINDER_RE3 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
 var INJECT_GIST = 120;
 var INJECTED = [
   { re: /<task-notification>[\s\S]*?<\/task-notification>/g, label: "bg task", gistRe: /<summary>([\s\S]*?)<\/summary>/ },
@@ -15715,7 +16106,7 @@ function collapseInjected(input) {
       return "";
     });
   }
-  return { text: text2.replace(SYSTEM_REMINDER_RE2, "").trim(), markers };
+  return { text: text2.replace(SYSTEM_REMINDER_RE3, "").trim(), markers };
 }
 function extractText(content) {
   if (typeof content === "string") return content;
@@ -15731,14 +16122,52 @@ function extractText(content) {
 function isToolResultOnly(content) {
   return Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
 }
-var AI_GIST = 160;
+var AI_GIST2 = 160;
+function materializeCodex(raw) {
+  const lines = [];
+  let humanTurns = 0, humanChars = 0;
+  let aiLastProse = "";
+  const aiTools = /* @__PURE__ */ new Map();
+  const flushAI = () => {
+    if (!aiLastProse && aiTools.size === 0) return;
+    const tools = [...aiTools.entries()].map(([n, c]) => c > 1 ? `${n}\xD7${c}` : n).join(", ");
+    const gist = aiLastProse ? aiLastProse.length > AI_GIST2 ? aiLastProse.slice(0, AI_GIST2) + "\u2026" : aiLastProse : "";
+    const bits = [];
+    if (gist) bits.push(gist);
+    if (tools) bits.push(`ran ${tools}`);
+    lines.push(`[AI: ${bits.join(" \xB7 ")}]`);
+    aiLastProse = "";
+    aiTools.clear();
+  };
+  for (const ev of extractCodexEvents(raw)) {
+    if (ev.kind === "user") {
+      flushAI();
+      humanTurns++;
+      humanChars += ev.text.length;
+      lines.push(`>> ${ev.text}`);
+    } else if (ev.kind === "assistant") {
+      const prose = ev.text.replace(/\s+/g, " ").trim();
+      if (prose) aiLastProse = prose;
+    } else if (ev.kind === "tool") {
+      aiTools.set(ev.name, (aiTools.get(ev.name) ?? 0) + 1);
+    }
+  }
+  flushAI();
+  return { text: lines.join("\n"), humanTurns, humanChars };
+}
+async function materializeCursor(file2, raw) {
+  const composer = await loadCursorComposer(file2, raw, cursorDbPathForFile(file2));
+  return composer ? renderCursorTranscript(composer) : { text: "", humanTurns: 0, humanChars: 0 };
+}
 async function materializeSession(file2) {
   let raw;
   try {
-    raw = await fs4.readFile(file2, "utf-8");
+    raw = await fs5.readFile(file2, "utf-8");
   } catch {
     return null;
   }
+  if (sniffCodexRaw(raw)) return materializeCodex(raw);
+  if (sniffCursorRaw(raw)) return materializeCursor(file2, raw);
   const lines = [];
   let humanTurns = 0, humanChars = 0;
   const pendingQueued = [];
@@ -15751,7 +16180,7 @@ async function materializeSession(file2) {
   const flushAI = () => {
     if (!aiLastProse && aiTools.size === 0) return;
     const tools = [...aiTools.entries()].map(([n, c]) => c > 1 ? `${n}\xD7${c}` : n).join(", ");
-    const gist = aiLastProse ? aiLastProse.length > AI_GIST ? aiLastProse.slice(0, AI_GIST) + "\u2026" : aiLastProse : "";
+    const gist = aiLastProse ? aiLastProse.length > AI_GIST2 ? aiLastProse.slice(0, AI_GIST2) + "\u2026" : aiLastProse : "";
     const bits = [];
     if (gist) bits.push(gist);
     if (tools) bits.push(`ran ${tools}`);
@@ -15830,7 +16259,7 @@ async function materializeSession(file2) {
 }
 
 // ../coding-core/dist/delegation/parse.js
-import { promises as fs5 } from "fs";
+import { promises as fs6 } from "fs";
 var MUTATORS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 var INVESTIGATORS = /* @__PURE__ */ new Set(["Read", "Grep", "Glob", "Bash", "ToolSearch", "WebSearch", "WebFetch"]);
 var CORRECTIVE_RE = /\b(fix|still|again|nope?|broken|revert|undo|wrong|same (error|issue|thing|problem|bug)|doesn'?t work|not work(ing)?|didn'?t work|that'?s not|try (again|to)|no it|it'?s still|its still|stop|keeps?|why (is|isn'?t)|do (this|that|it)|make it)\b/i;
@@ -15865,13 +16294,93 @@ function countToolErrors(content) {
   }
   return n;
 }
+function newTurn(i, t, text2) {
+  const len = text2.length;
+  const deepDive = len >= DEEPDIVE_MIN_LEN || DEEPDIVE_RE.test(text2);
+  return {
+    i,
+    t,
+    text: text2,
+    len,
+    corrective: !deepDive && len <= CORRECTIVE_MAX_LEN && CORRECTIVE_RE.test(text2),
+    deepDive,
+    edits: 0,
+    editFiles: [],
+    investigations: 0,
+    toolErrors: 0,
+    aiStruggle: 0
+  };
+}
+function parseCodexTurns(raw) {
+  const turns = [];
+  let cur = null;
+  let idx = 0;
+  for (const ev of extractCodexEvents(raw)) {
+    if (ev.kind === "user") {
+      const text2 = humanTypedText(ev.text);
+      if (!text2)
+        continue;
+      cur = newTurn(idx++, Number.isFinite(ev.t) ? ev.t : cur ? cur.t : 0, text2);
+      turns.push(cur);
+    } else if (ev.kind === "tool" && cur) {
+      if (CODEX_MUTATORS.has(ev.name)) {
+        cur.edits++;
+        for (const f of codexPatchFiles(ev.input))
+          if (!cur.editFiles.includes(f))
+            cur.editFiles.push(f);
+      } else if (CODEX_INVESTIGATORS.has(ev.name)) {
+        cur.investigations++;
+      }
+    } else if (ev.kind === "tool_output" && cur) {
+      if (ev.isError)
+        cur.toolErrors++;
+    } else if (ev.kind === "assistant" && cur) {
+      if (STRUGGLE_RE.test(ev.text))
+        cur.aiStruggle++;
+    }
+  }
+  return turns;
+}
+var CURSOR_MUTATOR_RE = /edit|write|replace|delete|patch|reapply|create/i;
+var CURSOR_INVESTIGATOR_RE = /read|search|grep|list|terminal|glob|fetch|run/i;
+async function parseCursorTurns(file2, raw) {
+  const c = await loadCursorComposer(file2, raw, cursorDbPathForFile(file2));
+  if (!c)
+    return [];
+  const turns = [];
+  let cur = null;
+  let idx = 0;
+  for (const turn of c.turns) {
+    if (turn.type === 1) {
+      const text2 = humanTypedText(turn.text);
+      if (!text2)
+        continue;
+      cur = newTurn(idx++, turn.t, text2);
+      turns.push(cur);
+    } else if (cur) {
+      if (turn.tool) {
+        if (CURSOR_MUTATOR_RE.test(turn.tool))
+          cur.edits++;
+        else if (CURSOR_INVESTIGATOR_RE.test(turn.tool))
+          cur.investigations++;
+      }
+      if (turn.text && STRUGGLE_RE.test(turn.text))
+        cur.aiStruggle++;
+    }
+  }
+  return turns;
+}
 async function parseSession(file2) {
   let raw;
   try {
-    raw = await fs5.readFile(file2, "utf-8");
+    raw = await fs6.readFile(file2, "utf-8");
   } catch {
     return [];
   }
+  if (sniffCodexRaw(raw))
+    return parseCodexTurns(raw);
+  if (sniffCursorRaw(raw))
+    return parseCursorTurns(file2, raw);
   const turns = [];
   let cur = null;
   let idx = 0;
@@ -15898,21 +16407,7 @@ async function parseSession(file2) {
       const text2 = humanTypedText(extractText2(content));
       if (!text2)
         continue;
-      const len = text2.length;
-      const deepDive = len >= DEEPDIVE_MIN_LEN || DEEPDIVE_RE.test(text2);
-      cur = {
-        i: idx++,
-        t: Number.isFinite(ts) ? ts : cur ? cur.t : 0,
-        text: text2,
-        len,
-        corrective: !deepDive && len <= CORRECTIVE_MAX_LEN && CORRECTIVE_RE.test(text2),
-        deepDive,
-        edits: 0,
-        editFiles: [],
-        investigations: 0,
-        toolErrors: 0,
-        aiStruggle: 0
-      };
+      cur = newTurn(idx++, Number.isFinite(ts) ? ts : cur ? cur.t : 0, text2);
       turns.push(cur);
     } else if (e.type === "assistant" && cur) {
       const msg = e.message ?? {};
@@ -16078,7 +16573,7 @@ async function detectDelegation(rec, opts = {}) {
   let meta = {};
   if (candidates.length > 0) {
     const mat = await materializeSession(rec.file);
-    const sandbox = await fs6.mkdtemp(path9.join(os2.tmpdir(), "ps-deleg-"));
+    const sandbox = await fs7.mkdtemp(path10.join(os3.tmpdir(), "ps-deleg-"));
     try {
       const run2 = await invokeAgent({
         prompt: buildPrompt(rec, mat?.text ?? "", candidates),
@@ -16088,7 +16583,7 @@ async function detectDelegation(rec, opts = {}) {
         maxTurns: 6,
         timeoutMs: 3e5,
         model: opts.model ?? "sonnet",
-        logPath: opts.logDir ? path9.join(opts.logDir, `${rec.sessionId}.log`) : void 0
+        logPath: opts.logDir ? path10.join(opts.logDir, `${rec.sessionId}.log`) : void 0
       });
       const j = run2.json ?? {};
       context = String(j.context ?? "").slice(0, 900);
@@ -16104,7 +16599,7 @@ async function detectDelegation(rec, opts = {}) {
       }).filter((l) => l.confirmed);
       meta = { costUsd: run2.costUsd, durationMs: run2.durationMs };
     } finally {
-      await fs6.rm(sandbox, { recursive: true, force: true }).catch(() => {
+      await fs7.rm(sandbox, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -16120,16 +16615,16 @@ async function detectDelegation(rec, opts = {}) {
     meta
   };
   if (opts.outDir) {
-    await fs6.mkdir(opts.outDir, { recursive: true });
-    await fs6.writeFile(path9.join(opts.outDir, `${rec.sessionId}.json`), JSON.stringify(read, null, 2));
+    await fs7.mkdir(opts.outDir, { recursive: true });
+    await fs7.writeFile(path10.join(opts.outDir, `${rec.sessionId}.json`), JSON.stringify(read, null, 2));
   }
   return read;
 }
 
 // ../../lib/agents/coding/delegation/rollup.ts
-import { promises as fs7 } from "fs";
-import os3 from "os";
-import path10 from "path";
+import { promises as fs8 } from "fs";
+import os4 from "os";
+import path11 from "path";
 var median2 = (xs) => {
   if (!xs.length) return 0;
   const s = [...xs].sort((a, b) => a - b);
@@ -16185,7 +16680,7 @@ async function rollupDelegation(reads, records, opts = {}) {
     }
     const exemplars = ranked.map((r) => ({ sessionId: r.sessionId, title: r.title, openingChars: r.overDrive.openingChars }));
     if (samples.length) {
-      const sandbox = await fs7.mkdtemp(path10.join(os3.tmpdir(), "ps-deleg-roll-"));
+      const sandbox = await fs8.mkdtemp(path11.join(os4.tmpdir(), "ps-deleg-roll-"));
       try {
         const run2 = await invokeAgent({
           prompt: buildPrompt2(samples),
@@ -16206,7 +16701,7 @@ async function rollupDelegation(reads, records, opts = {}) {
           exemplars
         };
       } finally {
-        await fs7.rm(sandbox, { recursive: true, force: true }).catch(() => {
+        await fs8.rm(sandbox, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -16267,7 +16762,7 @@ function aiWindowCutoff(sessions, opts = {}) {
 
 // ../../lib/agents/coding/promptCache.ts
 import { createHash } from "crypto";
-import { promises as fs8 } from "fs";
+import { promises as fs9 } from "fs";
 function promptSha(parts) {
   const h = createHash("sha256");
   for (const p of parts) {
@@ -16278,7 +16773,7 @@ function promptSha(parts) {
 }
 async function reusableOutput(outPath, sha, valid, key = "promptSha") {
   try {
-    const o = JSON.parse(await fs8.readFile(outPath, "utf8"));
+    const o = JSON.parse(await fs9.readFile(outPath, "utf8"));
     if (o[key] === sha && valid(o)) return o;
   } catch {
   }
@@ -16286,7 +16781,7 @@ async function reusableOutput(outPath, sha, valid, key = "promptSha") {
 }
 
 // ../../lib/agents/coding/profile.ts
-import path11 from "path";
+import path12 from "path";
 
 // ../../lib/calibration/fingerprint.ts
 import { createHash as createHash2 } from "node:crypto";
@@ -16440,7 +16935,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).
@@ -16536,13 +17031,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,
@@ -16591,8 +17087,8 @@ var BEST = DEFAULT_CALIBRATION.codingBenchmarks;
 
 // ../../lib/agents/coding/profile.ts
 var ROOT = process.cwd();
-var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path11.join(process.env.POLYMATH_DATA_DIR, "coding") : path11.join(ROOT, ".data", "coding");
-var GRADES = path11.join(CODING_DIR, "grades");
+var CODING_DIR = process.env.POLYMATH_DATA_DIR ? path12.join(process.env.POLYMATH_DATA_DIR, "coding") : path12.join(ROOT, ".data", "coding");
+var GRADES = path12.join(CODING_DIR, "grades");
 
 // ../../scripts/coding-delegation.mts
 var argv = process.argv.slice(2);
@@ -16620,10 +17116,10 @@ function makeLimiter(max) {
   };
 }
 var CODING = CODING_DIR;
-var OUT = path12.join(CODING, "delegation");
-var LOGS = path12.join(OUT, "logs");
+var OUT = path13.join(CODING, "delegation");
+var LOGS = path13.join(OUT, "logs");
 async function main() {
-  const sessions = JSON.parse(await fs9.readFile(path12.join(CODING, "sessions.json"), "utf8"));
+  const sessions = JSON.parse(await fs10.readFile(path13.join(CODING, "sessions.json"), "utf8"));
   const live = sessions.filter((s) => s.klass === "interactive" && !s.duplicateOf);
   const { gradable: allGradable } = partition(live);
   const cutoff = aiWindowCutoff(live);
@@ -16633,7 +17129,7 @@ async function main() {
     const set = new Set(IDS);
     picked = live.filter((s) => set.has(s.sessionId));
   } else if (N > 0) picked = gradable.slice().sort((a, b) => b.humanChars * Math.log1p(b.humanTurns) - a.humanChars * Math.log1p(a.humanTurns)).slice(0, N);
-  await fs9.mkdir(LOGS, { recursive: true });
+  await fs10.mkdir(LOGS, { recursive: true });
   console.log(`[delegation] ${live.length} live \xB7 ${allGradable.length} gradable${cutoff ? ` \xB7 ${gradable.length} since ${cutoff.slice(0, 10)} (AI window)` : ""} \xB7 running detect on ${picked.length} (LLM only on stuck-loop candidates)\u2026`);
   const lim = makeLimiter(CONC);
   let reused = 0;
@@ -16641,7 +17137,7 @@ async function main() {
   const reads = (await Promise.all(picked.map((s) => lim(async () => {
     if (!REFRESH) {
       try {
-        const prev = JSON.parse(await fs9.readFile(path12.join(OUT, `${s.sessionId}.json`), "utf8"));
+        const prev = JSON.parse(await fs10.readFile(path13.join(OUT, `${s.sessionId}.json`), "utf8"));
         reused++;
         tick(true);
         return prev;
@@ -16663,13 +17159,13 @@ async function main() {
   if (reused) console.log(`[delegation] reused ${reused} existing per-session read(s) (--refresh to re-detect)`);
   const stable = reads.map((r) => ({ id: r.sessionId, loops: r.stuckLoops, od: r.overDrive })).sort((a, b) => a.id < b.id ? -1 : 1);
   const sha = promptSha([JSON.stringify(stable), MODEL]);
-  const rollupPath = path12.join(CODING, "delegation-rollup.json");
+  const rollupPath = path13.join(CODING, "delegation-rollup.json");
   let rollup = REFRESH ? null : await reusableOutput(rollupPath, sha, (o) => typeof o.sessions === "number");
   if (rollup) console.log(`[delegation] rollup inputs unchanged \u2014 reusing (--refresh to regenerate)`);
   else {
     console.log(`[delegation] corpus rollup (Case A count + Case B over-drive judgment)\u2026`);
     rollup = { ...await rollupDelegation(reads, live, { model: MODEL }), promptSha: sha };
-    await fs9.writeFile(rollupPath, JSON.stringify(rollup, null, 2));
+    await fs10.writeFile(rollupPath, JSON.stringify(rollup, null, 2));
   }
   console.log(`
 \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 DELEGATION \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);