polymath-society 0.2.4 → 0.2.6

package/dist/pipeline/coding-gap.js

@@ -134,9 +134,8 @@ var require_secure_json_parse = __commonJS({
 });
 
 // ../../scripts/coding-gap.mts
-import { promises as fs9 } from "fs";
-import os2 from "os";
-import path12 from "path";
+import { promises as fs11 } from "fs";
+import path13 from "path";
 
 // ../../lib/agents/shared/agent.ts
 import { readFileSync } from "fs";
@@ -2151,8 +2150,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path14, errorMaps, issueData } = params;
+  const fullPath = [...path14, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -2268,11 +2267,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path14, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path14;
     this._key = key;
   }
   get path() {
@@ -15059,39 +15058,39 @@ function createOpenAI(options = {}) {
   });
   const createChatModel = (modelId, settings = {}) => new OpenAIChatLanguageModel(modelId, settings, {
     provider: `${providerName}.chat`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenAICompletionLanguageModel(modelId, settings, {
     provider: `${providerName}.completion`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenAIEmbeddingModel(modelId, settings, {
     provider: `${providerName}.embedding`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId, settings = {}) => new OpenAIImageModel(modelId, settings, {
     provider: `${providerName}.image`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path: path13 }) => `${baseURL}${path13}`,
+    url: ({ path: path14 }) => `${baseURL}${path14}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -15112,7 +15111,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path: path13 }) => `${baseURL}${path13}`,
+      url: ({ path: path14 }) => `${baseURL}${path14}`,
       headers: getHeaders,
       fetch: options.fetch
     });
@@ -16271,7 +16270,7 @@ function computeWorkstyle(inp) {
 
 // ../../lib/calibration/index.ts
 var DEFAULT_CALIBRATION = {
-  version: "2026-07-12.2",
+  version: "2026-07-14.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).
@@ -16360,7 +16359,7 @@ var DEFAULT_CALIBRATION = {
     }
   ],
   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." },
+    push: { median: 300, sigma: 0.91, 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: a 1-in-1,000 user AVERAGES ~5k directed words/day (near-daily heavy dictation, clearly below the ~10k single-day record). 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" }
   },
@@ -16393,12 +16392,18 @@ var DEFAULT_CALIBRATION = {
       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,
+      // Two DIFFERENT kinds of line (2026-07-14.2): topAvg is a PERCENTILE
+      // claim — what a 1-in-1,000 user AVERAGES over substantial days (5k/day:
+      // near-daily heavy dictation; a measured top dictating power user
+      // averages ~3.9k). topPeak is NOT a percentile — it is the CEILING
+      // reference, the wildest single days on record (~10k: a 14-16h
+      // launch-day marathon), rendered as "wildest single days", never
+      // "top X% peak". An avg-percentile and a peak-percentile can't both be
+      // shown at a same-ish value (avg≈peak reads broken — user call), and a
+      // peak PERCENTILE line is unknowable anyway; the record framing is
+      // honest and keeps the visual gap.
+      topAvgWordsPerDay: 5e3,
+      topPeakWordsPerDay: 1e4,
       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",
@@ -16733,7 +16738,7 @@ async function compileCodingProfile() {
     sRow(
       "How hard you push",
       aggregate?.throughput?.score ?? tCeiling,
-      `you peak at ~${peakWords.toLocaleString()} words of pure direction in a single day \u2014 the very top sustain ~${BEST.throughput.topAvgWordsPerDay.toLocaleString()} every day, week after week, and crest past ${BEST.throughput.topPeakWordsPerDay.toLocaleString()}`
+      `you peak at ~${peakWords.toLocaleString()} words of pure direction in a single day \u2014 the very top sustain ~${BEST.throughput.topAvgWordsPerDay.toLocaleString()} every day, week after week; the wildest single days on record push ~${BEST.throughput.topPeakWordsPerDay.toLocaleString()}`
     ),
     sRow(
       "How well you use AI",
@@ -16809,6 +16814,10 @@ async function readCodingAsset(name17) {
   );
 }
 
+// ../../lib/agents/coding/docsDir.ts
+import { promises as fs9 } from "fs";
+import path12 from "path";
+
 // ../../lib/agents/coding/materialize.ts
 import { promises as fs8 } from "fs";
 var SYSTEM_REMINDER_RE2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -16945,8 +16954,95 @@ async function materializeSession(file2) {
   return { text: lines.join("\n"), humanTurns, humanChars };
 }
 
+// ../../lib/agents/coding/docsDir.ts
+async function writeScoreboard(codingDir, docs) {
+  const gradesDir = path12.join(codingDir, "grades");
+  let files = [];
+  try {
+    files = (await fs9.readdir(gradesDir)).filter((f) => f.endsWith(".json")).sort();
+  } catch {
+    return;
+  }
+  const byCriterion = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    let g;
+    try {
+      g = JSON.parse(await fs9.readFile(path12.join(gradesDir, f), "utf8"));
+    } catch {
+      continue;
+    }
+    for (const c of g.criteria ?? []) {
+      const s = c.score ?? c.bestEstimate;
+      if (s == null) continue;
+      const line = `L${s}${c.score == null ? "~" : ""} \xB7 ${(g.date ?? "").slice(0, 10)} \xB7 ${(g.title ?? g.sessionId ?? "").replace(/\n.*/s, "").slice(0, 60)} \xB7 ${g.sessionId} \u2014 ${(c.instance ?? "").slice(0, 110)}`;
+      (byCriterion.get(c.key) ?? byCriterion.set(c.key, []).get(c.key)).push({ s, line });
+    }
+  }
+  if (!byCriterion.size) return;
+  const blocks = [...byCriterion.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(
+    ([key, rows]) => `## ${key}
+${rows.sort((a, b) => b.s - a.s).map((r) => r.line).join("\n")}`
+  );
+  await fs9.writeFile(
+    path12.join(docs, "_scoreboard.md"),
+    `# Scoreboard \u2014 every graded session per criterion, best first.
+# Lx~ = estimate. Format: level \xB7 date \xB7 title \xB7 sessionId \u2014 graded instance.
+
+${blocks.join("\n\n")}
+`
+  );
+}
+async function ensureCodingDocs(codingDir, sessions) {
+  const docs = path12.join(codingDir, "docs");
+  await fs9.mkdir(docs, { recursive: true });
+  const user = sessions.filter((s) => s.sessionId && !s.duplicateOf && (!("klass" in s) || s.klass === "interactive"));
+  let written = 0;
+  for (const s of user) {
+    const out = path12.join(docs, `${s.sessionId}.txt`);
+    try {
+      await fs9.access(out);
+      continue;
+    } catch {
+    }
+    const mat = await materializeSession(s.file).catch(() => null);
+    if (!mat?.text) continue;
+    await fs9.writeFile(out, mat.text);
+    written++;
+  }
+  const rows = user.sort((a, b) => (a.start ?? "") < (b.start ?? "") ? -1 : 1).map((s) => `${(s.start ?? "").slice(0, 10)} \xB7 ${(s.title ?? "").replace(/\n.*/s, "").slice(0, 80)} \xB7 ${s.sessionId}`);
+  await fs9.writeFile(path12.join(docs, "_map.md"), rows.join("\n") + "\n");
+  await writeScoreboard(codingDir, docs);
+  if (written) console.log(`[docs] materialized ${written} new transcript(s) \u2192 ${docs}`);
+  return docs;
+}
+function sourceLookupNote() {
+  return `
+
+SOURCE LOOKUP \u2014 you have Read/Grep/Glob over the working directory, which holds EVERYTHING known about this person's coding work. MAPS FIRST, grep second (the engine rule): docs/_scoreboard.md ranks every graded session per criterion, best first \u2014 one glance shows where the spikes/flair are, so start there when hunting peaks or checking whether a high mark is consistent or a one-off; day-digest.json is the day-by-day story of what they did in order \u2014 read the relevant days to get the arc before searching; docs/_map.md lists every session (date \xB7 title \xB7 sessionId). Then drill down: walkthroughs/<sessionId>.json is that session's phase-by-phase account (cheap, already distilled), grades/<sessionId>.json its graded findings with quotes, and docs/<sessionId>.txt the FULL transcript (">> " = the person, "[AI]" = the model) \u2014 the ground truth, read it when the distilled layers can't settle it. Other artifacts (flow.json, delegation/, expertise/, aggregate.json) are there too if a claim depends on them. The digest you were given is the spine \u2014 use lookups when a CLAIM-MOVING question cannot be settled from it (a moment you are about to headline, a promotion/depth call, an ambiguous engagement, whether detail was vision or boilerplate). VERIFY every verbatim quote you cite by finding it in the transcript first; if you cannot find it, do not use it. Look up what changes the output \u2014 do not re-read the whole corpus.`;
+}
+
+// ../../lib/agents/coding/promptCache.ts
+import { createHash as createHash2 } from "crypto";
+import { promises as fs10 } from "fs";
+function promptSha(parts) {
+  const h = createHash2("sha256");
+  for (const p of parts) {
+    h.update(p ?? "");
+    h.update("\0");
+  }
+  return h.digest("hex").slice(0, 16);
+}
+async function reusableOutput(outPath, sha, valid, key = "promptSha") {
+  try {
+    const o = JSON.parse(await fs10.readFile(outPath, "utf8"));
+    if (o[key] === sha && valid(o)) return o;
+  } catch {
+  }
+  return null;
+}
+
 // ../../scripts/coding-gap.mts
-var CODING = ".data/coding";
+var CODING = CODING_DIR;
 var CONFIG = {
   interface: "Claude Code INSIDE the Claude Desktop Mac app (NOT a raw terminal) \u2014 so terminal-only advice like `claude -p` does not fit; give desktop-app actions.",
   permissions: "`--dangerously-skip-permissions` is ON. They are NOT worried about destructive actions (never happened; they just revert). Do NOT raise auto mode or any permissions change \u2014 it is not in the catalog.",
@@ -16958,7 +17054,7 @@ var CLAUDE_AUTO_CAP = /* @__PURE__ */ new Set(["queue-ahead", "deferred-tools",
 var CLAUDE_AUTO_MCP = /^(visualize|Claude[_ ]?Preview|ccd[_ ]?session|ccd[_ ]?session[_ ]?mgmt|mcp[_ ]?registry)$/i;
 async function entrypointOf(file2) {
   try {
-    const head = (await fs9.readFile(file2, "utf8")).slice(0, 2e4);
+    const head = (await fs11.readFile(file2, "utf8")).slice(0, 2e4);
     if (/[\/."]\.?conductor/i.test(head)) return "conductor";
     const m = /"entrypoint":"([^"]+)"/.exec(head);
     return m ? m[1] : "unknown";
@@ -16980,14 +17076,14 @@ var MOBILE_WEB = /^claude-(web|mobile|ios|android)$/;
 function sumTool(recs, name17) {
   return recs.reduce((a, s) => a + (s.toolCounts?.[name17] ?? 0), 0);
 }
-var LOCK = path12.join(CODING, ".gap.lock");
+var LOCK = path13.join(CODING, ".gap.lock");
 var lockHeld = false;
 async function acquireLock() {
   try {
-    await fs9.writeFile(LOCK, String(process.pid), { flag: "wx" });
+    await fs11.writeFile(LOCK, String(process.pid), { flag: "wx" });
     lockHeld = true;
   } catch {
-    const pid = await fs9.readFile(LOCK, "utf8").catch(() => "?");
+    const pid = await fs11.readFile(LOCK, "utf8").catch(() => "?");
     throw new Error(`another coding-gap run appears active (pid ${pid}, ${LOCK}). Wait for it or delete the lock if it's stale \u2014 concurrent runs overwrite each other's gap.json.`);
   }
 }
@@ -16996,9 +17092,9 @@ async function main() {
   const p = await compileCodingProfile();
   const techniquesAsset = await readCodingAsset("TECHNIQUES.md");
   const techniques = techniquesAsset.text;
-  console.log(`  rubric: ${techniquesAsset.path} (${(await fs9.stat(techniquesAsset.path)).mtime.toISOString()})`);
+  console.log(`  rubric: ${techniquesAsset.path} (${(await fs11.stat(techniquesAsset.path)).mtime.toISOString()})`);
   const writing = (await readCodingAsset("WRITING.md")).text;
-  const all = JSON.parse(await fs9.readFile(path12.join(CODING, "sessions.json"), "utf8"));
+  const all = JSON.parse(await fs11.readFile(path13.join(CODING, "sessions.json"), "utf8"));
   const interactive = all.filter((s) => s.klass === "interactive" && s.start);
   const latestMs = Math.max(...interactive.map((s) => Date.parse(s.start)));
   const cutoffMs = latestMs - 14 * 864e5;
@@ -17055,7 +17151,7 @@ async function main() {
     return m ? `--- "${s.title}" \xB7 ${(s.start || "").slice(0, 10)} ---
 ${m.text.slice(0, 3e3)}` : "";
   }))).filter(Boolean);
-  const SYS = "You are a Claude Code power-user coach. You judge ONE person against the COMPLETE catalog of best ways to use Claude Code (the rubric below, sourced from Boris Cherny + first-party Claude Code features) and write a comprehensive, honest gap analysis, ORDERED most-difference-making \u2192 least. Rules: (1) Go through the whole catalog and surface the techniques they are NOT doing (or under-using) that would genuinely help \u2014 respecting each tip's [EMPHASIZE]/[DE-EMPHASIZE]/[GATE] curation. (2) ORDER by differenceRank (1 = biggest unlock for THIS person). Follow the rubric's PRIME DIRECTIVE: if usage.parallelism.alreadyParallel is FALSE \u2192 'Do more in parallel' is rank 1; else \u2192 'Invest in your CLAUDE.md / tune your context' is rank 1. Then Plan mode, then 'Give Claude test cases so it can auto-verify and run longer' (Boris's 'most important thing' \u2014 rank it high, right after plan mode), then subagents, and the rest per the rubric order, skipping any that don't apply. (3) GATE the conditional tips on the STRUCTURAL usage facts, NOT on keywords \u2014 and a tip whose gate FAILS is OMITTED from recommendations entirely, never included as a softened/conditional card (recommending something their data says doesn't apply, or that they already do, reads as not having looked): loops require real PR/branch volume in usage.collaboration, else OMIT; the Chrome tip requires ~zero browser-driving in usage.chrome, else OMIT and credit in alreadyStrong; forking uses the RECENT count in usage.forking \u2014 if they fork in the recent window they already do it, OMIT and credit; remote/mobile/EC2 fires only when usage.surface.workstationBound is TRUE; plan mode by usage.planMode; subagents by usage.subagents. If they already do a thing, it goes in alreadyStrong, NOT in recommendations. (4) \u26D4 CRITICAL \u2014 this person BUILDS Claude Code tooling, so their transcripts are full of the words 'worktree', 'pull request', 'fork', 'plan mode', 'by the way', 'teleport'. A keyword in the transcript is NOT evidence they use the feature. Rely on the STRUCTURAL facts only. (5) Ground every recommendation in a RECEIPT \u2014 a structural fact from their usage or a concrete session pain point \u2014 and CONVINCE with a specific case for how it helps THIS person, not a generic benefit. (6) Tailor every action to the Claude Desktop Mac app; NEVER give terminal-only `claude -p` advice. (7) Honor config.deliberateChoices (they stay on `main` on purpose \u2014 do NOT tell them to hand-juggle worktrees; parallel SESSIONS instead) and config.claudeAutoTools (never tell them to 'use' a tool Claude drives itself; for 'explain with visuals' the user just ASKS for a visual \u2014 do not name the tool). (8) Also name what they ALREADY do well. (9) SELF-CONTAINED but not verbose \u2014 lead with the PROBLEM, then the SOLUTION, then HOW to use it in their context. Plain language, no jargon, no enumerating multiple dates. An essay-like rec is a failed rec; so is a cryptic one. Follow this writing rubric strictly:\n\n" + writing;
+  const SYS = "You are a Claude Code power-user coach. You judge ONE person against the COMPLETE catalog of best ways to use Claude Code (the rubric below, sourced from Boris Cherny + first-party Claude Code features) and write a comprehensive, honest gap analysis, ORDERED most-difference-making \u2192 least. Rules: (1) Go through the whole catalog and surface the techniques they are NOT doing (or under-using) that would genuinely help \u2014 respecting each tip's [EMPHASIZE]/[DE-EMPHASIZE]/[GATE] curation. (2) ORDER by differenceRank (1 = biggest unlock for THIS person). Follow the rubric's PRIME DIRECTIVE: if usage.parallelism.alreadyParallel is FALSE \u2192 'Do more in parallel' is rank 1; else \u2192 'Invest in your CLAUDE.md / tune your context' is rank 1. Then Plan mode, then 'Give Claude test cases so it can auto-verify and run longer' (Boris's 'most important thing' \u2014 rank it high, right after plan mode), then subagents, and the rest per the rubric order, skipping any that don't apply. (3) GATE the conditional tips on the STRUCTURAL usage facts, NOT on keywords \u2014 and a tip whose gate FAILS is OMITTED from recommendations entirely, never included as a softened/conditional card (recommending something their data says doesn't apply, or that they already do, reads as not having looked): loops require real PR/branch volume in usage.collaboration, else OMIT; the Chrome tip requires ~zero browser-driving in usage.chrome, else OMIT and credit in alreadyStrong; forking uses the RECENT count in usage.forking \u2014 if they fork in the recent window they already do it, OMIT and credit; remote/mobile/EC2 fires only when usage.surface.workstationBound is TRUE; plan mode by usage.planMode; subagents by usage.subagents. If they already do a thing, it goes in alreadyStrong, NOT in recommendations. (4) \u26D4 CRITICAL \u2014 this person BUILDS Claude Code tooling, so their transcripts are full of the words 'worktree', 'pull request', 'fork', 'plan mode', 'by the way', 'teleport'. A keyword in the transcript is NOT evidence they use the feature. Rely on the STRUCTURAL facts only. (5) Ground every recommendation in a RECEIPT \u2014 a structural fact from their usage or a concrete session pain point \u2014 and CONVINCE with a specific case for how it helps THIS person, not a generic benefit. (6) Tailor every action to the Claude Desktop Mac app; NEVER give terminal-only `claude -p` advice. (7) Honor config.deliberateChoices (they stay on `main` on purpose \u2014 do NOT tell them to hand-juggle worktrees; parallel SESSIONS instead) and config.claudeAutoTools (never tell them to 'use' a tool Claude drives itself; for 'explain with visuals' the user just ASKS for a visual \u2014 do not name the tool). (8) Also name what they ALREADY do well. (9) SELF-CONTAINED but not verbose \u2014 lead with the PROBLEM, then the SOLUTION, then HOW to use it in their context. Plain language, no jargon, no enumerating multiple dates. An essay-like rec is a failed rec; so is a cryptic one. Follow this writing rubric strictly:\n\n" + writing + sourceLookupNote();
   const prompt = `THE RUBRIC \u2014 the complete catalog of best ways to use Claude Code. Judge the person against ALL of it, and ORDER by differenceRank per its PRIME DIRECTIVE:
 
 ${techniques}
@@ -17076,18 +17172,23 @@ Produce the gap analysis. Be thorough: cover every relevant catalog item they're
 }
 \`\`\`
 \`differenceRank\` is a strict 1..N ordering (1 = highest). Assign it per the PRIME DIRECTIVE and the rubric's general order; the report renders recommendations sorted by it. \`payoff\` (1-5) is a secondary strength cue. Recommend ONLY from the catalog.`;
-  console.log("gap \u2014 1 Sonnet pass over the full TECHNIQUES.md catalog + structural usage");
+  const sha = promptSha([SYS, prompt, "sonnet"]);
+  if (!process.argv.includes("--refresh")) {
+    const prev = await reusableOutput(path13.join(CODING, "gap.json"), sha, (o) => Array.isArray(o.recommendations) && o.recommendations.length > 0);
+    if (prev) {
+      console.log(`[gap] inputs unchanged \u2014 reusing output from ${prev.generatedAt} (--refresh to regenerate)`);
+      return;
+    }
+  }
+  await ensureCodingDocs(CODING, all);
+  console.log("gap \u2014 1 Sonnet pass over the full TECHNIQUES.md catalog + structural usage (+source lookups)");
   console.log(`  signals: alreadyParallel=${alreadyParallel} planModeCalls=${planModeUses} forks=${forkCopies}/${all.length} featureBranches=${featureBranches.length} workstationBound=${workstationBound} chrome=${chromeToolUse}`);
-  const sandbox = await fs9.mkdtemp(path12.join(os2.tmpdir(), "gap-"));
   let out = { recommendations: [], alreadyStrong: [] };
   try {
-    const run2 = await invokeAgent({ prompt, systemPrompt: SYS, addDir: sandbox, allowedTools: ["Read"], maxTurns: 4, timeoutMs: 6e5, model: "sonnet" });
+    const run2 = await invokeAgent({ prompt, systemPrompt: SYS, addDir: CODING, allowedTools: ["Read", "Grep", "Glob"], maxTurns: 10, timeoutMs: 6e5, model: "sonnet" });
     out = run2.json || out;
   } catch (e) {
     console.log("ERR", e.message.slice(0, 160));
-  } finally {
-    await fs9.rm(sandbox, { recursive: true, force: true }).catch(() => {
-    });
   }
   if (Array.isArray(out.recommendations)) {
     out.recommendations = out.recommendations.map((r, i) => ({ r, i })).sort((a, b) => (a.r.differenceRank ?? 99) - (b.r.differenceRank ?? 99) || (b.r.payoff ?? 0) - (a.r.payoff ?? 0) || a.i - b.i).map((x) => x.r);
@@ -17095,14 +17196,14 @@ Produce the gap analysis. Be thorough: cover every relevant catalog item they're
   if (!Array.isArray(out.recommendations) || out.recommendations.length === 0) {
     throw new Error("gap run produced 0 recommendations \u2014 refusing to overwrite the existing gap.json. Re-run the builder.");
   }
-  const result = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...out };
-  await fs9.writeFile(path12.join(CODING, "gap.json"), JSON.stringify(result, null, 2));
+  const result = { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), promptSha: sha, ...out };
+  await fs11.writeFile(path13.join(CODING, "gap.json"), JSON.stringify(result, null, 2));
   console.log(`WROTE ${CODING}/gap.json \u2014 recommendations:${(out.recommendations || []).length} \xB7 alreadyStrong:${(out.alreadyStrong || []).length}`);
 }
 main().catch((e) => {
   console.error(e);
   process.exitCode = 1;
 }).finally(() => {
-  if (lockHeld) fs9.rm(LOCK, { force: true }).catch(() => {
+  if (lockHeld) fs11.rm(LOCK, { force: true }).catch(() => {
   });
 });