polymath-society 0.2.19 → 0.2.21

package/dist/pipeline/coding-focus.js

@@ -134,7 +134,7 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-focus.mts
-import { promises as fs6 } from "fs";
+import { promises as fs8 } from "fs";
 
 // ../../lib/agents/coding/promptCache.ts
 import { createHash } from "crypto";
@@ -147,8 +147,55 @@ function promptSha(parts) {
   return h.digest("hex").slice(0, 16);
 }
 
+// ../../lib/agents/coding/stageLock.ts
+import { promises as fs } from "fs";
+var STALE_UNKNOWN_MS = 12 * 60 * 60 * 1e3;
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+async function acquireStageLock(lockPath, stage) {
+  const mine = String(process.pid);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      await fs.writeFile(lockPath, mine, { flag: "wx" });
+      return async () => {
+        const held = await fs.readFile(lockPath, "utf8").catch(() => null);
+        if (held === mine) await fs.unlink(lockPath).catch(() => {
+        });
+      };
+    } catch {
+      const raw = (await fs.readFile(lockPath, "utf8").catch(() => "")).trim();
+      const pid = /^\d{1,9}$/.test(raw) ? Number(raw) : null;
+      if (pid != null && pidAlive(pid)) {
+        throw new Error(
+          `another ${stage} run is ACTIVE (pid ${pid} is alive, ${lockPath}) \u2014 concurrent runs overwrite each other's output. Wait for it to finish.`
+        );
+      }
+      if (pid == null) {
+        const age = Date.now() - (await fs.stat(lockPath).catch(() => null))?.mtimeMs;
+        if (!(age > STALE_UNKNOWN_MS)) {
+          throw new Error(
+            `a ${stage} lock exists with an unreadable holder (${lockPath}, ${Math.round(age / 6e4)}m old) \u2014 not old enough to declare stale. Wait, or delete it if you know the run is gone.`
+          );
+        }
+      }
+      console.warn(
+        `[${stage}] stale lock from ${pid != null ? `dead pid ${pid}` : "an unreadable holder"} \u2014 removing it and proceeding (a crashed run must never strand the next one)`
+      );
+      await fs.unlink(lockPath).catch(() => {
+      });
+    }
+  }
+  throw new Error(`could not acquire the ${stage} lock (${lockPath}) \u2014 another run raced the stale takeover`);
+}
+
 // ../../scripts/coding-focus.mts
-import path10 from "path";
+import path11 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -156,7 +203,7 @@ import path8 from "path";
 
 // ../../lib/agents/shared/cliAdapter.ts
 import { spawn } from "child_process";
-import { promises as fs2 } from "fs";
+import { promises as fs3 } from "fs";
 import path2 from "path";
 
 // ../coding-core/dist/env.js
@@ -200,7 +247,7 @@ function extractJson(text2) {
 }
 
 // ../../lib/agents/shared/toolLog.ts
-import { promises as fs } from "fs";
+import { promises as fs2 } from "fs";
 import path from "path";
 async function writeToolLog(logPath, d) {
   const counts = {};
@@ -217,8 +264,8 @@ async function writeToolLog(logPath, d) {
   L.push(``);
   L.push(`## Full call sequence (${d.toolCalls.length})`);
   d.toolCalls.forEach((c, i) => L.push(`  ${String(i + 1).padStart(3, "0")}  ${c.tool.padEnd(5)}  ${c.target}`));
-  await fs.mkdir(path.dirname(logPath), { recursive: true });
-  await fs.writeFile(logPath, L.join("\n"), "utf-8");
+  await fs2.mkdir(path.dirname(logPath), { recursive: true });
+  await fs2.writeFile(logPath, L.join("\n"), "utf-8");
   const json = {
     roots: d.roots,
     toolCounts: counts,
@@ -228,7 +275,7 @@ async function writeToolLog(logPath, d) {
     filesRead: d.filesRead,
     callSequence: d.toolCalls
   };
-  await fs.writeFile(logPath.replace(/\.log$/, ".json"), JSON.stringify(json, null, 2), "utf-8");
+  await fs2.writeFile(logPath.replace(/\.log$/, ".json"), JSON.stringify(json, null, 2), "utf-8");
 }
 
 // ../../lib/agents/shared/cliAdapter.ts
@@ -237,8 +284,8 @@ var USAGE_LEDGER = () => path2.join(process.env.POLYMATH_DATA_DIR ? path2.resolv
 async function appendUsageLedger(line) {
   try {
     const f = USAGE_LEDGER();
-    await fs2.mkdir(path2.dirname(f), { recursive: true });
-    await fs2.appendFile(f, JSON.stringify(line) + "\n", "utf8");
+    await fs3.mkdir(path2.dirname(f), { recursive: true });
+    await fs3.appendFile(f, JSON.stringify(line) + "\n", "utf8");
   } catch {
   }
 }
@@ -516,6 +563,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>
@@ -556,7 +610,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 = [];
@@ -2184,8 +2238,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path12, errorMaps, issueData } = params;
+  const fullPath = [...path12, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2301,11 +2355,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path12, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path12;
     this._key = key;
   }
   get path() {
@@ -15092,39 +15146,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path11 }) => `${baseURL}${path11}`,
+    url: ({ path: path12 }) => `${baseURL}${path12}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -15145,7 +15199,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path11 }) => `${baseURL}${path11}`,
+      url: ({ path: path12 }) => `${baseURL}${path12}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -15175,7 +15229,7 @@ var openai = createOpenAI({
 });
 
 // ../../lib/agents/shared/tools.ts
-import { promises as fs3 } from "fs";
+import { promises as fs4 } from "fs";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import path5 from "path";
@@ -15195,7 +15249,7 @@ function fileTools(root) {
       parameters: external_exports.object({ path: external_exports.string().describe("dir path relative to source root") }),
       execute: async ({ path: p }) => {
         const dir = safeResolve(root, p);
-        const entries = await fs3.readdir(dir, { withFileTypes: true });
+        const entries = await fs4.readdir(dir, { withFileTypes: true });
         return entries.filter((e) => !e.name.startsWith(".git") && e.name !== ".obsidian").map((e) => e.isDirectory() ? `${e.name}/` : e.name).slice(0, 500).join("\n");
       }
     }),
@@ -15208,7 +15262,7 @@ function fileTools(root) {
       }),
       execute: async ({ path: p, offset = 0, limit = 600 }) => {
         const file2 = safeResolve(root, p);
-        const text2 = await fs3.readFile(file2, "utf-8");
+        const text2 = await fs4.readFile(file2, "utf-8");
         const lines = text2.split("\n");
         return lines.slice(offset, offset + limit).join("\n").slice(0, 6e4);
       }
@@ -15642,7 +15696,7 @@ function invokeAgent(inv, opts = {}) {
 }
 
 // ../coding-core/dist/messages.js
-import { promises as fs4 } from "fs";
+import { promises as fs6 } from "fs";
 
 // ../coding-core/dist/injected.js
 var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -15677,6 +15731,365 @@ function isHarnessEntry(e) {
   return e.isMeta === true || e.isCompactSummary === true;
 }
 
+// ../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;
+}
+
+// ../coding-core/dist/cursor.js
+import { promises as fs5 } from "fs";
+var NODE_SQLITE = "node:sqlite";
+async function openCursorSqlite(dbPath) {
+  try {
+    await fs5.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 };
+}
+function cursorMessages(c) {
+  const out = [];
+  let aiStart = 0;
+  let aiParts = [];
+  const flushAI = () => {
+    if (!aiParts.length)
+      return;
+    out.push({ t: aiStart, role: "ai", text: aiParts.join("\n") });
+    aiParts = [];
+  };
+  for (const turn of c.turns) {
+    if (turn.type === 1) {
+      flushAI();
+      out.push({ t: turn.t, role: "user", text: turn.text });
+    } else {
+      if (aiParts.length === 0)
+        aiStart = turn.t;
+      if (turn.text)
+        aiParts.push(turn.text);
+    }
+  }
+  flushAI();
+  return out;
+}
+function composerIdFromFile(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();
+}
+
 // ../coding-core/dist/messages.js
 function extractText(content) {
   if (typeof content === "string")
@@ -15688,13 +16101,62 @@ function extractText(content) {
 function isToolResultOnly(content) {
   return Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
 }
+function extractMessagesCodex(raw) {
+  const out = [];
+  let aiProse = [];
+  let aiTools = {};
+  let aiStart = 0;
+  const flushAI = () => {
+    if (!aiProse.length && Object.keys(aiTools).length === 0)
+      return;
+    const toolStr = Object.entries(aiTools).map(([n, c]) => c > 1 ? `${n}\xD7${c}` : n).join(", ");
+    let prose = aiProse.join(" ").replace(/\s+/g, " ").trim();
+    if (prose.length > 2200)
+      prose = prose.slice(0, 2200) + "\u2026";
+    let text2 = prose;
+    if (toolStr)
+      text2 = (text2 ? text2 + " " : "") + `[ran ${toolStr}]`;
+    if (text2)
+      out.push({ t: aiStart, role: "ai", text: text2 });
+    aiProse = [];
+    aiTools = {};
+  };
+  for (const ev of extractCodexEvents(raw)) {
+    if (!Number.isFinite(ev.t))
+      continue;
+    if (ev.kind === "user") {
+      const text2 = humanTypedText(ev.text);
+      if (text2) {
+        flushAI();
+        out.push({ t: ev.t, role: "user", text: text2 });
+      }
+    } else if (ev.kind === "assistant") {
+      if (!aiProse.length && Object.keys(aiTools).length === 0)
+        aiStart = ev.t;
+      if (ev.text)
+        aiProse.push(ev.text);
+    } else if (ev.kind === "tool") {
+      if (!aiProse.length && Object.keys(aiTools).length === 0)
+        aiStart = ev.t;
+      aiTools[ev.name] = (aiTools[ev.name] ?? 0) + 1;
+    }
+  }
+  flushAI();
+  return out.sort((a, b) => a.t - b.t);
+}
 async function extractMessages(file2) {
   let raw;
   try {
-    raw = await fs4.readFile(file2, "utf-8");
+    raw = await fs6.readFile(file2, "utf-8");
   } catch {
     return [];
   }
+  if (sniffCodexRaw(raw))
+    return extractMessagesCodex(raw);
+  if (sniffCursorRaw(raw)) {
+    const c = await loadCursorComposer(file2, raw, cursorDbPathForFile(file2));
+    return c ? cursorMessages(c) : [];
+  }
   const out = [];
   const userTexts = /* @__PURE__ */ new Set();
   const seenUuids = /* @__PURE__ */ new Set();
@@ -15780,20 +16242,20 @@ async function extractMessages(file2) {
 }
 
 // ../../lib/agents/coding/assets.ts
-import { promises as fs5 } from "fs";
-import path9 from "path";
+import { promises as fs7 } from "fs";
+import path10 from "path";
 import { fileURLToPath } from "url";
-var MODULE_DIR = path9.dirname(fileURLToPath(import.meta.url));
+var MODULE_DIR = path10.dirname(fileURLToPath(import.meta.url));
 async function readCodingAsset(name17) {
   const candidates = [
-    path9.join(MODULE_DIR, name17),
+    path10.join(MODULE_DIR, name17),
     // dev: beside this file · bundled: beside the bundle
-    path9.resolve("lib", "agents", "coding", name17)
+    path10.resolve("lib", "agents", "coding", name17)
     // legacy cwd-relative (repo-root cwd)
   ];
   for (const p of candidates) {
     try {
-      return { text: await fs5.readFile(p, "utf8"), path: p };
+      return { text: await fs7.readFile(p, "utf8"), path: p };
     } catch {
     }
   }
@@ -15869,7 +16331,7 @@ var CELL_MIN = 30;
 var CELLS = 48;
 var GAP_MIN = 45;
 if (process.argv.includes("--skip-llm")) process.env.FOCUS_SKIP_LLM = "1";
-var CODING = path10.join(process.env.POLYMATH_DATA_DIR || path10.join(process.cwd(), ".data"), "coding");
+var CODING = path11.join(process.env.POLYMATH_DATA_DIR || path11.join(process.cwd(), ".data"), "coding");
 var ld = (t) => new Date(t).toLocaleDateString("en-CA", { timeZone: TZ });
 var DAY_START_MIN = 4 * 60;
 var dayKey = (t) => ld(t - DAY_START_MIN * 6e4);
@@ -15968,29 +16430,23 @@ function parseModelJson(raw) {
   }
 }
 async function main() {
-  const LOCK = path10.join(CODING, ".focus.lock");
-  try {
-    await fs6.writeFile(LOCK, String(process.pid), { flag: "wx" });
-  } catch {
-    throw new Error(`another coding-focus run appears active (${LOCK}); delete only if stale`);
-  }
+  const release = await acquireStageLock(path11.join(CODING, ".focus.lock"), "coding-focus");
   try {
     await run2();
   } finally {
-    await fs6.unlink(LOCK).catch(() => {
-    });
+    await release();
   }
 }
 async function run2() {
-  const sess = JSON.parse(await fs6.readFile(path10.join(CODING, "sessions.json"), "utf8")).filter((s) => s.klass === "interactive" && !s.duplicateOf);
-  const CACHE = path10.join(CODING, ".msg-cache.json");
-  const cache = JSON.parse(await fs6.readFile(CACHE, "utf8").catch(() => "{}"));
+  const sess = JSON.parse(await fs8.readFile(path11.join(CODING, "sessions.json"), "utf8")).filter((s) => s.klass === "interactive" && !s.duplicateOf);
+  const CACHE = path11.join(CODING, ".msg-cache.json");
+  const cache = JSON.parse(await fs8.readFile(CACHE, "utf8").catch(() => "{}"));
   let hits = 0, misses = 0;
   const byDay = /* @__PURE__ */ new Map();
   const sessInfo = /* @__PURE__ */ new Map();
   for (const s of sess) {
     let meta;
-    const st = await fs6.stat(s.file).catch(() => null);
+    const st = await fs8.stat(s.file).catch(() => null);
     if (!st) continue;
     const key = `${Math.round(st.mtimeMs)}:${st.size}`;
     const hit = cache[s.sessionId];
@@ -16038,15 +16494,15 @@ async function run2() {
   }
   if (dropped + deduped > 0) console.log(`focus: cleaned typed stream \u2014 ${dropped} template/loop msgs dropped \xB7 ${deduped} fork copies deduped`);
   if (!byDay.size) throw new Error("focus: zero typed messages extracted \u2014 refusing to write an empty focus.json");
-  await fs6.writeFile(CACHE, JSON.stringify(cache));
+  await fs8.writeFile(CACHE, JSON.stringify(cache));
   console.log(`focus: msg-cache ${hits} hits \xB7 ${misses} parsed fresh`);
-  const chart = JSON.parse(await fs6.readFile(path10.join(CODING, "day-chart.json"), "utf8").catch(() => "[]"));
+  const chart = JSON.parse(await fs8.readFile(path11.join(CODING, "day-chart.json"), "utf8").catch(() => "[]"));
   const sidDayMin = /* @__PURE__ */ new Map();
   for (const day of chart) for (const c of day.conversations) {
     const m = sidDayMin.get(c.sessionId) ?? sidDayMin.set(c.sessionId, /* @__PURE__ */ new Map()).get(c.sessionId);
     m.set(day.date, (m.get(day.date) ?? 0) + c.intervals.reduce((a, [x, y]) => a + (y - x) / 6e4, 0));
   }
-  const digest = JSON.parse(await fs6.readFile(path10.join(CODING, "day-digest.json"), "utf8").catch(() => "{}"));
+  const digest = JSON.parse(await fs8.readFile(path11.join(CODING, "day-digest.json"), "utf8").catch(() => "{}"));
   const sidSummary = /* @__PURE__ */ new Map();
   for (const day of digest.days ?? []) for (const c of day.conversations ?? []) if (c.summary) sidSummary.set(c.sessionId, c.summary);
   const days = [], boundaries = [], gaps = [];
@@ -16195,7 +16651,7 @@ async function run2() {
     gaps: gaps.slice(-60),
     llm: null
   };
-  const prev = JSON.parse(await fs6.readFile(path10.join(CODING, "focus.json"), "utf8").catch(() => "null"));
+  const prev = JSON.parse(await fs8.readFile(path11.join(CODING, "focus.json"), "utf8").catch(() => "null"));
   if (!process.env.FOCUS_SKIP_LLM && !process.env.FOCUS_SKIP_CLUSTER) {
     const recentDates = new Set(days.slice(-30).map((d) => d.date));
     const recentSess = [...sessInfo.values()].filter((s) => [...s.byDate.keys()].some((d) => recentDates.has(d)) && s.all >= 2);
@@ -16325,11 +16781,11 @@ Return STRICT JSON only: {"bullets":["3-5 personalized bullets"],"skillMd":"the
     out.llm.accountability = prev.llm.accountability;
     console.log("focus: carrying previous accountability forward");
   }
-  await fs6.writeFile(path10.join(CODING, "focus.json"), JSON.stringify(out, null, 2));
+  await fs8.writeFile(path11.join(CODING, "focus.json"), JSON.stringify(out, null, 2));
   const h = (m) => (m / 60).toFixed(1) + "h";
   console.log(`wrote .data/coding/focus.json \u2014 ${days.length} days \xB7 steering ${h(out.totals.steeringMin)} \xB7 nudging ${h(out.totals.nudgingMin)} \xB7 silent-in-span ${h(out.totals.silentMin)} \xB7 ${workstreams.length} workstreams \xB7 llm ${out.llm ? "ok" : "none"}`);
 }
-var isMain = process.argv[1] && path10.resolve(process.argv[1]).includes("coding-focus");
+var isMain = process.argv[1] && path11.resolve(process.argv[1]).includes("coding-focus");
 if (isMain) main().catch((e) => {
   console.error(e);
   process.exit(1);