polymath-society 0.2.4

package/dist/engine/ingest-export.js

@@ -0,0 +1,1423 @@
+import{createRequire as __cr}from'module';const require=__cr(import.meta.url);
+
+// ../../lib/onboarding/retrieval/manual.ts
+import { promises as fs8 } from "fs";
+import os4 from "os";
+import path10 from "path";
+
+// ../../lib/onboarding/state.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import crypto from "crypto";
+
+// ../../lib/store.ts
+import { promises as fs } from "fs";
+import path from "path";
+var DATA_DIR = process.env.POLYMATH_DATA_DIR ? path.resolve(process.env.POLYMATH_DATA_DIR) : path.join(process.cwd(), ".data");
+var IMPORTED_DIR = path.join(DATA_DIR, "imported");
+var PROFILE_FILE = path.join(DATA_DIR, "profile.json");
+var ENTRIES_FILE = path.join(DATA_DIR, "entries.json");
+var CONNECTIONS_FILE = path.join(DATA_DIR, "connections.json");
+var EVAL_FILE = path.join(DATA_DIR, "evaluation.json");
+var ENGINE_FILE = path.join(DATA_DIR, "engine.json");
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+async function readJSON(file2, fallback) {
+  try {
+    return JSON.parse(await fs.readFile(file2, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+async function writeJSON(file2, data) {
+  await ensureDir(path.dirname(file2));
+  await fs.writeFile(file2, JSON.stringify(data, null, 2), "utf-8");
+}
+async function getProfile() {
+  return readJSON(PROFILE_FILE, null);
+}
+async function getEntries() {
+  return readJSON(ENTRIES_FILE, []);
+}
+async function getConnections() {
+  return readJSON(CONNECTIONS_FILE, {});
+}
+async function setConnection(id, patch) {
+  const conns = await getConnections();
+  const existing = conns[id] || { id, connected: false, lastSync: null, eventCount: 0, available: true };
+  const next = { ...existing, ...patch, id };
+  conns[id] = next;
+  await writeJSON(CONNECTIONS_FILE, conns);
+  return next;
+}
+async function saveImported(id, events, fileKey) {
+  await writeJSON(path.join(IMPORTED_DIR, `${fileKey ?? id}.json`), events);
+}
+async function getImported(id, fileKey) {
+  return readJSON(path.join(IMPORTED_DIR, `${fileKey ?? id}.json`), []);
+}
+async function removeImported(fileKey) {
+  await fs.unlink(path.join(IMPORTED_DIR, `${fileKey}.json`)).catch(() => {
+  });
+}
+async function recordImport(id, imp) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!imp.account) {
+    await saveImported(id, imp.events);
+    return setConnection(id, {
+      // GUARD: "connected" means content actually came in. A Notion export once
+      // imported 0 notes and still showed "Synced" — an empty import must read
+      // as NOT connected so the failure is visible, never as a green pill.
+      connected: imp.events.length > 0,
+      lastSync: now,
+      eventCount: imp.events.length,
+      files: imp.files,
+      root: imp.root,
+      ...imp.archive ? { archive: imp.archive } : {},
+      ...imp.conversations != null ? { conversations: imp.conversations } : {},
+      available: true
+    });
+  }
+  await saveImported(id, imp.events, `${id}.acct-${imp.account.id}`);
+  const cur = (await getConnections())[id];
+  let accounts = [...cur?.accounts ?? []];
+  const legacy = await getImported(id);
+  if (legacy.length) {
+    const ids = new Set(imp.events.map((e) => e.id));
+    const overlap = legacy.reduce((n, e) => n + (ids.has(e.id) ? 1 : 0), 0);
+    if (overlap >= 0.25 * Math.min(legacy.length, imp.events.length)) {
+      await removeImported(id);
+      accounts = accounts.filter((a) => a.id !== "legacy");
+    } else if (!accounts.some((a) => a.id === "legacy")) {
+      accounts.push({
+        id: "legacy",
+        label: "earlier import",
+        eventCount: legacy.length,
+        lastSync: cur?.lastSync ?? null,
+        ...cur?.conversations != null ? { conversations: cur.conversations } : {},
+        ...cur?.archive ? { archive: cur.archive } : {},
+        files: cur?.files,
+        root: cur?.root
+      });
+    }
+  } else {
+    accounts = accounts.filter((a) => a.id !== "legacy");
+  }
+  const entry = {
+    id: imp.account.id,
+    label: imp.account.label,
+    eventCount: imp.events.length,
+    ...imp.conversations != null ? { conversations: imp.conversations } : {},
+    ...imp.archive ? { archive: imp.archive } : {},
+    lastSync: now,
+    files: imp.files,
+    root: imp.root
+  };
+  accounts = [...accounts.filter((a) => a.id !== entry.id), entry];
+  return setConnection(id, {
+    // Same guard as the single-slot path: no content, no "connected".
+    connected: accounts.some((a) => a.eventCount > 0),
+    lastSync: now,
+    eventCount: accounts.reduce((s, a) => s + a.eventCount, 0),
+    conversations: accounts.reduce((s, a) => s + (a.conversations ?? 0), 0),
+    files: accounts.flatMap((a) => a.files ?? []),
+    root: imp.root,
+    ...imp.archive ? { archive: imp.archive } : {},
+    accounts,
+    available: true
+  });
+}
+async function getAllImported() {
+  let names = [];
+  try {
+    names = (await fs.readdir(IMPORTED_DIR)).filter((n) => n.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const all = [];
+  for (const n of names) {
+    all.push(...await readJSON(path.join(IMPORTED_DIR, n), []));
+  }
+  return all;
+}
+async function saveEvaluation(e) {
+  await writeJSON(EVAL_FILE, e);
+}
+
+// ../../lib/onboarding/state.ts
+var ONBOARDING_DIR = path2.join(DATA_DIR, "onboarding");
+var STATE_FILE = path2.join(ONBOARDING_DIR, "state.json");
+var DIGEST_DIR = path2.join(ONBOARDING_DIR, "digest");
+var EXPORTS_DIR = path2.join(ONBOARDING_DIR, "exports");
+function empty() {
+  return {
+    glimpse: null,
+    enrichment: null,
+    detected: [],
+    jobs: [],
+    computerPermissionGrantedAt: null,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function getState() {
+  try {
+    return JSON.parse(await fs2.readFile(STATE_FILE, "utf-8"));
+  } catch {
+    return empty();
+  }
+}
+async function writeState(s) {
+  s.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await fs2.mkdir(ONBOARDING_DIR, { recursive: true });
+  await fs2.writeFile(STATE_FILE, JSON.stringify(s, null, 2), "utf-8");
+  return s;
+}
+function newJobId() {
+  return crypto.randomUUID();
+}
+async function upsertJob(job) {
+  const s = await getState();
+  const i = s.jobs.findIndex((j) => j.id === job.id);
+  job.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (i >= 0) s.jobs[i] = job;
+  else s.jobs.push(job);
+  await writeState(s);
+  return job;
+}
+async function patchJob(id, patch) {
+  const s = await getState();
+  const i = s.jobs.findIndex((j) => j.id === id);
+  if (i < 0) return null;
+  s.jobs[i] = { ...s.jobs[i], ...patch, id, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await writeState(s);
+  return s.jobs[i];
+}
+async function createJob(source) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const job = {
+    id: newJobId(),
+    source,
+    stage: "requested",
+    requestedAt: now,
+    updatedAt: now
+  };
+  return upsertJob(job);
+}
+
+// ../../lib/connectors/fileImport.ts
+import { promises as fs4 } from "fs";
+import path5 from "path";
+import os from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// ../../lib/connectors/util.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import crypto2 from "crypto";
+function sha16(obj) {
+  return crypto2.createHash("sha256").update(typeof obj === "string" ? obj : JSON.stringify(obj)).digest("hex").slice(0, 16);
+}
+function isExcluded(file2, excluded) {
+  if (!excluded || excluded.length === 0) return false;
+  for (const ex of excluded) {
+    if (file2 === ex) return true;
+    if (file2.startsWith(ex.endsWith(path3.sep) ? ex : ex + path3.sep)) return true;
+  }
+  return false;
+}
+async function walk(dir, ext) {
+  let out = [];
+  let entries;
+  try {
+    entries = await fs3.readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const full = path3.join(dir, e.name);
+    if (e.isDirectory()) {
+      out = out.concat(await walk(full, ext));
+    } else if (e.isFile() && e.name.endsWith(ext)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+// ../../lib/agents/shared/worklist.ts
+import path4 from "path";
+var MONTHS = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+function inferDate(relPath) {
+  const segs = relPath.split(path4.sep);
+  let year = 0;
+  let month = 0;
+  let day = 0;
+  for (const seg of segs) {
+    const y = seg.match(/(20\d{2})/);
+    if (y) year = Math.max(year, Number(y[1]));
+    const mNum = seg.match(/^(\d{1,2})\s*[-–]\s*[A-Za-z]/);
+    if (mNum) {
+      const m = Number(mNum[1]);
+      if (m >= 1 && m <= 12) month = m;
+    }
+    const mName = seg.toLowerCase().match(/\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/);
+    if (mName && !month) month = MONTHS[mName[1]];
+  }
+  const last = segs[segs.length - 1].replace(/\.md$/i, "");
+  const pair = last.match(/^(\d{1,2})\s*[-–]\s*(\d{1,2})/);
+  if (pair) {
+    const a = Number(pair[1]);
+    const b = Number(pair[2]);
+    if (month && (a === month || b === month)) {
+      day = a === month ? b : a;
+    } else if (!month) {
+      if (a >= 1 && a <= 12) {
+        month = a;
+        day = b;
+      } else if (b >= 1 && b <= 12) {
+        month = b;
+        day = a;
+      }
+    } else {
+      day = b;
+    }
+  }
+  if (!year) return { ym: "", date: "" };
+  const mm = month ? String(month).padStart(2, "0") : "";
+  const ym = mm ? `${year}-${mm}` : `${year}`;
+  const date = mm && day ? `${ym}-${String(day).padStart(2, "0")}` : ym;
+  return { ym, date };
+}
+
+// ../../lib/connectors/fileImport.ts
+var run = promisify(execFile);
+async function extractZip(zipPath, dest) {
+  try {
+    await run("tar", ["-xf", zipPath, "-C", dest], { maxBuffer: 256 * 1024 * 1024 });
+  } catch (tarErr) {
+    console.warn(`[fileImport] tar -xf failed on ${path5.basename(zipPath)} (${tarErr.message.slice(0, 120)}) \u2014 falling back to unzip`);
+    await new Promise((resolve, reject) => {
+      execFile("unzip", ["-o", "-q", zipPath, "-d", dest], { maxBuffer: 256 * 1024 * 1024 }, (e) => e ? reject(e) : resolve()).stdin?.end();
+    });
+  }
+}
+async function unzipTo(zipPath, dest) {
+  await fs4.rm(dest, { recursive: true, force: true });
+  await fs4.mkdir(dest, { recursive: true });
+  await extractZip(zipPath, dest);
+  await expandNestedZips(dest);
+}
+async function expandNestedZips(dest, depth = 0) {
+  if (depth >= 3) return;
+  const zips = await walk(dest, ".zip");
+  for (const z of zips) {
+    const sub = z.replace(/\.zip$/i, "");
+    await fs4.mkdir(sub, { recursive: true });
+    await extractZip(z, sub);
+    await fs4.rm(z, { force: true });
+  }
+  if (zips.length) await expandNestedZips(dest, depth + 1);
+}
+function htmlToText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#39;/g, "'").replace(/&quot;/g, '"').replace(/\s+/g, " ").trim();
+}
+async function readAccountIdentity(source, root) {
+  try {
+    if (source === "claude") {
+      const users = JSON.parse(await fs4.readFile(path5.join(root, "users.json"), "utf-8"));
+      const email = Array.isArray(users) ? users[0]?.email_address : void 0;
+      if (email) return { id: sha16({ email }).slice(0, 8), label: email };
+    }
+    if (source === "chatgpt") {
+      const user = JSON.parse(await fs4.readFile(path5.join(root, "user.json"), "utf-8"));
+      if (user?.email) return { id: sha16({ email: user.email }).slice(0, 8), label: user.email };
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function detectChatExport(root) {
+  try {
+    const users = JSON.parse(await fs4.readFile(path5.join(root, "users.json"), "utf-8"));
+    if (Array.isArray(users) && users[0]?.email_address) return "claude";
+  } catch {
+  }
+  try {
+    const user = JSON.parse(await fs4.readFile(path5.join(root, "user.json"), "utf-8"));
+    if (user?.email || user?.chatgpt_plus_user !== void 0) return "chatgpt";
+  } catch {
+  }
+  const [shard] = await findConversationsJsons(root);
+  if (shard) {
+    try {
+      const data = JSON.parse(await fs4.readFile(shard, "utf-8"));
+      const first = Array.isArray(data) ? data[0] : null;
+      if (first?.mapping) return "chatgpt";
+      if (first?.chat_messages) return "claude";
+    } catch {
+    }
+  }
+  return null;
+}
+async function importNotes(source, root, exclude) {
+  const events = [];
+  const files = [];
+  const candidates = [...await walk(root, ".md"), ...await walk(root, ".html")].filter(
+    (f) => !isExcluded(f, exclude)
+  );
+  for (const file2 of candidates) {
+    let raw;
+    let stat;
+    try {
+      stat = await fs4.stat(file2);
+      raw = await fs4.readFile(file2, "utf-8");
+    } catch {
+      continue;
+    }
+    const text = (file2.toLowerCase().endsWith(".html") ? htmlToText(raw) : raw).trim();
+    if (!text) continue;
+    const inferred = inferDate(path5.relative(root, file2)).date;
+    const ts = /^\d{4}-\d{2}-\d{2}$/.test(inferred) ? `${inferred}T12:00:00.000Z` : new Date(stat.mtimeMs).toISOString();
+    events.push({
+      id: sha16({ file: file2, head: text.slice(0, 200) }),
+      source,
+      type: "note",
+      timestamp: ts,
+      data: { text: text.slice(0, 8e3), title: path5.basename(file2), file: file2 }
+    });
+    files.push({ path: file2, events: 1 });
+  }
+  return { events, files };
+}
+async function findConversationsJsons(root) {
+  const jsons = await walk(root, ".json");
+  const shards = jsons.filter((f) => /^conversations(-\d+)?\.json$/.test(path5.basename(f))).sort();
+  if (shards.length) return shards;
+  return jsons[0] ? [jsons[0]] : [];
+}
+async function loadConversations(files) {
+  const convos = [];
+  for (const file2 of files) {
+    try {
+      const data = JSON.parse(await fs4.readFile(file2, "utf-8"));
+      if (Array.isArray(data)) for (const convo of data) convos.push({ convo, file: file2 });
+    } catch {
+    }
+  }
+  return convos;
+}
+async function importChatGPT(source, root) {
+  const shardFiles = await findConversationsJsons(root);
+  if (!shardFiles.length) return { events: [], files: [] };
+  const events = [];
+  const perFile = new Map(shardFiles.map((p) => [p, 0]));
+  const convos = await loadConversations(shardFiles);
+  let conversations = 0;
+  for (const { convo: c, file: file2 } of convos) {
+    const before = events.length;
+    const mapping = c.mapping || {};
+    for (const nodeId of Object.keys(mapping)) {
+      const m = mapping[nodeId]?.message;
+      const role = m?.author?.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const parts = m?.content?.parts || [];
+      const text = parts.filter((p) => typeof p === "string").join("\n").trim();
+      if (!text) continue;
+      const t = m.create_time || c.create_time;
+      const ts = t ? new Date(t * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      events.push({
+        id: sha16({ nodeId, head: text.slice(0, 200) }),
+        source,
+        type: role === "user" ? "ai_prompt" : "ai_response",
+        timestamp: ts,
+        data: role === "user" ? { prompt_text: text } : { response_text: text }
+      });
+      perFile.set(file2, (perFile.get(file2) ?? 0) + 1);
+    }
+    if (events.length > before) conversations++;
+  }
+  return { events, conversations, files: shardFiles.map((p) => ({ path: p, events: perFile.get(p) ?? 0 })) };
+}
+async function importClaudeExport(source, root) {
+  const shardFiles = await findConversationsJsons(root);
+  if (!shardFiles.length) return { events: [], files: [] };
+  const events = [];
+  const perFile = new Map(shardFiles.map((p) => [p, 0]));
+  const convos = await loadConversations(shardFiles);
+  let conversations = 0;
+  for (const { convo: c, file: file2 } of convos) {
+    const before = events.length;
+    const msgs = c.chat_messages || c.messages || [];
+    for (const m of msgs) {
+      const sender = m.sender || m.role;
+      let text = m.text || "";
+      if (!text && Array.isArray(m.content)) {
+        text = m.content.map((p) => p?.text || "").join("\n");
+      }
+      text = (text || "").trim();
+      if (!text) continue;
+      const rawTs = m.created_at || c.created_at;
+      const ts = rawTs ? new Date(rawTs).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      const isHuman = sender === "human" || sender === "user";
+      events.push({
+        id: sha16({ c: c.uuid || c.name, head: text.slice(0, 200), ts }),
+        source,
+        type: isHuman ? "ai_prompt" : "ai_response",
+        timestamp: ts,
+        data: isHuman ? { prompt_text: text } : { response_text: text }
+      });
+      perFile.set(file2, (perFile.get(file2) ?? 0) + 1);
+    }
+    if (events.length > before) conversations++;
+  }
+  return { events, conversations, files: shardFiles.map((p) => ({ path: p, events: perFile.get(p) ?? 0 })) };
+}
+async function importFromPath(source, inputPath, exclude) {
+  let p = inputPath.trim();
+  if (p.startsWith("~")) p = path5.join(os.homedir(), p.slice(1));
+  let stat;
+  try {
+    stat = await fs4.stat(p);
+  } catch {
+    throw new Error(`Path not found: ${p}`);
+  }
+  let workDir = p;
+  if (stat.isFile() && p.toLowerCase().endsWith(".zip")) {
+    const stem = path5.basename(p, path5.extname(p)).replace(/[^\w.-]+/g, "_").slice(0, 80) || "export";
+    const dest = path5.join(DATA_DIR, "extract", source, stem);
+    await unzipTo(p, dest);
+    workDir = dest;
+  } else if (stat.isFile()) {
+    workDir = path5.dirname(p);
+  }
+  const detected = await detectChatExport(workDir);
+  const effective = detected ?? source;
+  let result;
+  switch (effective) {
+    case "obsidian":
+    case "notion":
+      result = await importNotes(effective, workDir, exclude);
+      break;
+    case "chatgpt":
+      result = await importChatGPT(effective, workDir);
+      break;
+    case "claude":
+      result = await importClaudeExport(effective, workDir);
+      break;
+    default:
+      result = { events: [], files: [] };
+  }
+  const account = await readAccountIdentity(effective, workDir);
+  return { ...result, ...account ? { account } : {}, source: effective, root: workDir };
+}
+
+// ../../lib/compute.ts
+import { promises as fs5 } from "fs";
+import path7 from "path";
+
+// ../../lib/careerTodos.ts
+var CAREER_TODOS = [
+  {
+    id: "schedule",
+    title: "Lock in a daily deep-work schedule",
+    detail: "Same start time, two or three protected blocks. Consistency is the cheapest level you can buy.",
+    level: 2,
+    cta: "Set it",
+    resources: [
+      { label: "Deep Work \u2014 the core idea", href: "https://www.calnewport.com/books/deep-work/" },
+      { label: "Time-blocking, simply", href: "https://todoist.com/productivity-methods/time-blocking" }
+    ],
+    onPlatform: "Paste your daily logs in Talk to me \u2014 we'll watch whether the schedule actually holds."
+  },
+  {
+    id: "profile",
+    title: "Fix up your LinkedIn and GitHub",
+    detail: "A clean headline, a pinned project, a real bio. People look you up before they reply \u2014 give them something.",
+    level: 3,
+    cta: "Polish",
+    resources: [
+      { label: "Make your GitHub profile shine", href: "https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/about-your-profile" },
+      { label: "A LinkedIn that gets replies", href: "https://www.linkedin.com/help/linkedin/answer/a548429" }
+    ],
+    onPlatform: "Sign in with LinkedIn under your profile \u2014 we'll pull it in and flag what's missing."
+  },
+  {
+    id: "scroll",
+    title: "Read the right corner of Twitter daily",
+    detail: "Follow 30 people doing the work you want to do.",
+    level: 4,
+    cta: "Curate",
+    resources: [
+      { label: "A list of people to follow", href: "https://x.com/search?q=AI%20engineer&f=user" }
+    ],
+    onPlatform: "Chat with the assistant in Talk to me to build and prune your follow list."
+  },
+  {
+    id: "post",
+    title: "Start posting usefully on Twitter",
+    detail: "Two builds-in-public threads a week. Show the work, not the takes.",
+    level: 5,
+    cta: "Draft",
+    resources: [
+      { label: "Who to follow in tech Twitter", href: "https://x.com/search?q=building%20in%20public&f=user" },
+      { label: "How to use X", href: "https://help.x.com/en/using-x" },
+      { label: "How to post a thread", href: "https://help.x.com/en/using-x/creating-a-thread" }
+    ],
+    onPlatform: "Draft threads from your pasted work \u2014 we'll flag the ones worth posting."
+  },
+  {
+    id: "finetune",
+    title: "Ship a fine-tuning / data project",
+    detail: "Small, end-to-end, public. It compounds and it's legible to the people you want to reach.",
+    level: 6,
+    cta: "Start",
+    resources: [
+      { label: "Unsloth \u2014 fast fine-tuning notebooks", href: "https://github.com/unslothai/unsloth" },
+      { label: "Hugging Face \u2014 training docs", href: "https://huggingface.co/docs/transformers/en/training" },
+      { label: "Modal \u2014 cheap GPU runs", href: "https://modal.com/docs/guide/gpu" }
+    ],
+    onPlatform: "Paste your build logs in Talk to me \u2014 we'll track the project and surface it in your report."
+  },
+  {
+    id: "cowork",
+    title: "Find a co-working space or build a crew",
+    detail: "Isolation caps your ceiling. Get around people who push \u2014 a space, a Discord, a weekly build night.",
+    level: 7,
+    cta: "Find one",
+    resources: [
+      { label: "Hacker houses & spaces", href: "https://www.workfrom.co" },
+      { label: "Find a local builder meetup", href: "https://lu.ma/discover" }
+    ],
+    onPlatform: "Tell the assistant your city \u2014 we'll help you shortlist spaces and communities."
+  },
+  {
+    id: "internship",
+    title: "Get an internship at a frontier lab",
+    detail: "Neolab is hiring for exactly your shape. Warm intro available \u2014 draft the DM with one click.",
+    level: 9,
+    cta: "Draft DM",
+    resources: [
+      { label: "Write a cold email that lands", href: "https://www.julian.com/guide/email" },
+      { label: "Work at a Startup", href: "https://www.workatastartup.com" },
+      { label: "Find someone who can refer you", href: "https://www.linkedin.com/search/results/people/" }
+    ],
+    onPlatform: "Draft the DM here, then accept the warm intro in Gifts."
+  }
+];
+
+// ../../lib/gifts.ts
+var GIFTS = [
+  {
+    id: "messages",
+    title: "Messages",
+    kind: "inbox",
+    detail: "A Stanford philosophy student \u2014 exceptionally well-read \u2014 wants to compare notes on charting a better path through education.",
+    status: "new"
+  },
+  {
+    id: "cognition",
+    title: "Cognition",
+    kind: "intro",
+    detail: "A warm referral into the team building Cognition's agent platform. Mission-aligned, in SF, exactly your shape.",
+    status: "new"
+  },
+  {
+    id: "vc",
+    title: "VC intro",
+    kind: "intro",
+    detail: "A partner at Lightspeed wants to be connected \u2014 they back deeply technical founders early.",
+    status: "viewed"
+  },
+  {
+    id: "openai",
+    title: "OpenAI",
+    kind: "opportunity",
+    detail: "An opening on OpenAI's post-training team that fits your technical affinity \u2014 they asked to see more.",
+    status: "viewed"
+  },
+  {
+    id: "anthropic",
+    title: "Anthropic",
+    kind: "opportunity",
+    detail: "Your curiosity reads at Anthropic's bar \u2014 a referral toward their interpretability team is unlocked.",
+    status: "viewed"
+  }
+];
+
+// ../../lib/calibration/index.ts
+var DEFAULT_CALIBRATION = {
+  version: "2026-07-12.2",
+  // = 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).
+  rubricVersion: "f51b3a93a3",
+  // Canonical scale = the one the product owner set for the public report
+  // (11=0.01% … 8=2%), extended downward from the old report ladder. The old
+  // CodeAnalysisView / npm-viewer maps (7→10%/15%, 6→25%/30%) were drift, not
+  // intent.
+  scoreBands: [
+    { score: 11, label: "Top 0.01%" },
+    { score: 10, label: "Top 0.1%" },
+    { score: 9, label: "Top 0.5%" },
+    { score: 8, label: "Top 2%" },
+    { score: 7, label: "Top 5%" },
+    { score: 6, label: "Top 15%" },
+    { score: 5, label: "Top 50%" },
+    { score: 4, label: "Top 65%" },
+    { score: 3, label: "Top 80%" },
+    { score: 2, label: "Top 90%" },
+    { score: 1, label: "Top 97%" }
+  ],
+  minRankedScore: 6,
+  benchmarkBands: [
+    {
+      level: "11",
+      name: "Superhuman",
+      rank: "Top 0.01%",
+      oneIn: "1 in 10,000+",
+      meaning: "Beyond the normal human ceiling for the trait \u2014 the genuine power-law outlier. Almost no one earns this; when the evidence shows it, it is scored, not rounded down.",
+      foundIn: [
+        "Fields Medal and Nobel-track researchers",
+        "Founders of generational companies",
+        "The handful of people a frontier field is named after"
+      ],
+      maxTopPct: 0.01
+    },
+    {
+      level: "10",
+      name: "World-class",
+      rank: "Top 0.1%",
+      oneIn: "1 in 1,000",
+      meaning: "Among the best alive at this trait \u2014 the level entire institutions are built to find.",
+      foundIn: [
+        "Researchers at frontier AI labs",
+        "Faculty at top-5 research universities",
+        "IMO / IOI medalists",
+        "Founders backed by the top decile of venture firms"
+      ],
+      maxTopPct: 0.1
+    },
+    {
+      level: "9",
+      name: "Exceptional",
+      rank: "Top 1%",
+      oneIn: "1 in 100",
+      meaning: "Clearly exceptional \u2014 the strongest person on most strong teams.",
+      foundIn: [
+        "PhD students at top programs",
+        "Early engineers at breakout startups",
+        "YC-class founders",
+        "National olympiad finalists"
+      ],
+      maxTopPct: 1
+    },
+    {
+      level: "8",
+      name: "Strong",
+      rank: "Top 10%",
+      oneIn: "1 in 10",
+      meaning: "Strong against the whole population \u2014 the best person in most rooms, not every room.",
+      foundIn: [
+        "Senior engineers at selective tech companies",
+        "Graduates of demanding technical programs",
+        "Operators who get promoted everywhere they go"
+      ],
+      maxTopPct: 10
+    },
+    {
+      level: "5",
+      name: "Median",
+      rank: "50th percentile",
+      oneIn: "1 in 2",
+      meaning: 'The middle of the general population. The reference class is all ~8 billion humans \u2014 so even "strong" above already means top 10% of everyone.',
+      foundIn: ["The general population \u2014 most people, most places"],
+      maxTopPct: 100
+    }
+  ],
+  codingTiers: {
+    push: { median: 300, sigma: 1.121, tag: "estimated \u2014 log-normal fit", source: "Anthropic 2026 Claude Code study (400k sessions): median engaged user ~8 prompts/day at ~35 words \u2014 ~300 directed words/day; tail shape from its actions-per-prompt distribution. AVERAGE over substantial days, cumulative not spiky." },
+    focus: { median: 0.08, sigma: 0.559, tag: "estimated \u2014 proxy-anchored", source: "median: Anthropic 20h/week engaged-user figure implies ~1h/day of true rapid exchange against an 8h working day; ceiling anchored to the ~4h/day deep-work limit (45% share = 1-in-1,000). AVERAGE share, cumulative not spiky." },
+    orchestration: { tag: "estimated \u2014 behavior bands", source: "no published concurrency distribution exists; ceiling anchored to the Claude Code lead's documented 10-15 parallel sessions" }
+  },
+  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.
+      typicalPctOfDay: 0.35,
+      topPctOfDay: 0.5,
+      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"
+    },
+    longestRun: {
+      typicalHours: 0.67,
+      // ~40 min before the average worker is interrupted
+      topHours: 4,
+      tag: "measured",
+      source: "RescueTime (avg max ~40 min focus before interruption) \xB7 deep-work single-block ceiling ~3\u20134h",
+      line: "a top performer can hold a single ~3\u20134h uninterrupted block; the average worker breaks at ~40 min"
+    },
+    parallelism: {
+      topMaxConcurrent: 12,
+      // Boris Cherny ~10–15 interactive sessions
+      topAvgConcurrent: 6,
+      // time-weighted average while active (anecdotal, same source)
+      worktreesTip: "3\u20135 git worktrees at once",
+      tag: "anecdotal",
+      source: "Boris Cherny (Claude Code lead, Anthropic): ~10\u201315 concurrent sessions, 'dozens of Claudes running at all times'; 3\u20135 worktrees = 'the single biggest productivity unlock'",
+      line: "the Claude Code lead runs 10\u201315 sessions at once; his #1 tip is 3\u20135 git worktrees in parallel"
+    },
+    throughput: {
+      // Top-0.1% words/day reference lines, anchored to the throughput ladder
+      // (THROUGHPUT_LADDER in throughput.ts): score 10 "world-class sustained" =
+      // 9k/day, score 11 "superhuman ceiling" = 12k/day. Calibrated to the person's
+      // own anchors, not a wild guess — but still a target, not a measured population.
+      topAvgWordsPerDay: 9e3,
+      topPeakWordsPerDay: 12e3,
+      benchLabel: "top 0.1%",
+      // No published "words typed/day" for heavy users — the real story is OUTPUT.
+      loopsHeadline: ">1,000,000 lines of Rust at 99.8% tests passing",
+      loopsDetail: "the Bun runtime was ported Zig\u2192Rust largely autonomously \u2014 hundreds of parallel subagents, two AI reviewers per file",
+      tag: "measured",
+      source: "The Register, May 2026 (Bun Zig\u2192Rust rewrite)",
+      line: "autonomous fleets ported >1M lines of Rust at 99.8% tests passing; a while-loop agent delivered a $50k contract for $297 of compute"
+    }
+  }
+};
+function bandLabel(score, doc = DEFAULT_CALIBRATION) {
+  const s = Math.max(1, Math.min(11, Math.round(score)));
+  let best = null;
+  for (const b of doc.scoreBands) if (b.score <= s && (!best || b.score > best.score)) best = b;
+  return (best ?? doc.scoreBands[0]).label;
+}
+
+// ../../lib/patterns.ts
+var TOP_STRENGTHS = [
+  {
+    title: "Curiosity",
+    level: bandLabel(9),
+    detail: "You go to primary sources and stay until it actually clicks \u2014 and the range of what you've chased, from ML internals to how people learn, is unusual."
+  },
+  {
+    title: "Agency",
+    level: bandLabel(9),
+    detail: "You've come at the education problem from a dozen angles over the past several months \u2014 each one a high-quality, high-judgment bet, none of it busywork. You don't wait for permission to start."
+  },
+  {
+    title: "Ownership",
+    level: bandLabel(8),
+    detail: "You take the unglamorous parts as yours to close. On the education work you've carried the hard bits end to end instead of handing them off."
+  }
+];
+var WORK_ON = [
+  {
+    title: "Converting strategy to action",
+    detail: "You're good at deciding the right move \u2014 the co-working space, the LinkedIn cleanup, the next project \u2014 but it stays a plan. Pick one open intention this week, ship the first concrete step within 48 hours, and log it here so the action actually shows up in your patterns."
+  },
+  {
+    title: "Consistent schedules",
+    detail: "Your hours add up, but they're fragmented \u2014 a block at 9, another at noon, another late at night. Set one fixed start time, protect two or three deep-work blocks a day, and hold the same shape for two weeks before you judge it."
+  },
+  {
+    title: "Openness to other ideas",
+    detail: "You lock in fast, sometimes before the counter-argument is on the table. Before committing to a direction, write the strongest version of the opposing case in two lines, and pull in one person who'll genuinely push back."
+  }
+];
+var SECTION_AXES = [
+  { match: /intellig|curios|mind/i, axes: ["Raw ability", "Curiosity"] },
+  { match: /ambitio/i, axes: ["Ambition"] },
+  { match: /people|empath|social/i, axes: ["Empathy"] },
+  { match: /strateg|judg|decision/i, axes: ["Strategy"] },
+  { match: /communicat|conflict|writing/i, axes: ["Communication"] },
+  { match: /conscient|work ethic|disciplin|consisten/i, axes: ["Work ethic", "Consistency"] }
+];
+function rankFromScore(score) {
+  return bandLabel(score);
+}
+function derivePatterns(report) {
+  const scoreByLabel = new Map(report.capabilities.map((c) => [c.label, c.score]));
+  const avgScore = report.capabilities.length ? Math.round(
+    report.capabilities.reduce((s, c) => s + c.score, 0) / report.capabilities.length
+  ) : 6;
+  const sectionScore = (title) => {
+    const entry = SECTION_AXES.find((e) => e.match.test(title));
+    const scores = (entry?.axes ?? []).map((a) => scoreByLabel.get(a)).filter((n) => typeof n === "number");
+    return scores.length ? Math.max(...scores) : avgScore;
+  };
+  const strengths = [];
+  const workOn = [];
+  for (const sec of report.sections) {
+    if (sec.tone === "concern") {
+      for (const p of sec.points) workOn.push({ title: sec.title, detail: p.text });
+      continue;
+    }
+    const pros = sec.points.filter((p) => !p.candid);
+    const cons = sec.points.filter((p) => p.candid);
+    if (pros.length) {
+      const score = sectionScore(sec.title);
+      strengths.push({
+        title: sec.title,
+        level: rankFromScore(score),
+        detail: pros[0].text,
+        _score: score
+      });
+    }
+    for (const c of cons) workOn.push({ title: sec.title, detail: c.text });
+  }
+  const topStrengths = strengths.sort((a, b) => b._score - a._score).slice(0, 3).map(({ _score, ...card }) => card);
+  return { topStrengths, workOn: workOn.slice(0, 4) };
+}
+
+// ../../lib/evaluate.ts
+var DIMENSIONS = [
+  { key: "ownership", label: "Ownership", offset: 18 },
+  { key: "judgement", label: "Judgement", offset: 12 },
+  { key: "feedback", label: "Openness to feedback", offset: 6 },
+  { key: "growth", label: "Growth curve", offset: 10 },
+  { key: "interests", label: "What they're drawn to", offset: 14 },
+  { key: "drive", label: "How hard they push", offset: 16 },
+  { key: "ambition", label: "Ambition", offset: 15 },
+  { key: "life", label: "What they want from life", offset: 4 },
+  { key: "technical", label: "Technical affinity", offset: 20 },
+  { key: "metacognition", label: "Metacognition", offset: 8 },
+  { key: "morals", label: "Morals & values", offset: 7 }
+];
+function clamp(n, lo = 0, hi = 100) {
+  return Math.max(lo, Math.min(hi, n));
+}
+function levelFor(score) {
+  if (score >= 85) return "Top 1% \xB7 Anthropic level";
+  if (score >= 70) return "Strong \xB7 author level";
+  if (score >= 50) return "Developing";
+  return "Early signal";
+}
+function dayKey(iso) {
+  return iso.slice(0, 10);
+}
+function evaluatePlaceholder(input) {
+  const { profile, entries, events, connectedCount } = input;
+  const prompts = events.filter((e) => e.type === "ai_prompt").length;
+  const responses = events.filter((e) => e.type === "ai_response").length;
+  const sessions = new Set(events.map((e) => e.sessionId).filter(Boolean)).size;
+  const pastedChars = entries.reduce((sum, e) => sum + e.text.length, 0);
+  const hourBuckets = /* @__PURE__ */ new Map();
+  const stamp = (iso) => {
+    const d = dayKey(iso);
+    const hour = new Date(iso).getHours();
+    if (!hourBuckets.has(d)) hourBuckets.set(d, /* @__PURE__ */ new Set());
+    hourBuckets.get(d).add(hour);
+  };
+  for (const e of events) {
+    if (e.timestamp) stamp(e.timestamp);
+  }
+  for (const e of entries) stamp(e.createdAt);
+  const activeDays = hourBuckets.size;
+  const intensity = [];
+  const today = /* @__PURE__ */ new Date();
+  for (let i = 13; i >= 0; i--) {
+    const d = new Date(today.getTime() - i * 864e5);
+    const key = d.toISOString().slice(0, 10);
+    const hours = hourBuckets.has(key) ? Math.min(16, hourBuckets.get(key).size) : 0;
+    intensity.push({ day: key, hours });
+  }
+  const totalEvents = events.length;
+  const signal = Math.min(
+    16,
+    Math.round(Math.log2(totalEvents + 1) * 1.4 + Math.log2(pastedChars + 1) * 0.6)
+  );
+  const dimensions = DIMENSIONS.map((d) => {
+    const seed = Array.from(d.key).reduce((a, c) => a + c.charCodeAt(0), 0);
+    const spread = 46 + (seed * 7 + d.offset) % 42;
+    const score = clamp(Math.min(96, spread + signal));
+    return {
+      key: d.key,
+      label: d.label,
+      score,
+      level: levelFor(score),
+      evidence: totalEvents > 0 ? `Inferred from ${prompts} prompts across ${sessions || 1} sessions (placeholder).` : "Connect a source to generate signal."
+    };
+  });
+  const topStrengths = TOP_STRENGTHS;
+  const workOn = WORK_ON;
+  const todos = CAREER_TODOS;
+  const gifts = GIFTS;
+  const wantToSee = [
+    "You sticking to your schedule",
+    "You being more honest with yourself",
+    "You being more high-agency"
+  ];
+  const profileFill = profile ? [profile.github, profile.website, profile.things, profile.lookingFor].filter(Boolean).length : 0;
+  const progress = clamp(
+    Math.round(
+      connectedCount * 8 + Math.min(35, Math.log2(totalEvents + 1) * 5) + (profile?.onboarded ? 10 : 0) + profileFill * 2 + Math.min(10, pastedChars / 2500)
+    )
+  );
+  const level = Math.min(10, Math.max(1, Math.floor(progress / 10) + 1));
+  const summary = totalEvents > 0 ? `Read ${totalEvents.toLocaleString()} signals across ${sessions || 1} sessions and ${activeDays} active day${activeDays === 1 ? "" : "s"}. Curiosity and agency are already top-decile; consistency is the unlock.` : "Nothing connected yet. Paste something in, or connect a source, and the picture fills in.";
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    progress,
+    level,
+    dimensions,
+    topStrengths,
+    workOn,
+    intensity,
+    todos,
+    gifts,
+    wantToSee,
+    summary,
+    stats: {
+      totalEvents,
+      prompts,
+      responses,
+      sessions,
+      activeDays,
+      pastedChars
+    },
+    isPlaceholder: true
+  };
+}
+
+// ../../lib/agents/shared/cliAdapter.ts
+var CLAUDE_BIN = process.env.CLAUDE_BIN || "claude";
+
+// ../../lib/agents/shared/backends.ts
+import os2 from "os";
+var HOME = os2.homedir();
+
+// ../../lib/agents/shared/tools.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var exec = promisify2(execFile2);
+
+// ../../lib/agents/shared/limitGate.ts
+import { AsyncLocalStorage } from "async_hooks";
+var MIN = 6e4;
+var HOUR = 60 * MIN;
+var STALL_BACKOFFS_MS = [6e4, 3 * MIN, 10 * MIN, 20 * MIN];
+var SLEEP_CHUNK_MS = 5 * MIN;
+var CANONICAL = [
+  /claude (ai )?usage limit reached/i,
+  /\busage limit reached\b/i,
+  // "session" variant seen live 2026-07-06: "You've hit your session limit ·
+  // resets 4:10am (America/Los_Angeles)" — unrecognized, it failed EVERY
+  // post-wall stage of the overnight rehearsal instead of pausing. Keep the
+  // subject alternatives in sync with what the CLI actually emits.
+  /you'?ve (?:hit|reached) your (?:usage |session |weekly |daily )?limit/i,
+  /\bsession limit\b[^.]{0,40}resets?/i,
+  /reached your usage limit/i,
+  /5[\s-]?hour limit (?:reached|hit)/i,
+  /limit will reset/i
+];
+var LIBERAL = [
+  ...CANONICAL,
+  /usage limit/i,
+  /\bsession limit\b/i,
+  /\brate[\s-]?limit(?:ed|s|\b)/i,
+  /\btoo many requests\b/i,
+  /\b429\b/,
+  /quota (?:exceeded|reached|exhausted)/i,
+  /resets? (?:at|in)\b/i,
+  /resets? \d{1,2}(?::\d{2})?\s*(?:am|pm)/i
+  // "resets 4:10am" — no "at" (live form)
+];
+var ALS = new AsyncLocalStorage();
+
+// ../../lib/agents/shared/paths.ts
+import os3 from "os";
+import path6 from "path";
+function polymathHome() {
+  return process.env.POLYMATH_HOME || path6.join(os3.homedir(), ".polymath-society");
+}
+function agentDir(agent) {
+  return path6.join(polymathHome(), agent);
+}
+
+// ../../lib/compute.ts
+async function loadReport() {
+  try {
+    const raw = await fs5.readFile(path7.join(agentDir("report"), "latest.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function applyReportPatterns(ev) {
+  const report = await loadReport();
+  if (!report) return ev;
+  const { topStrengths, workOn } = derivePatterns(report);
+  if (!topStrengths.length && !workOn.length) return ev;
+  return {
+    ...ev,
+    ...topStrengths.length ? { topStrengths } : {},
+    ...workOn.length ? { workOn } : {},
+    isPlaceholder: ev.isPlaceholder && report.meta.isPlaceholder
+  };
+}
+async function computeEvaluation() {
+  const [profile, entries, events, connections] = await Promise.all([
+    getProfile(),
+    getEntries(),
+    getAllImported(),
+    getConnections()
+  ]);
+  const connectedCount = Object.values(connections).filter((c) => c.connected).length;
+  const evaluation = await applyReportPatterns(
+    evaluatePlaceholder({ profile, entries, events, connectedCount })
+  );
+  await saveEvaluation(evaluation);
+  return evaluation;
+}
+
+// ../../lib/onboarding/notify/notify.ts
+import { promises as fs6 } from "fs";
+import path8 from "path";
+
+// ../../lib/sources.ts
+var SOURCES = [
+  {
+    id: "claude-code",
+    label: "Claude Code",
+    desc: "Local CLI session logs \u2014 ~/.claude/projects",
+    kind: "auto",
+    available: true
+  },
+  {
+    id: "cursor",
+    label: "Cursor",
+    desc: "Workspace AI history + agent transcripts",
+    kind: "auto",
+    available: true
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    desc: "Codex CLI sessions \u2014 ~/.codex",
+    kind: "auto",
+    available: true
+  },
+  {
+    id: "obsidian",
+    label: "Obsidian",
+    desc: "Pick your vault folder (.md notes)",
+    kind: "import",
+    available: true
+  },
+  {
+    id: "apple-notes",
+    label: "Apple Notes",
+    desc: "Local notes \u2014 read via the Notes app",
+    kind: "auto",
+    available: true
+  },
+  {
+    id: "notion",
+    label: "Notion",
+    desc: "Pick your Notion export (.zip or folder)",
+    kind: "import",
+    available: true
+  },
+  {
+    id: "chatgpt",
+    label: "ChatGPT",
+    desc: "Pick your ChatGPT data export (.zip)",
+    kind: "import",
+    available: true
+  },
+  {
+    id: "claude",
+    label: "Claude",
+    desc: "Pick your claude.ai data export (.zip)",
+    kind: "import",
+    available: true
+  }
+];
+var SOURCE_LABELS = Object.fromEntries(
+  SOURCES.map((s) => [s.id, s.label])
+);
+
+// ../../lib/onboarding/notify/notify.ts
+var QUEUE_FILE = path8.join(ONBOARDING_DIR, "notifications.json");
+var DEDUPE_MS = 12 * 60 * 60 * 1e3;
+var PRUNE_MS = 7 * 24 * 60 * 60 * 1e3;
+var notifier = null;
+async function readQueue() {
+  try {
+    return JSON.parse(await fs6.readFile(QUEUE_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+async function enqueue(n) {
+  await fs6.mkdir(ONBOARDING_DIR, { recursive: true });
+  let q = await readQueue();
+  q = q.filter((x) => !x.delivered || Date.now() - (Date.parse(x.createdAt) || 0) < PRUNE_MS);
+  if (n.dedupeKey) {
+    const i = q.findIndex((x) => x.dedupeKey === n.dedupeKey);
+    if (i >= 0) {
+      const existing = q[i];
+      const age = Date.now() - (Date.parse(existing.createdAt) || 0);
+      if (age < DEDUPE_MS) {
+        q[i] = { ...existing, title: n.title, body: n.body, href: n.href, kind: n.kind, source: n.source, url: n.url };
+        await fs6.writeFile(QUEUE_FILE, JSON.stringify(q, null, 2), "utf-8");
+        return;
+      }
+      q.splice(i, 1);
+    }
+  }
+  q.push(n);
+  await fs6.writeFile(QUEUE_FILE, JSON.stringify(q, null, 2), "utf-8");
+}
+async function notifyReady(source, eventCount) {
+  const label = SOURCE_LABELS[source] ?? source;
+  const n = {
+    id: `${source}-${Date.now()}`,
+    title: "I finished reading you.",
+    body: `Your ${label} history is in \u2014 ${eventCount.toLocaleString()} new signals. Come see what I found.`,
+    href: "/report",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    delivered: false,
+    dedupeKey: `ready:${source}`
+  };
+  if (notifier) {
+    await notifier.deliver(n);
+    return;
+  }
+  await enqueue(n);
+}
+
+// ../../lib/onboarding/jobs/analyze-trigger.ts
+import { spawn } from "child_process";
+import { promises as fs7, existsSync } from "fs";
+import path9 from "path";
+var ROOT = process.cwd();
+var LOCK = path9.join(ROOT, ".data", "analyze.lock");
+var PENDING = path9.join(ROOT, ".data", "engine-pending.json");
+function defaultCmd() {
+  if (existsSync(path9.join(ROOT, "scripts", "run-engine.mts"))) return "npx tsx scripts/run-engine.mts";
+  return `"${process.execPath}" "${path9.join(ROOT, "engine-dist", "run-engine.js")}"`;
+}
+function mode() {
+  const m = (process.env.POLYMATH_ANALYZE_MODE || "immediate").toLowerCase();
+  return m === "nightly" || m === "off" ? m : "immediate";
+}
+function debounceMs() {
+  const v = Number(process.env.POLYMATH_ANALYZE_DEBOUNCE_MS);
+  return Number.isFinite(v) && v >= 0 ? v : 5 * 6e4;
+}
+var g = globalThis;
+function handle() {
+  return g.__analyzeTrigger ??= { timer: null, pending: /* @__PURE__ */ new Set() };
+}
+async function scheduleIncrementalAnalysis(source) {
+  const m = mode();
+  if (m === "off") {
+    console.log("[analyze-trigger] POLYMATH_ANALYZE_MODE=off \u2014 not auto-running");
+    return;
+  }
+  if (m === "nightly") {
+    await markPending(source);
+    console.log(`[analyze-trigger] queued ${source} for the nightly engine run`);
+    return;
+  }
+  await markPending(source);
+  const h = handle();
+  h.pending.add(source);
+  if (h.timer) clearTimeout(h.timer);
+  const ms = debounceMs();
+  console.log(`[analyze-trigger] ${source} imported \u2014 engine run in ${Math.round(ms / 1e3)}s (debounced)`);
+  h.timer = setTimeout(() => {
+    h.timer = null;
+    h.pending.clear();
+    void runEngineOnce({ noWindow: true });
+  }, ms);
+  h.timer.unref?.();
+}
+async function markPending(source) {
+  await fs7.mkdir(path9.dirname(PENDING), { recursive: true });
+  let cur = { sources: [], since: (/* @__PURE__ */ new Date()).toISOString() };
+  try {
+    cur = JSON.parse(await fs7.readFile(PENDING, "utf-8"));
+  } catch {
+  }
+  const sources = Array.from(/* @__PURE__ */ new Set([...cur.sources || [], source]));
+  await fs7.writeFile(PENDING, JSON.stringify({ sources, since: cur.since || (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+}
+async function clearPending() {
+  await fs7.rm(PENDING, { force: true }).catch(() => {
+  });
+}
+async function acquireLock() {
+  try {
+    const pid = Number((await fs7.readFile(LOCK, "utf-8")).trim());
+    if (pid && isAlive(pid)) return false;
+  } catch {
+  }
+  await fs7.mkdir(path9.dirname(LOCK), { recursive: true });
+  await fs7.writeFile(LOCK, String(process.pid));
+  return true;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runEngineOnce(opts = {}) {
+  if (!await acquireLock()) {
+    console.log("[analyze-trigger] an engine run is already active \u2014 skipping");
+    return 0;
+  }
+  const cmd = process.env.POLYMATH_ANALYZE_CMD || defaultCmd();
+  console.log(`[analyze-trigger] engine run START: ${cmd}`);
+  const env = {
+    ...process.env,
+    POLYMATH_RESILIENT: "1",
+    // survive the 5h wall (limitGate)
+    ...opts.noWindow ? { POLYMATH_RESILIENT_NO_WINDOW: "1" } : {}
+  };
+  try {
+    const code = await new Promise((resolve) => {
+      const child = spawn("bash", ["-lc", cmd], { cwd: ROOT, env, stdio: "inherit" });
+      child.on("error", (e) => {
+        console.error("[analyze-trigger] engine spawn failed", e);
+        resolve(-1);
+      });
+      child.on("exit", (c) => resolve(c ?? -1));
+    });
+    console.log(`[analyze-trigger] engine run DONE (exit ${code})`);
+    if (code === 0) await clearPending();
+    else console.log("[analyze-trigger] keeping engine-pending.json \u2014 a wake/nightly retry will resume the remaining work");
+    return code;
+  } finally {
+    await fs7.rm(LOCK, { force: true }).catch(() => {
+    });
+  }
+}
+
+// ../../lib/onboarding/jobs/runner.ts
+async function runIngest(jobId) {
+  const state = await getState();
+  const job = state.jobs.find((j) => j.id === jobId);
+  if (!job) return null;
+  if (!job.zipPath) {
+    return patchJob(jobId, { stage: "error", error: "no zip/folder path to ingest" });
+  }
+  let events;
+  let effectiveSource = job.source;
+  try {
+    const imp = await importFromPath(job.source, job.zipPath);
+    events = imp.events;
+    effectiveSource = imp.source ?? job.source;
+    if (events.length === 0) {
+      return patchJob(jobId, { stage: "error", error: "export contained no readable content \u2014 nothing was imported" });
+    }
+    await recordImport(effectiveSource, { ...imp, archive: job.zipPath });
+    if (effectiveSource !== job.source) await patchJob(jobId, { source: effectiveSource });
+  } catch (e) {
+    return patchJob(jobId, { stage: "error", error: `import failed: ${e.message}` });
+  }
+  try {
+    await computeEvaluation();
+  } catch {
+  }
+  void scheduleIncrementalAnalysis(effectiveSource).catch(() => {
+  });
+  const ready = await patchJob(jobId, { stage: "ready" });
+  try {
+    await notifyReady(effectiveSource, events.length);
+  } catch {
+  }
+  return ready;
+}
+
+// ../../lib/onboarding/retrieval/manual.ts
+function expandHome(p) {
+  return p === "~" || p.startsWith("~/") ? path10.join(os4.homedir(), p.slice(1)) : path10.resolve(p);
+}
+async function attachLocalExport(source, filePath, opts = {}) {
+  const resolved = expandHome(filePath.trim());
+  const stat = await fs8.stat(resolved).catch(() => null);
+  if (!stat) throw new Error(`nothing found at ${resolved}`);
+  if (stat.isFile() && !/\.zip$/i.test(resolved)) {
+    throw new Error(`expected a .zip file or a folder, got ${path10.basename(resolved)}`);
+  }
+  let zipPath = resolved;
+  if (stat.isFile()) {
+    await fs8.mkdir(EXPORTS_DIR, { recursive: true });
+    zipPath = path10.join(EXPORTS_DIR, `${source}-manual-${Date.now()}.zip`);
+    await fs8.copyFile(resolved, zipPath);
+  }
+  const state = await getState();
+  const open = [...state.jobs].reverse().find((j) => j.source === source && j.stage !== "ready" && j.stage !== "ingesting");
+  const job = open ?? await createJob(source);
+  const staged = await patchJob(job.id, {
+    stage: "ingesting",
+    zipPath,
+    downloadUrl: void 0,
+    error: void 0,
+    needsUserReason: void 0
+  }) ?? job;
+  if (opts.background) {
+    void runIngest(job.id).catch(() => {
+    });
+    return staged;
+  }
+  return await runIngest(job.id) ?? staged;
+}
+
+// ../../lib/onboarding/types.ts
+var EXPORT_SOURCES = ["chatgpt", "claude", "notion"];
+
+// ../../scripts/ingest-export.mts
+var KINDS = [...EXPORT_SOURCES, "obsidian"];
+var [kind, file] = process.argv.slice(2);
+(async () => {
+  if (!kind || !file || !KINDS.includes(kind)) {
+    console.error(`usage: npx tsx scripts/ingest-export.mts <${KINDS.join("|")}> <path-to-zip-or-folder>`);
+    process.exit(2);
+  }
+  if (kind === "obsidian") {
+    console.log(`Ingesting Obsidian vault from ${file} \u2026`);
+    const imp = await importFromPath("obsidian", file);
+    if (imp.events.length === 0) {
+      console.error("FAIL: vault contained no readable notes \u2014 nothing was imported");
+      process.exit(1);
+    }
+    await recordImport(imp.source, imp);
+    try {
+      await computeEvaluation();
+    } catch {
+    }
+    console.log(`DONE \u2014 imported ${imp.events.length} events from ${imp.conversations ?? "?"} notes.`);
+    process.exit(0);
+  }
+  console.log(`Ingesting ${kind} export from ${file} \u2026`);
+  const job = await attachLocalExport(kind, file);
+  if (job.stage === "ready") {
+    console.log(`DONE \u2014 job ${job.id}: data imported, evaluation refreshed.`);
+  } else {
+    console.log(`Job ${job.id} ended in stage "${job.stage}"${job.error ? `: ${job.error}` : ""}`);
+  }
+  process.exit(job.stage === "error" ? 1 : 0);
+})().catch((e) => {
+  console.error("FAIL", e.message);
+  process.exit(1);
+});