polymath-society 0.2.4

package/dist/pipeline/coding-frontier.js

@@ -0,0 +1,51 @@
+import{createRequire as __cr}from'module';const require=__cr(import.meta.url);
+
+// ../../scripts/coding-frontier.mts
+import { promises as fs } from "fs";
+var CODING = ".data/coding";
+var tc = (s, name) => (s.toolCounts?.[name] ?? 0) > 0;
+var mcp = (s, re) => (s.mcpTools ?? []).some((m) => re.test(m));
+var DETECTORS = [
+  { key: "live-preview", label: "Live-preview automation (drives a dev server to verify UI)", family: "Browser & machine control", test: (s) => mcp(s, /Claude_Preview|preview_/) },
+  { key: "chrome-mcp", label: "Chrome / browser automation", family: "Browser & machine control", test: (s) => mcp(s, /Claude_in_Chrome|playwright/) },
+  { key: "computer-use", label: "Computer use (native desktop control)", family: "Browser & machine control", test: (s) => mcp(s, /computer-use/) },
+  { key: "subagent-fanout", label: "Subagent fan-out (parallel agents)", family: "Orchestration", test: (s) => (s.subagentSpawns ?? 0) > 0 || tc(s, "Agent") || tc(s, "Task") },
+  { key: "task-orchestration", label: "Task orchestration (TaskCreate / TaskUpdate)", family: "Orchestration", test: (s) => tc(s, "TaskCreate") || tc(s, "TaskUpdate") },
+  { key: "deferred-tools", label: "Deferred-tool loading (ToolSearch)", family: "Orchestration", test: (s) => tc(s, "ToolSearch") },
+  { key: "queue-ahead", label: "Queue-ahead (prompts queued while the AI works)", family: "Orchestration", test: (s) => (s.queueOps ?? 0) > 0 },
+  { key: "skill-used", label: "Used a skill", family: "Skills & extensions", test: (s) => tc(s, "Skill") },
+  { key: "visualize", label: "Visualization widgets", family: "Skills & extensions", test: (s) => mcp(s, /visualize|show_widget/) },
+  { key: "web-research", label: "Web research (WebSearch / WebFetch)", family: "Research", test: (s) => tc(s, "WebSearch") || tc(s, "WebFetch") }
+];
+async function main() {
+  const all = JSON.parse(await fs.readFile(`${CODING}/sessions.json`, "utf8"));
+  const sessions = all.filter((s) => s.klass === "interactive");
+  const dateOf = (s) => (s.start || "").slice(0, 10);
+  const activeDays = new Set(sessions.map(dateOf).filter(Boolean)).size;
+  const capabilities = DETECTORS.map((d) => {
+    const hit = sessions.filter((s) => d.test(s));
+    const days = new Set(hit.map(dateOf).filter(Boolean)).size;
+    return { key: d.key, label: d.label, family: d.family, sessions: hit.length, days, tableStakes: hit.length / sessions.length >= 0.85 };
+  }).filter((c) => c.sessions > 0).sort((a, b) => b.sessions - a.sessions);
+  const srv = {};
+  for (const s of sessions) for (const m of s.mcpTools ?? []) {
+    const mm = /^mcp__(.+?)__/.exec(m);
+    if (mm) (srv[mm[1]] = srv[mm[1]] || /* @__PURE__ */ new Set()).add(s.sessionId);
+  }
+  const mcpServers = Object.entries(srv).map(([server, set]) => ({ server, sessions: set.size })).sort((a, b) => b.sessions - a.sessions);
+  const out = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionsScanned: sessions.length,
+    activeDays,
+    capabilities,
+    mcpServers,
+    pending: ["skill-created (needs tool-input parse)", "loops / scheduled runs", "overnight / EC2 remote", "run-from-phone"]
+  };
+  await fs.writeFile(`${CODING}/frontier.json`, JSON.stringify(out, null, 2));
+  console.log(`frontier.json \u2014 ${capabilities.length} capabilities, ${mcpServers.length} MCP servers, ${sessions.length} sessions`);
+  capabilities.forEach((c) => console.log(`  ${c.sessions}\xD7 (${c.days}d) ${c.label}${c.tableStakes ? "  [table-stakes]" : ""}`));
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/dist/pipeline/coding-gap-dist.js

@@ -0,0 +1,293 @@
+import{createRequire as __cr}from'module';const require=__cr(import.meta.url);
+
+// ../../scripts/coding-gap-dist.mts
+import { promises as fs2 } from "fs";
+import path from "path";
+
+// ../../lib/agents/shared/cliAdapter.ts
+var CLAUDE_BIN = process.env.CLAUDE_BIN || "claude";
+
+// ../../lib/agents/shared/backends.ts
+import os from "os";
+var HOME = os.homedir();
+
+// ../../lib/agents/shared/tools.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+
+// ../../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();
+
+// ../coding-core/dist/messages.js
+import { promises as fs } from "fs";
+
+// ../coding-core/dist/injected.js
+var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var INJECTED_RES = [
+  /<task-notification>[\s\S]*?<\/task-notification>/g,
+  /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/g,
+  /<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g,
+  /<ide_opened_file>[\s\S]*?<\/ide_opened_file>/g
+];
+var HARNESS_TURN_RES = [
+  /^Non user activity$/i,
+  /^<<autonomous-loop(-dynamic)?>>$/,
+  /^This session is being continued from a previous conversation/,
+  // the loop skill's expanded wake-up prompt — older CLI versions wrote it as a
+  // plain user turn with no isMeta flag (found counting 601 words, 2026-07-07)
+  /^(-{3,}\s*)?#\s*Autonomous loop (check|tick)/
+];
+function stripInjected(t) {
+  for (const re of INJECTED_RES)
+    t = t.replace(re, "");
+  return t.replace(SYSTEM_REMINDER_RE, "");
+}
+function isHarnessTurn(t) {
+  const s = t.trim();
+  return HARNESS_TURN_RES.some((re) => re.test(s));
+}
+function humanTypedText(t) {
+  const s = stripInjected(t).trim();
+  return s && !isHarnessTurn(s) ? s : "";
+}
+function isHarnessEntry(e) {
+  return e.isMeta === true || e.isCompactSummary === true;
+}
+
+// ../coding-core/dist/messages.js
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content))
+    return content.filter((c) => c && typeof c === "object" && c.type === "text").map((c) => c.text || "").join("\n");
+  return "";
+}
+function isToolResultOnly(content) {
+  return Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
+}
+async function extractMessages(file) {
+  let raw;
+  try {
+    raw = await fs.readFile(file, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  const userTexts = /* @__PURE__ */ new Set();
+  const seenUuids = /* @__PURE__ */ new Set();
+  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 text = prose;
+    if (toolStr)
+      text = (text ? text + " " : "") + `[ran ${toolStr}]`;
+    if (text)
+      out.push({ t: aiStart, role: "ai", text });
+    aiProse = [];
+    aiTools = {};
+  };
+  for (const line of raw.split("\n")) {
+    const s = line.trim();
+    if (!s)
+      continue;
+    let e;
+    try {
+      e = JSON.parse(s);
+    } catch {
+      continue;
+    }
+    const t = typeof e.timestamp === "string" ? Date.parse(e.timestamp) : NaN;
+    if (!Number.isFinite(t))
+      continue;
+    if (e.type === "queue-operation" && e.operation === "enqueue" && typeof e.content === "string") {
+      const qt = humanTypedText(e.content);
+      if (qt) {
+        flushAI();
+        out.push({ t, role: "user", text: qt, q: true });
+      }
+      continue;
+    }
+    if (e.type === "user") {
+      if (isHarnessEntry(e))
+        continue;
+      const uuid = typeof e.uuid === "string" ? e.uuid : "";
+      if (uuid && seenUuids.has(uuid))
+        continue;
+      const content = e.message?.content;
+      if (isToolResultOnly(content))
+        continue;
+      const text = humanTypedText(extractText(content));
+      if (text) {
+        if (uuid)
+          seenUuids.add(uuid);
+        userTexts.add(text);
+        flushAI();
+        out.push({ t, role: "user", text });
+      }
+      continue;
+    }
+    if (e.type === "assistant") {
+      const msg = e.message ?? {};
+      if (!aiProse.length && Object.keys(aiTools).length === 0)
+        aiStart = t;
+      if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          const it = item;
+          if (it.type === "text" && it.text)
+            aiProse.push(it.text);
+          else if (it.type === "tool_use" && it.name)
+            aiTools[it.name] = (aiTools[it.name] ?? 0) + 1;
+        }
+      } else {
+        const p = extractText(msg.content);
+        if (p)
+          aiProse.push(p);
+      }
+    }
+  }
+  flushAI();
+  return out.filter((m) => !(m.q && userTexts.has(m.text))).map(({ q, ...m }) => m).sort((a, b) => a.t - b.t);
+}
+
+// ../coding-core/dist/words.js
+var CODE_START = /^\s*(import |export |const |let |var |function\b|class |def |async |await |return |if\s*\(|for\s*\(|while\s*\(|switch\s*\(|#include|<\/?[a-zA-Z][\w-]*[\s>]|[}{)\]]|@[A-Za-z]|\$\s|npm |npx |git |cd |sudo )/;
+var SEAM_RE = /\n\s*\n\s*\n+/;
+var SEGMENT_CEILING = 400;
+var NOTE = "((ran|created|edited|read|wrote|searched) (a|an|\\d+) [a-z]+|updated todos)";
+var TRANSCRIPT_LINE_RE = new RegExp(`^\\s*(${NOTE})((,| and) ${NOTE})*\\s*$|^\\s*thought for .{1,30}$`, "im");
+var EM_DASH_RE = / — /g;
+var MAX_WPM = 1e3;
+var DEFAULT_GAP_MIN = 5;
+function typedWords(text, gapMs) {
+  const typed = humanTypedText(text);
+  const msgDashes = (typed.match(EM_DASH_RE) || []).length;
+  const msgWords = proseWords(typed);
+  const draftedMsg = msgDashes >= 6 && msgWords > 0 && msgDashes / msgWords >= 1 / 200;
+  let counted = 0;
+  for (const seg of typed.split(SEAM_RE)) {
+    if (TRANSCRIPT_LINE_RE.test(seg))
+      continue;
+    const w = proseWords(seg);
+    if (!w)
+      continue;
+    const dashes = (seg.match(EM_DASH_RE) || []).length;
+    if (dashes >= 3 && dashes / w >= 1 / 200)
+      continue;
+    if (draftedMsg && dashes >= 1)
+      continue;
+    counted += Math.min(w, SEGMENT_CEILING);
+  }
+  const mins = gapMs / 6e4;
+  const window = Number.isFinite(mins) && mins > 0 ? mins : DEFAULT_GAP_MIN;
+  return Math.min(counted, Math.round(MAX_WPM * window));
+}
+function proseWords(text) {
+  let t = text;
+  const skillAt = t.indexOf("Base directory for this skill:");
+  if (skillAt >= 0)
+    t = t.slice(0, skillAt);
+  const contAt = t.indexOf("This session is being continued from a previous conversation");
+  if (contAt >= 0)
+    t = t.slice(0, contAt);
+  t = t.replace(/<command-[a-z-]+>[\s\S]*?<\/command-[a-z-]+>/gi, " ");
+  t = t.replace(/```[\s\S]*?```/g, " ");
+  t = t.replace(/`[^`\n]{2,}`/g, " ");
+  const kept = t.split("\n").filter((ln) => {
+    const s = ln.trim();
+    if (s.length < 8)
+      return true;
+    const letters = (s.match(/[A-Za-z]/g) || []).length;
+    const symbols = (s.match(/[{}()[\];=<>+\-*/%&|^~$@\\]/g) || []).length;
+    const codey = CODE_START.test(s) || symbols > 3 && symbols / s.length > 0.25 || // symbol-dense → code
+    letters / s.length < 0.45;
+    return !codey;
+  });
+  return (kept.join(" ").trim().match(/\S+/g) || []).length;
+}
+
+// ../../scripts/coding-gap-dist.mts
+var CODING = ".data/coding";
+var WPM = 130;
+var BIN = 0.5;
+var MAX = 20;
+async function main() {
+  const sess = JSON.parse(await fs2.readFile(path.join(CODING, "sessions.json"), "utf8")).filter((s) => !s.duplicateOf && s.klass === "interactive");
+  const gaps = [];
+  for (const s of sess) {
+    let ms = [];
+    try {
+      ms = await extractMessages(s.file);
+    } catch {
+      continue;
+    }
+    const ev = ms.map((m) => ({ t: m.t, role: m.role, words: m.role === "user" ? typedWords(m.text || "", NaN) : 0 })).sort((a, b) => a.t - b.t);
+    for (let i = 1; i < ev.length; i++) {
+      const g = (ev[i].t - ev[i - 1].t) / 6e4;
+      if (g <= 0 || g > 60) continue;
+      gaps.push(Math.max(0, g - (ev[i].role === "user" ? ev[i].words / WPM : 0)));
+    }
+  }
+  gaps.sort((a, b) => a - b);
+  const bins = [];
+  for (let lo = 0; lo < MAX; lo = Math.round((lo + BIN) * 10) / 10) bins.push({ lo, hi: Math.round((lo + BIN) * 10) / 10, count: 0 });
+  let over = 0;
+  for (const g of gaps) {
+    if (g >= MAX) {
+      over++;
+      continue;
+    }
+    bins[Math.floor(g / BIN)].count++;
+  }
+  const curve = [];
+  for (let t = 0.5; t <= 15; t = Math.round((t + 0.5) * 10) / 10) curve.push({ t, fracUnder: Math.round(gaps.filter((g) => g < t).length / gaps.length * 1e3) / 1e3 });
+  const pct = (p) => gaps[Math.min(gaps.length - 1, Math.floor(gaps.length * p))] ?? 0;
+  const out = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), totalGaps: gaps.length, binMin: BIN, maxMin: MAX, bins, over, currentFlowGap: 5, curve, median: Math.round(pct(0.5) * 100) / 100, p25: Math.round(pct(0.25) * 100) / 100, p75: Math.round(pct(0.75) * 100) / 100, p90: Math.round(pct(0.9) * 100) / 100 };
+  await fs2.writeFile(path.join(CODING, "gap-dist.json"), JSON.stringify(out, null, 2));
+  const mx = Math.max(...bins.map((b) => b.count), 1);
+  console.log(`gap-dist: ${gaps.length} gaps \xB7 median ${out.median}m \xB7 p75 ${out.p75}m \xB7 p90 ${out.p90}m \xB7 ${over} over ${MAX}m`);
+  bins.forEach((b) => {
+    if (b.count) console.log(`  ${b.lo.toFixed(1).padStart(4)}-${b.hi.toFixed(1)}m ${"\u2588".repeat(Math.round(b.count / mx * 50))} ${b.count}`);
+  });
+}
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});