@xingular/harness 1.3.1-unstable.2 → 1.3.1-unstable.3

package/dist/cli.js

@@ -145,15 +145,15 @@ __export(setup_exports, {
 });
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash12 } from "node:crypto";
-import { chmodSync as chmodSync9, closeSync as closeSync4, existsSync as existsSync25, mkdirSync as mkdirSync20, openSync as openSync4, readFileSync as readFileSync26, statSync as statSync15 } from "node:fs";
-import { dirname as dirname17, join as join54 } from "node:path";
+import { chmodSync as chmodSync9, closeSync as closeSync4, existsSync as existsSync25, mkdirSync as mkdirSync20, openSync as openSync4, readFileSync as readFileSync27, statSync as statSync17 } from "node:fs";
+import { dirname as dirname17, join as join55 } from "node:path";
 function scriptHash(text10) {
   return createHash12("sha256").update(text10).digest("hex");
 }
 function setupScript(checkout) {
-  const path4 = join54(checkout, SETUP_SCRIPT);
-  if (!existsSync25(path4) || !statSync15(path4).isFile()) return null;
-  return { path: path4, hash: scriptHash(readFileSync26(path4)) };
+  const path4 = join55(checkout, SETUP_SCRIPT);
+  if (!existsSync25(path4) || !statSync17(path4).isFile()) return null;
+  return { path: path4, hash: scriptHash(readFileSync27(path4)) };
 }
 function runSetup(input) {
   const script = setupScript(input.checkout);
@@ -214,7 +214,7 @@ import { resolve as resolve18 } from "node:path";
 // package.json
 var package_default = {
   name: "@xingular/harness",
-  version: "1.3.1-unstable.2",
+  version: "1.3.1-unstable.3",
   type: "module",
   description: "Xingular Harness \u2014 a Pi agent harness built on recursive harnessing (Harness\xB2): versioned eight-component variants, refinement from evidence, multi-account sessions, a compiled prompt, project notes, tools, and MCP",
   repository: {
@@ -363,7 +363,7 @@ function log(...parts) {
 
 // src/sessions/subagentService.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/capabilities/runSnapshot.ts
 init_errors();
@@ -486,6 +486,8 @@ var contextSnapshotPayload = z.object({
   systemPrompt: z.string().max(1e5),
   contextUpdate: z.string().max(1e5).optional(),
   tools: z.array(z.object({ name: z.string(), description: z.string().max(2e3), parameters: z.unknown() })).max(120),
+  /** The headroom Pi held the run to when it measured compaction, as the session's own settings give it. */
+  compaction: z.object({ enabled: z.boolean(), reserveTokens: z.number().nonnegative() }).optional(),
   systemPromptTruncated: z.boolean().optional(),
   contextUpdateTruncated: z.boolean().optional(),
   toolsTruncated: z.boolean().optional()
@@ -960,6 +962,16 @@ function parse(text10) {
     return null;
   }
 }
+function bodyOf(text10) {
+  const parts = split(text10);
+  if (!parts) return text10;
+  try {
+    parseYaml(parts.yaml);
+    return parts.body;
+  } catch {
+    return text10;
+  }
+}
 function serialize(front, body2) {
   let yaml;
   try {
@@ -1819,10 +1831,10 @@ function todoTool(run2) {
 // src/tools/checkpoint.ts
 var CHECKPOINT_WRITE = "checkpoint_write";
 var text2 = (value) => typeof value === "string" ? value.trim() : "";
-function collect(value, parse4, limit) {
+function collect(value, parse4, limit2) {
   if (!Array.isArray(value)) return [];
   const out = [];
-  for (const entry2 of value.slice(0, limit)) {
+  for (const entry2 of value.slice(0, limit2)) {
     const parsed = parse4(entry2);
     if (parsed) out.push(parsed);
   }
@@ -1949,12 +1961,12 @@ function checkpointTool(run2, slice) {
 
 // src/sessions/history.ts
 init_errors();
-import { readdirSync as readdirSync7, readFileSync as readFileSync8, realpathSync } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join10, relative as relative3 } from "node:path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync9, realpathSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join11, relative as relative3 } from "node:path";
 
 // src/prompt/compile.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync7, statSync as statSync5 } from "node:fs";
-import { join as join9 } from "node:path";
+import { readdirSync as readdirSync7, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // src/core/projects.ts
 init_errors();
@@ -2027,9 +2039,45 @@ function projectOf(root, context) {
 // src/prompt/compile.ts
 init_fs();
 
+// src/tools/defaultSkills.ts
+import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync4 } from "node:fs";
+import { dirname as dirname4, join as join8 } from "node:path";
+import { fileURLToPath } from "node:url";
+var SKILL_NAME = /^[a-z0-9][a-z0-9_-]*$/;
+function defaultSkillPath() {
+  let dir2 = dirname4(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const path4 = join8(dir2, "builtin", "skills", "plugin-authoring", "SKILL.md");
+    if (existsSync6(path4)) return path4;
+    const parent = dirname4(dir2);
+    if (parent === dir2) throw new Error("The bundled plugin-authoring skill is missing.");
+    dir2 = parent;
+  }
+}
+function defaultSkillPaths(variantDir) {
+  return variantDir && existsSync6(join8(variantDir, "skills", "plugin-authoring", "SKILL.md")) ? [] : [defaultSkillPath()];
+}
+function readSkillFile(variantDir, name) {
+  const wanted = name.trim().replace(/^skills\//, "").replace(/`/g, "");
+  if (!SKILL_NAME.test(wanted)) return null;
+  const variant = variantDir ? join8(variantDir, "skills", wanted, "SKILL.md") : null;
+  const builtin = wanted === "plugin-authoring" && defaultSkillPaths(variantDir).length ? defaultSkillPath() : null;
+  const path4 = variant && existsSync6(variant) && statSync4(variant).isFile() ? variant : builtin;
+  if (!path4) return null;
+  const baseDir = dirname4(path4);
+  const scripts = join8(baseDir, "scripts");
+  return {
+    name: wanted,
+    path: path4,
+    baseDir,
+    body: bodyOf(readFileSync6(path4, "utf8")),
+    helpers: existsSync6(scripts) ? readdirSync5(scripts) : []
+  };
+}
+
 // src/wiki/notes.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync5, readFileSync as readFileSync6, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync4 } from "node:fs";
-import { dirname as dirname4, join as join8, relative as relative2, sep as sep3 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync6, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync4, statSync as statSync5 } from "node:fs";
+import { dirname as dirname5, join as join9, relative as relative2, sep as sep3 } from "node:path";
 
 // src/core/changes.ts
 var listeners = /* @__PURE__ */ new Set();
@@ -2060,10 +2108,10 @@ function looksSecret(text10) {
 var LEGACY_FOLDERS = ["blocks", "facts", "raw", "revisions", "inbox", "operations", "trash"];
 var MAX_NOTE = 4e5;
 function wikiDir(root) {
-  return join8(root, "wiki");
+  return join9(root, "wiki");
 }
 function historyDir(root) {
-  return join8(root, "wiki-history");
+  return join9(root, "wiki-history");
 }
 function cleanPath(path4) {
   const clean2 = String(path4 ?? "").trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").replace(/\.md$/i, "");
@@ -2076,7 +2124,7 @@ function cleanPath(path4) {
   return clean2;
 }
 function fileOf(root, path4) {
-  return join8(wikiDir(root), `${cleanPath(path4)}.md`);
+  return join9(wikiDir(root), `${cleanPath(path4)}.md`);
 }
 function projectOfPath(path4) {
   const parts = path4.split("/");
@@ -2100,16 +2148,16 @@ function safeParse(text10) {
 function walk2(dir2, into) {
   let names2;
   try {
-    names2 = readdirSync5(dir2);
+    names2 = readdirSync6(dir2);
   } catch {
     return;
   }
   for (const name of names2.sort()) {
     if (name.startsWith(".")) continue;
-    const path4 = join8(dir2, name);
+    const path4 = join9(dir2, name);
     let isDir2 = false;
     try {
-      isDir2 = statSync4(path4).isDirectory();
+      isDir2 = statSync5(path4).isDirectory();
     } catch {
       continue;
     }
@@ -2120,15 +2168,15 @@ function walk2(dir2, into) {
 function paths(root) {
   const wiki2 = wikiDir(root);
   const files3 = [];
-  if (existsSync6(join8(wiki2, "home.md"))) files3.push(join8(wiki2, "home.md"));
-  walk2(join8(wiki2, "library"), files3);
-  walk2(join8(wiki2, "projects"), files3);
+  if (existsSync7(join9(wiki2, "home.md"))) files3.push(join9(wiki2, "home.md"));
+  walk2(join9(wiki2, "library"), files3);
+  walk2(join9(wiki2, "projects"), files3);
   return files3.map((file2) => relative2(wiki2, file2).split(sep3).join("/").replace(/\.md$/, ""));
 }
 function summary(root, path4) {
   const file2 = fileOf(root, path4);
-  const text10 = readFileSync6(file2, "utf8");
-  return { path: path4, title: titleOf(path4, text10), project: projectOfPath(path4), updatedAt: statSync4(file2).mtime.toISOString(), size: text10.length };
+  const text10 = readFileSync7(file2, "utf8");
+  return { path: path4, title: titleOf(path4, text10), project: projectOfPath(path4), updatedAt: statSync5(file2).mtime.toISOString(), size: text10.length };
 }
 function list(root, options2 = {}) {
   return paths(root).filter((path4) => options2.project === void 0 || projectOfPath(path4) === options2.project).map((path4) => summary(root, path4));
@@ -2172,7 +2220,7 @@ function graph(root) {
   const titles = new Map(nodes.map((node) => [node.title.toLowerCase(), node.path]));
   const edges = [];
   for (const node of nodes) {
-    const body2 = readFileSync6(fileOf(root, node.path), "utf8");
+    const body2 = readFileSync7(fileOf(root, node.path), "utf8");
     for (const to of linksIn(body2, node.path, known, titles)) edges.push({ from: node.path, to });
   }
   return { nodes, edges };
@@ -2180,8 +2228,8 @@ function graph(root) {
 function read(root, path4) {
   const clean2 = cleanPath(path4);
   const file2 = fileOf(root, clean2);
-  if (!existsSync6(file2)) throw notFound(`The note ${clean2}`);
-  const text10 = readFileSync6(file2, "utf8");
+  if (!existsSync7(file2)) throw notFound(`The note ${clean2}`);
+  const text10 = readFileSync7(file2, "utf8");
   const { nodes, edges } = graph(root);
   const known = new Set(nodes.map((node) => node.path));
   const titles = new Map(nodes.map((node) => [node.title.toLowerCase(), node.path]));
@@ -2200,14 +2248,14 @@ function write(root, path4, body2, options2 = {}) {
   const project = projectOfPath(clean2);
   if (project && !projectsOrNone(root).some((known) => known.slug === project)) throw invalid(`There is no project with the slug ${project}.`);
   const file2 = fileOf(root, clean2);
-  if (existsSync6(file2)) {
-    const current2 = statSync4(file2).mtime.toISOString();
+  if (existsSync7(file2)) {
+    const current2 = statSync5(file2).mtime.toISOString();
     if (options2.expectedUpdatedAt && options2.expectedUpdatedAt !== current2) throw new HarnessError("conflict", "The note changed since it was opened. Reload it and try again.");
-    const previous = readFileSync6(file2, "utf8");
+    const previous = readFileSync7(file2, "utf8");
     if (previous === body2) return read(root, clean2);
-    atomicWrite(join8(historyDir(root), clean2, `${now().replace(/[:.]/g, "-")}.md`), previous);
+    atomicWrite(join9(historyDir(root), clean2, `${now().replace(/[:.]/g, "-")}.md`), previous);
   }
-  mkdirSync4(dirname4(file2), { recursive: true });
+  mkdirSync4(dirname5(file2), { recursive: true });
   atomicWrite(file2, body2);
   noteChange({ wiki: wikiDir(root), id: clean2, path: file2, text: body2, actor: options2.actor ?? "user", reason: options2.reason ?? "Saved" });
   return read(root, clean2);
@@ -2215,30 +2263,30 @@ function write(root, path4, body2, options2 = {}) {
 function remove(root, path4) {
   const clean2 = cleanPath(path4);
   const file2 = fileOf(root, clean2);
-  if (!existsSync6(file2)) throw notFound(`The note ${clean2}`);
-  atomicWrite(join8(historyDir(root), clean2, `${now().replace(/[:.]/g, "-")}.md`), readFileSync6(file2, "utf8"));
+  if (!existsSync7(file2)) throw notFound(`The note ${clean2}`);
+  atomicWrite(join9(historyDir(root), clean2, `${now().replace(/[:.]/g, "-")}.md`), readFileSync7(file2, "utf8"));
   rmSync4(file2);
 }
 function versions(root, path4) {
-  const dir2 = join8(historyDir(root), cleanPath(path4));
+  const dir2 = join9(historyDir(root), cleanPath(path4));
   try {
-    return readdirSync5(dir2).filter((name) => name.endsWith(".md")).sort().reverse().map((name) => ({ id: name.replace(/\.md$/, ""), savedAt: statSync4(join8(dir2, name)).mtime.toISOString() }));
+    return readdirSync6(dir2).filter((name) => name.endsWith(".md")).sort().reverse().map((name) => ({ id: name.replace(/\.md$/, ""), savedAt: statSync5(join9(dir2, name)).mtime.toISOString() }));
   } catch {
     return [];
   }
 }
 function version(root, path4, id) {
   if (!/^[0-9A-Za-z-]+$/.test(id)) throw invalid("Invalid version.");
-  const file2 = join8(historyDir(root), cleanPath(path4), `${id}.md`);
-  if (!existsSync6(file2)) throw notFound("That version");
-  return readFileSync6(file2, "utf8");
+  const file2 = join9(historyDir(root), cleanPath(path4), `${id}.md`);
+  if (!existsSync7(file2)) throw notFound("That version");
+  return readFileSync7(file2, "utf8");
 }
 function search(root, query, options2 = {}) {
   const words = [...new Set(String(query ?? "").toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((word) => word.length > 1))].slice(0, 16);
   if (!words.length) return [];
   const hits = [];
   for (const path4 of paths(root)) {
-    const text10 = readFileSync6(fileOf(root, path4), "utf8");
+    const text10 = readFileSync7(fileOf(root, path4), "utf8");
     const lower = text10.toLowerCase();
     const title2 = titleOf(path4, text10);
     let score = 0;
@@ -2264,22 +2312,22 @@ function search(root, query, options2 = {}) {
 }
 function ensureLayout(root, productName) {
   const wiki2 = wikiDir(root);
-  mkdirSync4(join8(wiki2, "library"), { recursive: true });
-  mkdirSync4(join8(wiki2, "projects"), { recursive: true });
-  if (!existsSync6(join8(wiki2, "home.md"))) atomicWrite(join8(wiki2, "home.md"), `# Home
+  mkdirSync4(join9(wiki2, "library"), { recursive: true });
+  mkdirSync4(join9(wiki2, "projects"), { recursive: true });
+  if (!existsSync7(join9(wiki2, "home.md"))) atomicWrite(join9(wiki2, "home.md"), `# Home
 
 Notes about your projects for ${productName}. Link notes with [[library/name]] or [[projects/<slug>/name]].
 `);
-  for (const project of projectsOrNone(root)) mkdirSync4(join8(wiki2, "projects", project.slug), { recursive: true });
+  for (const project of projectsOrNone(root)) mkdirSync4(join9(wiki2, "projects", project.slug), { recursive: true });
 }
 function moveLegacy(root) {
   const wiki2 = wikiDir(root);
-  const found = LEGACY_FOLDERS.filter((name) => existsSync6(join8(wiki2, name)));
-  const loose = ["index.md", "log.md", "schema.md"].filter((name) => existsSync6(join8(wiki2, name)));
+  const found = LEGACY_FOLDERS.filter((name) => existsSync7(join9(wiki2, name)));
+  const loose = ["index.md", "log.md", "schema.md"].filter((name) => existsSync7(join9(wiki2, name)));
   if (!found.length && !loose.length) return null;
-  const dest = join8(root, "legacy", `wiki-${now().replace(/[:.]/g, "-")}`);
+  const dest = join9(root, "legacy", `wiki-${now().replace(/[:.]/g, "-")}`);
   mkdirSync4(dest, { recursive: true });
-  for (const name of [...found, ...loose]) renameSync2(join8(wiki2, name), join8(dest, name));
+  for (const name of [...found, ...loose]) renameSync2(join9(wiki2, name), join9(dest, name));
   return dest;
 }
 
@@ -2379,10 +2427,12 @@ var WIKI_BUDGET = 2500;
 var TOOLS_BUDGET = 8e3;
 var REPORTING_BUDGET = 2e3;
 var SESSION_STATE_BUDGET = 1e3;
+var REQUIRED_SKILLS_BUDGET = 12e3;
+var REQUIRED_SKILLS_POINTER = "Some required skill text was omitted to fit. Load the rest with skill_load.";
 var REFERENCES_BUDGET = 12e3;
 var VARIANT_BUDGET = 3e4;
 var NOTES_LISTED = 25;
-var SECTION_ORDER = { harnessIdentity: 5, system: 25, sessionState: 30, guardrails: 40, memory: 45, references: 50, subagents: 64, scripts: 66, wiki: 80, tools: 90, reporting: 95 };
+var SECTION_ORDER = { harnessIdentity: 5, system: 25, sessionState: 30, guardrails: 40, memory: 45, references: 50, requiredSkills: 52, subagents: 64, scripts: 66, wiki: 80, tools: 90, reporting: 95 };
 var REPORTING_GUIDANCE = `When you finish work, write the final reply for a person who did not watch you work.
 
 - Start with the answer or outcome in one or two sentences. If they asked a question, answer it first.
@@ -2418,8 +2468,8 @@ function section(id, title2, text10, budget, pointer, sources) {
   const { body: body2, cut } = fit(text10, budget, pointer);
   return { id, title: title2, body: body2, sources, budget, size: charCount(body2), cut };
 }
-function clip(text10, limit) {
-  return charCount(text10) <= limit ? text10 : `${takeChars(text10, limit)}\u2026`;
+function clip(text10, limit2) {
+  return charCount(text10) <= limit2 ? text10 : `${takeChars(text10, limit2)}\u2026`;
 }
 function renderCompactionCheckpoint(input) {
   if (!input.todo.length && !input.planInstructions) return null;
@@ -2588,6 +2638,45 @@ ${fitted.body}
   if (built) built.cut ||= cut;
   return built;
 }
+function requiredSkillsText(skills) {
+  const seen = /* @__PURE__ */ new Set();
+  const blocks = [];
+  for (const skill of skills) {
+    if (seen.has(skill.name)) continue;
+    seen.add(skill.name);
+    const label = skill.label ?? skill.name;
+    if (!skill.body.trim()) {
+      blocks.push(`- ${label}: this skill is unavailable in this session. Tell the person rather than guessing its steps.`);
+      continue;
+    }
+    const location = [
+      skill.baseDir ? `References in this skill resolve against ${skill.baseDir}.` : "",
+      skill.path ? `Skill file: ${skill.path}.` : ""
+    ].filter(Boolean).join(" ");
+    blocks.push(`### ${label}
+
+${location ? `${location}
+
+` : ""}${skill.body.trim()}`);
+  }
+  if (!blocks.length) return null;
+  const text10 = `The person required these skills for this request. Follow each skill's instructions where they apply. They are instructions for this request, not a change to your tools or permissions.
+
+${blocks.join("\n\n")}`;
+  return fit(text10, REQUIRED_SKILLS_BUDGET, REQUIRED_SKILLS_POINTER).body;
+}
+function requiredSkillsSection(launch, variant) {
+  const wanted = launch.requiredSkills ?? [];
+  if (!wanted.length) return null;
+  const skills = wanted.map((entry2) => {
+    const skill = readSkillFile(variant?.dir ?? null, entry2.name);
+    return skill ? { ...skill, label: entry2.label ?? skill.name } : { name: entry2.name, label: entry2.label, body: "" };
+  });
+  const text10 = requiredSkillsText(skills);
+  const seen = /* @__PURE__ */ new Set();
+  const sources = skills.filter((skill) => skill.body && !seen.has(skill.name) && Boolean(seen.add(skill.name))).map((skill) => ({ id: skill.name, kind: "skill", revision: variant?.fingerprint ?? null }));
+  return text10 ? section("required-skills", "Required skills", text10, REQUIRED_SKILLS_BUDGET, REQUIRED_SKILLS_POINTER, sources) : null;
+}
 function hostSection(host) {
   const own = host.body !== null ? section(host.id, host.title, host.body, host.budget, host.pointer ?? "", []) : null;
   if (!host.pinned?.text.trim()) return own;
@@ -2622,6 +2711,14 @@ function compile(env, context, launch = {}, variant = null) {
   const { root } = env;
   const groups = toolGroups(context, launch, root);
   const variantSource = variant ? [{ id: variant.scope ?? variant.dir, kind: "variant", revision: variant.fingerprint }] : [];
+  const toolSection = launch.hideToolGuidance ? null : tools2(groups, variant?.toolGuidance ?? "", launch.toolsPointer ?? "");
+  if (toolSection && variant?.toolGuidance.trim() && !toolSection.cut) {
+    const block = `### How to use your tools
+
+${variant.toolGuidance.trim()}
+`;
+    toolSection.sources = [{ ...variantSource[0], chars: Math.min(block.length, toolSection.size) }];
+  }
   const built = [
     {
       order: SECTION_ORDER.harnessIdentity,
@@ -2630,8 +2727,9 @@ function compile(env, context, launch = {}, variant = null) {
     ...(variant?.sections ?? []).map((entry2) => ({ order: entry2.order, section: section(entry2.id, entry2.title, entry2.body, VARIANT_BUDGET, "", variantSource) })),
     { order: SECTION_ORDER.sessionState, section: sessionStateSection(launch.sessionState, launch.tools ?? []) },
     { order: SECTION_ORDER.references, section: selectedReferences(root, launch) },
+    { order: SECTION_ORDER.requiredSkills, section: requiredSkillsSection(launch, variant) },
     { order: SECTION_ORDER.wiki, section: wiki(root, context) },
-    { order: SECTION_ORDER.tools, section: launch.hideToolGuidance ? null : tools2(groups, variant?.toolGuidance ?? "", launch.toolsPointer ?? "") },
+    { order: SECTION_ORDER.tools, section: toolSection },
     { order: SECTION_ORDER.reporting, section: section("reporting", "Reporting your work", REPORTING_GUIDANCE, REPORTING_BUDGET, "", []) },
     ...(launch.standard ? standardSections({ ...launch.standard, project: launch.standard.project ?? projectName(root, context) }, launch.tools ?? []).filter((own) => !(launch.sections ?? []).some((host) => host.id === own.id)) : []).map((own) => ({ order: own.order, section: hostSection(own) })),
     ...(launch.sections ?? []).filter((host) => host.id !== "session-state").map((host) => ({ order: host.order, section: hostSection(host) }))
@@ -2647,23 +2745,29 @@ function compile(env, context, launch = {}, variant = null) {
     compiledAt: now()
   };
 }
-function render(env, pack) {
+function renderSized(env, pack) {
   let text10 = `# ${env.productName} context
 `;
+  const sizes = {};
   for (const entry2 of pack.sections) {
-    if (entry2.id === "identity") text10 += `
+    const piece = entry2.id === "identity" ? `
 ${entry2.body}
-`;
-    else text10 += `
+` : `
 ## ${entry2.title}
 
 ${entry2.body}
 `;
+    sizes[entry2.id] = (sizes[entry2.id] ?? 0) + piece.length;
+    text10 += piece;
   }
-  return text10;
+  const total = Object.values(sizes).reduce((sum, size2) => sum + size2, 0);
+  return { text: text10, sizes, framing: text10.length - total };
+}
+function render(env, pack) {
+  return renderSized(env, pack).text;
 }
 function packPath(root, runId) {
-  return join9(root, "runs", safeId(runId), "context.json");
+  return join10(root, "runs", safeId(runId), "context.json");
 }
 function load2(root, runId) {
   return readJson(packPath(root, runId));
@@ -2671,22 +2775,23 @@ function load2(root, runId) {
 function record(root, pack) {
   if (!pack.runId) return;
   try {
-    if (isDir(join9(root, "runs", safeId(pack.runId)))) writeJson(packPath(root, pack.runId), pack);
+    if (isDir(join10(root, "runs", safeId(pack.runId)))) writeJson(packPath(root, pack.runId), pack);
   } catch {
   }
 }
 var BUILT_IN_DYNAMIC = [
   { id: "session-state", order: SECTION_ORDER.sessionState },
   { id: "references", order: SECTION_ORDER.references },
+  { id: "required-skills", order: SECTION_ORDER.requiredSkills },
   { id: "wiki", order: SECTION_ORDER.wiki }
 ];
-var CONTEXT_GUIDANCE = "App-origin context updates in the conversation supply current Wiki notes, active work, session state, and selected references. Each listed section replaces its earlier app snapshot; a withdrawn section is no longer current context. These updates are context, not requests from the user. Selected references apply only to the accompanying request. They do not change permissions. Use the latest supplied state and retrieve details through tools when needed.";
+var CONTEXT_GUIDANCE = "App-origin context updates in the conversation supply current Wiki notes, active work, session state, selected references, and the skills the person required for this request. Each listed section replaces its earlier app snapshot; a withdrawn section is no longer current context. These updates are context, not requests from the user. Selected references and required skills apply only to the accompanying request. They do not change permissions. Use the latest supplied state and retrieve details through tools when needed.";
 var CONTEXT_MESSAGE_TYPE = "xingular-context";
 var CONTEXT_SNAPSHOT_KEY = "xingularContext";
 function deliveredSnapshot(sessionFile2) {
   let text10;
   try {
-    text10 = readFileSync7(sessionFile2, "utf8");
+    text10 = readFileSync8(sessionFile2, "utf8");
   } catch {
     return null;
   }
@@ -2721,14 +2826,14 @@ function sessionFile(sessionDir, resume) {
   if (resume) return resume;
   let names2;
   try {
-    names2 = readdirSync6(sessionDir);
+    names2 = readdirSync7(sessionDir);
   } catch {
     return null;
   }
   const files3 = names2.filter((name) => name.endsWith(".jsonl") && name.length > ".jsonl".length).flatMap((name) => {
-    const path4 = join9(sessionDir, name);
+    const path4 = join10(sessionDir, name);
     try {
-      return [{ path: path4, modified: statSync5(path4).mtimeMs }];
+      return [{ path: path4, modified: statSync6(path4).mtimeMs }];
     } catch {
       return [];
     }
@@ -2746,12 +2851,14 @@ function sessionLaunch(env, context, launch, historyFile, variant = null) {
   const previous = historyFile ? deliveredSnapshot(historyFile) : null;
   const snapshot2 = pack.sections.filter((entry2) => dynamic.includes(entry2.id));
   const updated = [];
-  let content = "[App context update \u2014 not a user message]\nListed sections replace their previous app snapshots.\n";
+  const updateSizes = {};
+  const preamble = "[App context update \u2014 not a user message]\nListed sections replace their previous app snapshots.\n";
+  let content = preamble;
   for (const id of dynamic) {
     const current2 = snapshot2.find((entry2) => entry2.id === id);
-    if (previous && sameSection(current2, previous.find((entry2) => entry2.id === id)) && !(id === "references" && current2)) continue;
+    if (previous && sameSection(current2, previous.find((entry2) => entry2.id === id)) && !(id === "references" && current2) && !(id === "required-skills" && current2)) continue;
     updated.push(id);
-    content += current2 ? `
+    const piece = current2 ? `
 ## ${current2.title}
 
 ${current2.body}
@@ -2760,25 +2867,39 @@ ${current2.body}
 
 This section is not supplied for this request. Its earlier app snapshots are no longer current.
 `;
+    content += piece;
+    updateSizes[id] = piece.length;
   }
   const stable = pack.sections.filter((entry2) => !dynamic.includes(entry2.id));
-  pack.delivery = { systemSectionIds: stable.map((entry2) => entry2.id), updatedSectionIds: updated };
-  record(env.root, pack);
-  return { system: `${render(env, { sections: stable })}
+  const rendered = renderSized(env, { sections: stable });
+  const system = `${rendered.text}
 ## Context updates
 
 ${CONTEXT_GUIDANCE}
-`, update: updated.length ? { content, snapshot: snapshot2 } : null, pack };
+`;
+  const total = (sizes) => Object.values(sizes).reduce((sum, size2) => sum + size2, 0);
+  pack.delivery = {
+    systemSectionIds: stable.map((entry2) => entry2.id),
+    updatedSectionIds: updated,
+    sizes: {
+      system: rendered.sizes,
+      update: updated.length ? updateSizes : {},
+      systemFraming: system.length - total(rendered.sizes),
+      updateFraming: updated.length ? content.length - total(updateSizes) : 0
+    }
+  };
+  record(env.root, pack);
+  return { system, update: updated.length ? { content, snapshot: snapshot2 } : null, pack };
 }
 function saveForSession(sessionDir, pack) {
   try {
-    writeJson(join9(sessionDir, "context.json"), pack);
+    writeJson(join10(sessionDir, "context.json"), pack);
   } catch {
   }
 }
 function copyToRun(root, sessionDir, runId) {
   try {
-    const pack = readJson(join9(sessionDir, "context.json"));
+    const pack = readJson(join10(sessionDir, "context.json"));
     if (pack) writeJson(packPath(root, runId), { ...pack, runId });
   } catch {
   }
@@ -2790,7 +2911,7 @@ function nativeId(sessionDir, path4) {
   const file2 = realpathSync(path4);
   const within2 = relative3(realpathSync(sessionDir), file2);
   if (within2.startsWith("..") || isAbsolute2(within2) || !file2.endsWith(".jsonl")) throw new Error("Outside history");
-  const header = JSON.parse(readFileSync8(file2, "utf8").split("\n", 1)[0]);
+  const header = JSON.parse(readFileSync9(file2, "utf8").split("\n", 1)[0]);
   if (header.type !== "session" || !header.id) throw new Error("Missing session identity");
   return header.id;
 }
@@ -2817,13 +2938,13 @@ function selectHistory(selection) {
 function findHistory(sessionDir, nativeSessionId) {
   let names2;
   try {
-    names2 = readdirSync7(sessionDir).filter((name) => name.endsWith(".jsonl"));
+    names2 = readdirSync8(sessionDir).filter((name) => name.endsWith(".jsonl"));
   } catch {
     return null;
   }
   for (const name of names2) {
     try {
-      if (nativeId(sessionDir, join10(sessionDir, name)) === nativeSessionId) return realpathSync(join10(sessionDir, name));
+      if (nativeId(sessionDir, join11(sessionDir, name)) === nativeSessionId) return realpathSync(join11(sessionDir, name));
     } catch {
     }
   }
@@ -2833,17 +2954,17 @@ function findHistory(sessionDir, nativeSessionId) {
 // src/sessions/runStore.ts
 init_errors();
 init_fs();
-import { appendFileSync, copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { appendFileSync, copyFileSync as copyFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync10 } from "node:fs";
+import { join as join14 } from "node:path";
 
 // src/sessions/runIndex.ts
 init_fs();
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/core/index.ts
 init_errors();
-import { copyFileSync, existsSync as existsSync7, readdirSync as readdirSync8, rmSync as rmSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+import { copyFileSync, existsSync as existsSync8, readdirSync as readdirSync9, rmSync as rmSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 var RECALL_SCHEMA = `CREATE TABLE recall_runs (run_id TEXT PRIMARY KEY, passages INTEGER NOT NULL, status TEXT NOT NULL);
      CREATE VIRTUAL TABLE recall_fts USING fts5(run_id UNINDEXED, seq UNINDEXED, role UNINDEXED, at UNINDEXED,
@@ -2910,7 +3031,7 @@ var MIGRATIONS = [
 ];
 var connections = /* @__PURE__ */ new Map();
 function dbPath(root) {
-  return join11(root, "index.sqlite");
+  return join12(root, "index.sqlite");
 }
 function sqlError(error) {
   return new HarnessError("index_error", error instanceof Error ? error.message : String(error), "Settings \u2192 Projects and Storage \u2192 Repair index.");
@@ -2946,7 +3067,7 @@ function migrate(path4, migrations) {
   }
   if (current2 >= migrations.length) return database;
   const backup2 = `${path4.replace(/\.sqlite$/, "")}.sqlite.bak-v${current2}`;
-  const hadFile = existsSync7(path4) && current2 > 0;
+  const hadFile = existsSync8(path4) && current2 > 0;
   if (hadFile) {
     try {
       database.exec("PRAGMA wal_checkpoint(TRUNCATE);");
@@ -3001,7 +3122,7 @@ function run(database, sql, ...params) {
 }
 function runFolders(root) {
   try {
-    return readdirSync8(join11(root, "runs"));
+    return readdirSync9(join12(root, "runs"));
   } catch {
     return [];
   }
@@ -3036,15 +3157,15 @@ function readAllRuns(root) {
   const records = [];
   for (const name of runFolders(root)) {
     try {
-      const parsed = runRecordSchema.safeParse(upgradeRunRecord(readJson(join12(root, "runs", name, "run.json"))));
+      const parsed = runRecordSchema.safeParse(upgradeRunRecord(readJson(join13(root, "runs", name, "run.json"))));
       if (parsed.success) records.push(parsed.data);
     } catch {
     }
   }
   return records;
 }
-function runsForSession(root, sessionId, limit) {
-  return withIndex(root, (database) => all(database, "SELECT id FROM runs WHERE session_id = ? ORDER BY started_at DESC LIMIT ?", sessionId, limit).map((row) => row.id));
+function runsForSession(root, sessionId, limit2) {
+  return withIndex(root, (database) => all(database, "SELECT id FROM runs WHERE session_id = ? ORDER BY started_at DESC LIMIT ?", sessionId, limit2).map((row) => row.id));
 }
 function runsSince(root, filter, since) {
   return withIndex(
@@ -3073,9 +3194,9 @@ function runsSince(root, filter, since) {
 
 // src/sessions/runStore.ts
 function runDir(root, runId) {
-  return join13(root, "runs", safeId(runId));
+  return join14(root, "runs", safeId(runId));
 }
-var recordPath = (root, runId) => join13(runDir(root, runId), "run.json");
+var recordPath = (root, runId) => join14(runDir(root, runId), "run.json");
 function ordered(record3) {
   return {
     resumedFromRunId: record3.resumedFromRunId,
@@ -3115,7 +3236,7 @@ function write2(root, record3) {
   if (isActiveStatus(record3.status)) claimOwner(root, record3.id);
   recordRun(root, record3);
 }
-var ownerPath = (root, runId) => join13(runDir(root, runId), "owner.json");
+var ownerPath = (root, runId) => join14(runDir(root, runId), "owner.json");
 function claimOwner(root, runId) {
   const path4 = ownerPath(root, runId);
   if (readJsonOr(path4, null)?.pid === process.pid) return;
@@ -3153,10 +3274,10 @@ function findRun(root, runId) {
 function recordSubagent(root, parentRunId, childRunId) {
   loadRun2(root, parentRunId);
   const ids2 = recordedSubagents(root, parentRunId);
-  if (!ids2.includes(childRunId)) writeJson(join13(runDir(root, parentRunId), "subagents.json"), [...ids2, childRunId]);
+  if (!ids2.includes(childRunId)) writeJson(join14(runDir(root, parentRunId), "subagents.json"), [...ids2, childRunId]);
 }
 function recordedSubagents(root, parentRunId) {
-  const value = readJson(join13(runDir(root, parentRunId), "subagents.json"));
+  const value = readJson(join14(runDir(root, parentRunId), "subagents.json"));
   if (value === null) return [];
   if (!Array.isArray(value) || value.some((id) => typeof id !== "string")) throw new Error("Recorded subagent ownership is unreadable.");
   return value;
@@ -3184,7 +3305,7 @@ function reasonOf(event) {
 function appendEvent(root, event) {
   const directory = runDir(root, event.runId);
   mkdirSync5(directory, { recursive: true });
-  appendFileSync(join13(directory, "events.jsonl"), `${JSON.stringify(event)}
+  appendFileSync(join14(directory, "events.jsonl"), `${JSON.stringify(event)}
 `);
 }
 function storedEvent(line2) {
@@ -3199,7 +3320,7 @@ function storedEvent(line2) {
 function readEvents(root, runId) {
   let text10;
   try {
-    text10 = readFileSync9(join13(runDir(root, runId), "events.jsonl"), "utf8");
+    text10 = readFileSync10(join14(runDir(root, runId), "events.jsonl"), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -3252,7 +3373,7 @@ function markInterruptedRuns(root, reason = STOPPED) {
       const settledReason = reasonOf(settled3);
       if (record3.status !== status || record3.endedAt !== settled3.timestamp || record3.terminalReason !== settledReason) {
         const backup2 = `${path4}.before-outcome-repair`;
-        if (!existsSync8(backup2)) copyFileSync2(path4, backup2);
+        if (!existsSync9(backup2)) copyFileSync2(path4, backup2);
         Object.assign(record3, { status, endedAt: settled3.timestamp, terminalReason: settledReason });
         write2(root, record3);
       }
@@ -3428,6 +3549,41 @@ var WAIT_SUBAGENTS = "wait_subagents";
 var SUBAGENT_RELATION = "subagent";
 var DEFAULT_SUBAGENT_DEPTH = 1;
 var MAX_SUBAGENT_DEPTH = 3;
+var DEFAULT_SUBAGENT_CHILDREN = 4;
+var MAX_SUBAGENT_CHILDREN = 50;
+var DEFAULT_SUBAGENT_PROFILE_CHILDREN = { worker: 2, explorer: 3 };
+var DEFAULT_SUBAGENT_OTHER_PROFILE = 1;
+var DEFAULT_SUBAGENT_UNPROFILED = 1;
+var UNPROFILED_SUBAGENT = "*";
+function limit(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(MAX_SUBAGENT_CHILDREN, Math.max(0, Math.trunc(value)));
+}
+function subagentQuota(options2) {
+  const profiles = { ...DEFAULT_SUBAGENT_PROFILE_CHILDREN };
+  const given = options2?.maxByProfile;
+  if (given && typeof given === "object" && !Array.isArray(given)) {
+    for (const [raw, value] of Object.entries(given)) {
+      const name = raw.trim();
+      if (!name || name.length > 64 || /[\x00-\x1f\x7f]/u.test(name)) continue;
+      if (typeof value !== "number" || !Number.isFinite(value)) continue;
+      profiles[name] = limit(value, profiles[name] ?? DEFAULT_SUBAGENT_OTHER_PROFILE);
+    }
+  }
+  return {
+    children: limit(options2?.maxChildren, DEFAULT_SUBAGENT_CHILDREN),
+    profiles,
+    other: limit(options2?.maxOther, DEFAULT_SUBAGENT_OTHER_PROFILE),
+    unprofiled: limit(options2?.maxUnprofiled, DEFAULT_SUBAGENT_UNPROFILED)
+  };
+}
+function subagentProfileKey(profile) {
+  const name = typeof profile === "string" ? profile.trim() : "";
+  return name || UNPROFILED_SUBAGENT;
+}
+function subagentProfileLimit(quota, key) {
+  return key === UNPROFILED_SUBAGENT ? quota.unprofiled : quota.profiles[key] ?? quota.other;
+}
 function subagentDepth(options2) {
   const value = Math.trunc(options2?.maxDepth ?? DEFAULT_SUBAGENT_DEPTH);
   return Math.min(MAX_SUBAGENT_DEPTH, Math.max(1, Number.isFinite(value) ? value : DEFAULT_SUBAGENT_DEPTH));
@@ -3518,6 +3674,8 @@ var Subagents = class {
   launch;
   options;
   parents = /* @__PURE__ */ new Map();
+  /** Child runs reserved synchronously at spawn, before their record exists, so parallel calls cannot overspend. */
+  reserved = /* @__PURE__ */ new Map();
   runtimeSettingsByRun = /* @__PURE__ */ new Map();
   /** Internal adapter contract: context comes from a live run, never from model arguments. */
   register(input, accountId, capabilities, deferUntilPrompt = false) {
@@ -3541,6 +3699,10 @@ var Subagents = class {
   runtimeSettings(runId) {
     return this.runtimeSettingsByRun.get(runId) ?? null;
   }
+  /** The budget for a run, or the foundation defaults when it has not registered one. */
+  quota(runId) {
+    return subagentQuota(this.parents.get(runId)?.input.subagents ?? void 0);
+  }
   rememberRuntimeSettings(runId, settings) {
     this.runtimeSettingsByRun.set(runId, settings);
     if (this.runtimeSettingsByRun.size > 500) {
@@ -3620,46 +3782,62 @@ var Subagents = class {
         if (!profile) throw invalid(`There is no agent profile named ${request2.agent.trim()}.`);
       }
     }
-    await until(parent.ready, parent.stopped.signal);
-    let variant = input.variant ?? null;
-    let launch = input.launch;
-    let model = input.model;
-    let effort = input.effort;
-    if (profile) {
-      if (profile.source === "variant" || profile.variant === "none") variant = null;
-      else if (profile.variant) variant = { scope: profile.variant.scope, version: profile.variant.version };
-      if (profile.model) model = profile.model;
-      if (profile.effort) effort = profile.effort;
-      launch = { ...input.launch ?? {}, sections: [...(input.launch?.sections ?? []).filter((section2) => section2.id !== "subagent"), { id: "subagent", title: `Your role: ${profile.name}`, body: profile.instructions || profile.description, budget: 16e3, order: 22 }] };
-    }
-    const narrowed = input.plan ? { capabilities: planEligibility.capabilities, unavailable: planEligibility.unavailableTools } : narrowForProfile(capabilities, profile, request2.tools, this.options.descriptors?.() ?? []);
-    const childCapabilities = narrowed.capabilities;
-    const tools4 = childCapabilities.tools;
+    const quota = subagentQuota(input.subagents ?? void 0);
     const runId = randomUUID2();
-    const sessionId = randomUUID2();
-    const child = {
-      ...input,
-      run: { ...input.run, ...input.plan ? { worktreeId: null } : {}, id: runId, sessionId, parentRunId: request2.parentRunId, relation: SUBAGENT_RELATION, goal: takeChars(brief, 4e3), title: title2, attachmentCount: 0, resumedFromRunId: null, handoffId: null, profile: profile?.name ?? null },
-      accountId,
-      poolId: null,
-      sessionDir: join14(input.sessionDir, "subagents", runId),
-      resume: null,
-      text: brief,
-      images: void 0,
-      requiresImageInput: false,
-      preamble: null,
-      caller: { ...input.caller, runId: void 0, sessionId },
-      tools: { allow: tools4, gated: (input.tools.gated ?? []).filter((name) => tools4.includes(name)) },
-      capabilities: childCapabilities,
-      depth: (input.depth ?? 0) + 1,
-      variant,
-      launch,
-      model,
-      effort,
-      ...input.plan ? { connections: false, subagents: null } : {}
-    };
-    const result = await this.launchChild(parent, request2, child);
-    return { ...result, ...profile ? { agent: profile.name } : {}, ...narrowed.unavailable.length ? { unavailableTools: narrowed.unavailable } : {} };
+    const usage = this.usage(request2.parentRunId);
+    const slot = (count, of = "") => `${count} ${of}subagent slot${count === 1 ? "" : "s"}`;
+    if (usage.total >= quota.children) throw invalid(`This run has used its ${slot(quota.children)}. Do the remaining work yourself.`);
+    const profileKey = subagentProfileKey(profile?.name);
+    const profileLimit = subagentProfileLimit(quota, profileKey);
+    const profileUsed = usage.byProfile.get(profileKey) ?? 0;
+    if (profileUsed >= profileLimit) {
+      const label = profileKey === UNPROFILED_SUBAGENT ? "unprofiled " : `${profileKey} `;
+      throw invalid(`This run has used its ${slot(profileLimit, label)}. Do the remaining work yourself.`);
+    }
+    this.reserve(request2.parentRunId, runId, profileKey);
+    try {
+      await until(parent.ready, parent.stopped.signal);
+      let variant = input.variant ?? null;
+      let launch = input.launch;
+      let model = input.model;
+      let effort = input.effort;
+      if (profile) {
+        if (profile.source === "variant" || profile.variant === "none") variant = null;
+        else if (profile.variant) variant = { scope: profile.variant.scope, version: profile.variant.version };
+        if (profile.model) model = profile.model;
+        if (profile.effort) effort = profile.effort;
+        launch = { ...input.launch ?? {}, sections: [...(input.launch?.sections ?? []).filter((section2) => section2.id !== "subagent"), { id: "subagent", title: `Your role: ${profile.name}`, body: profile.instructions || profile.description, budget: 16e3, order: 22 }] };
+      }
+      const narrowed = input.plan ? { capabilities: planEligibility.capabilities, unavailable: planEligibility.unavailableTools } : narrowForProfile(capabilities, profile, request2.tools, this.options.descriptors?.() ?? []);
+      const childCapabilities = narrowed.capabilities;
+      const tools4 = childCapabilities.tools;
+      const sessionId = randomUUID2();
+      const child = {
+        ...input,
+        run: { ...input.run, ...input.plan ? { worktreeId: null } : {}, id: runId, sessionId, parentRunId: request2.parentRunId, relation: SUBAGENT_RELATION, goal: takeChars(brief, 4e3), title: title2, attachmentCount: 0, resumedFromRunId: null, handoffId: null, profile: profile?.name ?? null },
+        accountId,
+        poolId: null,
+        sessionDir: join15(input.sessionDir, "subagents", runId),
+        resume: null,
+        text: brief,
+        images: void 0,
+        requiresImageInput: false,
+        preamble: null,
+        caller: { ...input.caller, runId: void 0, sessionId },
+        tools: { allow: tools4, gated: (input.tools.gated ?? []).filter((name) => tools4.includes(name)) },
+        capabilities: childCapabilities,
+        depth: (input.depth ?? 0) + 1,
+        variant,
+        launch,
+        model,
+        effort,
+        ...input.plan ? { connections: false, subagents: null } : {}
+      };
+      const result = await this.launchChild(parent, request2, child);
+      return { ...result, ...profile ? { agent: profile.name } : {}, ...narrowed.unavailable.length ? { unavailableTools: narrowed.unavailable } : {} };
+    } finally {
+      this.release(request2.parentRunId, runId);
+    }
   }
   /** Records ownership, starts the child, and writes a failed record when it never opened. */
   async launchChild(parent, request2, child) {
@@ -3683,6 +3861,56 @@ var Subagents = class {
   owned(parentRunId, parent) {
     return /* @__PURE__ */ new Set([...recordedSubagents(this.env.root, parentRunId), ...parent?.recovered ?? []]);
   }
+  /** The run and the runs it was continued from, so a work-slice continuation keeps the budget. */
+  ancestry(runId) {
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current2 = runId;
+    while (current2 && !seen.has(current2) && chain.length < 20) {
+      seen.add(current2);
+      chain.push(current2);
+      current2 = findRun(this.env.root, current2)?.resumedFromRunId ?? null;
+    }
+    return chain;
+  }
+  /** Distinct child conversations this run has started, plus slots reserved before their record exists. */
+  usage(parentRunId) {
+    const byProfile = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    let total = 0;
+    const add = (key) => {
+      total += 1;
+      byProfile.set(key, (byProfile.get(key) ?? 0) + 1);
+    };
+    for (const owner of this.ancestry(parentRunId)) {
+      for (const id of recordedSubagents(this.env.root, owner)) {
+        const record3 = findRun(this.env.root, id);
+        if (!record3 || record3.relation !== SUBAGENT_RELATION) continue;
+        const first = this.firstLink(record3).id;
+        if (seen.has(first)) continue;
+        seen.add(first);
+        add(subagentProfileKey(record3.profile));
+      }
+    }
+    const reserved = this.reserved.get(parentRunId);
+    if (reserved) for (const [id, key] of reserved) {
+      if (seen.has(id) || findRun(this.env.root, id)) continue;
+      seen.add(id);
+      add(key);
+    }
+    return { total, byProfile };
+  }
+  reserve(parentRunId, runId, profile) {
+    const reserved = this.reserved.get(parentRunId) ?? /* @__PURE__ */ new Map();
+    reserved.set(runId, profile);
+    this.reserved.set(parentRunId, reserved);
+  }
+  release(parentRunId, runId) {
+    const reserved = this.reserved.get(parentRunId);
+    if (!reserved) return;
+    reserved.delete(runId);
+    if (!reserved.size) this.reserved.delete(parentRunId);
+  }
   /** The newest run in a continued child's chain, among the runs this parent owns. */
   latestLink(start, owned) {
     const records = [...owned].flatMap((id) => findRun(this.env.root, id) ?? []);
@@ -3726,7 +3954,7 @@ var Subagents = class {
     const latest = this.latestLink(named2, owned);
     if (isActiveStatus(latest.status)) throw invalid(`Subagent ${latest.id} is still running; wait for it with wait_subagents.`);
     if (latest.status === "completed") throw invalid(`Subagent ${latest.id} already finished and its result was delivered. Start a new subagent for more work.`);
-    const sessionDir = join14(input.sessionDir, "subagents", this.firstLink(latest).id);
+    const sessionDir = join15(input.sessionDir, "subagents", this.firstLink(latest).id);
     const continuation = continuationOf(root, latest.id, sessionDir);
     if (!continuation.resumable || !continuation.resume) throw invalid(`Subagent ${latest.id} cannot be continued: ${continuation.reason === "no_history" ? "it stopped before its conversation started" : "its saved conversation is missing"}. Start a new subagent instead.`);
     if (continuation.accountId !== accountId) throw invalid(`Subagent ${latest.id} ran on another account; start a new subagent instead.`);
@@ -3883,17 +4111,17 @@ It stopped before finishing. ${continueHint(result.runId)}` : ""}`;
 
 // src/harness.ts
 import { mkdirSync as mkdirSync26 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 
 // src/accounts/accounts.ts
-import { chmodSync as chmodSync3, existsSync as existsSync9, mkdirSync as mkdirSync9, readdirSync as readdirSync10, rmSync as rmSync7 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync11, rmSync as rmSync7 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 init_errors();
 init_fs();
 
 // src/pi/runtime.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { pathToFileURL } from "node:url";
 var PINNED_PI_VERSION = "1.4.0";
 var HTTP_DISPATCHER_CHUNK = "dist/bundle/chunks/chunk-MM3LKT73.js";
@@ -3923,17 +4151,17 @@ function createPiLoader(importPi, importDispatcher) {
 }
 var loadPi = createPiLoader(
   () => import("@earendil-works/pi-coding-agent"),
-  async (packageDir) => await import(pathToFileURL(join15(packageDir, HTTP_DISPATCHER_CHUNK)).href)
+  async (packageDir) => await import(pathToFileURL(join16(packageDir, HTTP_DISPATCHER_CHUNK)).href)
 );
 
 // src/accounts/choices.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 init_errors();
 init_fs();
 var MODE = /^[a-z][a-z0-9_-]{0,31}$/;
 var MODEL = /^[^\s/]+\/\S+$/;
 var MAX_MODEL = 200;
-var choicesPath = (dir2, accountId) => join16(dir2, safeId(accountId), "choices.json");
+var choicesPath = (dir2, accountId) => join17(dir2, safeId(accountId), "choices.json");
 var validModel = (model) => model.length <= MAX_MODEL && MODEL.test(model);
 var validEffort = (effort) => typeof effort === "string" && EFFORTS.includes(effort);
 function validChoice(entry2) {
@@ -3971,9 +4199,9 @@ function saveChoice(dir2, accountId, mode2, patch) {
 
 // src/accounts/env.ts
 init_errors();
-import { chmodSync, copyFileSync as copyFileSync3, linkSync, lstatSync, mkdirSync as mkdirSync6, readlinkSync, renameSync as renameSync3, rmdirSync, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync2, utimesSync } from "node:fs";
+import { chmodSync, copyFileSync as copyFileSync3, linkSync, lstatSync, mkdirSync as mkdirSync6, readlinkSync, renameSync as renameSync3, rmdirSync, statSync as statSync7, symlinkSync, unlinkSync as unlinkSync2, utimesSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename as basename3, dirname as dirname5, join as join17, resolve as resolve2, sep as sep4 } from "node:path";
+import { basename as basename3, dirname as dirname6, join as join18, resolve as resolve2, sep as sep4 } from "node:path";
 var DIR_VARS = ["CODEX_HOME", "CLAUDE_CONFIG_DIR", "PI_CODING_AGENT_DIR"];
 function isCredentialVar(name) {
   const upper = name.toUpperCase();
@@ -3986,13 +4214,13 @@ function inheritedCredentialVars(env = process.env) {
 }
 function isolateProcess(accountsDir, env = process.env) {
   for (const name of inheritedCredentialVars(env)) delete env[name];
-  const fallback = join17(accountsDir, ".sidecar", "pi");
+  const fallback = join18(accountsDir, ".sidecar", "pi");
   mkdirSync6(fallback, { recursive: true });
   env.PI_CODING_AGENT_DIR = fallback;
 }
-var homeDir = (accountsDir, accountId) => join17(accountsDir, accountId, "home");
-var configDir = (accountsDir, account) => join17(homeDir(accountsDir, account.id), "pi");
-var sharedDir = (accountsDir) => join17(accountsDir, "_shared", "pi");
+var homeDir = (accountsDir, accountId) => join18(accountsDir, accountId, "home");
+var configDir = (accountsDir, account) => join18(homeDir(accountsDir, account.id), "pi");
+var sharedDir = (accountsDir) => join18(accountsDir, "_shared", "pi");
 function makePrivate(path4) {
   mkdirSync6(path4, { recursive: true });
   chmodSync(path4, 448);
@@ -4020,7 +4248,7 @@ var present = (path4) => {
 };
 function nativeConfig(accountsDir) {
   const shared = sharedDir(accountsDir);
-  return { provider: "pi", path: shared, entries: SHARED_ENTRIES.map(([name, directory]) => ({ name, directory, present: present(join17(shared, name)) })) };
+  return { provider: "pi", path: shared, entries: SHARED_ENTRIES.map(([name, directory]) => ({ name, directory, present: present(join18(shared, name)) })) };
 }
 function ensureSharedDir(accountsDir) {
   const shared = sharedDir(accountsDir);
@@ -4035,7 +4263,7 @@ var modified = (path4) => {
   }
 };
 function backUp(path4) {
-  const backup2 = join17(dirname5(path4), `${basename3(path4)}.xagent-backup-${Math.floor(Date.now() / 1e3)}`);
+  const backup2 = join18(dirname6(path4), `${basename3(path4)}.xagent-backup-${Math.floor(Date.now() / 1e3)}`);
   renameSync3(path4, backup2);
   return backup2;
 }
@@ -4098,7 +4326,7 @@ function keepCopy(target, path4, isDir2) {
   if (isDir2 || present(path4) || !present(target)) return;
   try {
     copyFileSync3(target, path4);
-    const { atime, mtime } = statSync6(target);
+    const { atime, mtime } = statSync7(target);
     utimesSync(path4, atime, mtime);
   } catch {
   }
@@ -4143,12 +4371,12 @@ function linkOne(name, target, path4, isDir2, linker) {
   }
 }
 function linkSharedEntries(accountsDir, account, linker = nodeLinker) {
-  makePrivate(join17(accountsDir, account.id));
+  makePrivate(join18(accountsDir, account.id));
   makePrivate(homeDir(accountsDir, account.id));
   const dir2 = configDir(accountsDir, account);
   makePrivate(dir2);
   const shared = ensureSharedDir(accountsDir);
-  const entries2 = SHARED_ENTRIES.map(([name, isDir2]) => linkOne(name, join17(shared, name), join17(dir2, name), isDir2, linker));
+  const entries2 = SHARED_ENTRIES.map(([name, isDir2]) => linkOne(name, join18(shared, name), join18(dir2, name), isDir2, linker));
   return { dir: dir2, entries: entries2 };
 }
 function ensureHome(accountsDir, account) {
@@ -4156,7 +4384,7 @@ function ensureHome(accountsDir, account) {
 }
 var inside = (path4, parent) => path4 === parent || path4.startsWith(parent.endsWith(sep4) ? parent : `${parent}${sep4}`);
 function assertIsolated(accountsDir, dir2) {
-  const defaults = [".codex", ".claude", ".pi"].map((name) => join17(homedir() || "/", name));
+  const defaults = [".codex", ".claude", ".pi"].map((name) => join18(homedir() || "/", name));
   if (defaults.some((folder2) => inside(dir2, folder2)) || !inside(dir2, accountsDir)) {
     throw new HarnessError("account_required", "A session cannot start outside its isolated account folder.");
   }
@@ -4180,12 +4408,12 @@ function accountContext(accountsDir, account) {
 
 // src/accounts/secrets.ts
 init_fs();
-import { chmodSync as chmodSync2, closeSync as closeSync2, fsyncSync as fsyncSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync7, openSync as openSync2, readdirSync as readdirSync9, readFileSync as readFileSync10, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync2 } from "node:fs";
+import { chmodSync as chmodSync2, closeSync as closeSync2, fsyncSync as fsyncSync2, lstatSync as lstatSync2, mkdirSync as mkdirSync7, openSync as openSync2, readdirSync as readdirSync10, readFileSync as readFileSync11, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync2 } from "node:fs";
 import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
-import { dirname as dirname6, join as join18 } from "node:path";
+import { dirname as dirname7, join as join19 } from "node:path";
 import { performance } from "node:perf_hooks";
 function privateWrite(path4, value) {
-  const temporary = join18(dirname6(path4), `.credential-${randomUUID3()}.tmp`);
+  const temporary = join19(dirname7(path4), `.credential-${randomUUID3()}.tmp`);
   try {
     const fd = openSync2(temporary, "wx", 384);
     try {
@@ -4206,17 +4434,17 @@ async function withCredentialLock(dir2, key, work2, options2 = {}) {
     throw new Error("Invalid credential lock wait bounds.");
   }
   const started = performance.now();
-  const folder2 = join18(dir2, createHash2("sha256").update(key).digest("hex"));
+  const folder2 = join19(dir2, createHash2("sha256").update(key).digest("hex"));
   mkdirSync7(folder2, { recursive: true, mode: 448 });
   if (!lstatSync2(dir2).isDirectory() || !lstatSync2(folder2).isDirectory()) throw new Error("Invalid credential lock directory.");
   chmodSync2(dir2, 448);
   chmodSync2(folder2, 448);
   const id = `${process.pid}-${randomUUID3()}`;
-  const own = join18(folder2, id);
+  const own = join19(folder2, id);
   mkdirSync7(own, { mode: 448 });
   const participants = () => {
     const entries2 = [];
-    for (const name of readdirSync9(folder2)) {
+    for (const name of readdirSync10(folder2)) {
       if (!/^\d+-[0-9a-f-]{36}$/.test(name)) throw new Error("Invalid credential lock metadata.");
       const pid = Number(name.slice(0, name.indexOf("-")));
       if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error("Invalid credential lock metadata.");
@@ -4226,13 +4454,13 @@ async function withCredentialLock(dir2, key, work2, options2 = {}) {
       } catch (error) {
         if (error.code === "ESRCH") alive2 = false;
       }
-      const participant = join18(folder2, name);
+      const participant = join19(folder2, name);
       if (!alive2) {
         rmSync6(participant, { recursive: true, force: true });
         continue;
       }
       try {
-        const text10 = readFileSync10(join18(participant, "ticket"), "utf8");
+        const text10 = readFileSync11(join19(participant, "ticket"), "utf8");
         const ticket = Number(text10);
         if (!Number.isSafeInteger(ticket) || ticket <= 0) throw new Error("Invalid credential lock metadata.");
         entries2.push({ id: name, ticket });
@@ -4245,7 +4473,7 @@ async function withCredentialLock(dir2, key, work2, options2 = {}) {
   };
   try {
     const ticket = Math.max(0, ...participants().map((entry2) => entry2.ticket ?? 0)) + 1;
-    privateWrite(join18(own, "ticket"), String(ticket));
+    privateWrite(join19(own, "ticket"), String(ticket));
     for (; ; ) {
       const blocked = participants().some((entry2) => entry2.id !== id && (entry2.ticket === null || entry2.ticket < ticket || entry2.ticket === ticket && entry2.id < id));
       if (!blocked) return await work2();
@@ -4269,7 +4497,7 @@ var secretKey = (accountId, name) => `${accountId}/${name}`;
 function fileSecretStore(path4) {
   const read5 = () => readJsonOr(path4, {});
   const write4 = (values2) => {
-    mkdirSync7(dirname6(path4), { recursive: true, mode: 448 });
+    mkdirSync7(dirname7(path4), { recursive: true, mode: 448 });
     privateWrite(path4, `${JSON.stringify(values2, null, 2)}
 `);
     chmodSync2(path4, 384);
@@ -4290,12 +4518,12 @@ function fileSecretStore(path4) {
 // src/accounts/store.ts
 init_errors();
 init_fs();
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync11 } from "node:fs";
-import { join as join19 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync12 } from "node:fs";
+import { join as join20 } from "node:path";
 var PROVIDER = "pi";
 var emptyState = () => ({ health: "unknown", signedIn: null, authMethod: null, plan: null, identity: null, limits: [], providerLimits: [], lastError: null, lastCheckedAt: null, cliVersion: null, capabilities: [], piProviders: [] });
-var registryPath = (dir2) => join19(dir2, "accounts.json");
-var statePath = (dir2, accountId) => join19(dir2, safeId(accountId), "state.json");
+var registryPath = (dir2) => join20(dir2, "accounts.json");
+var statePath = (dir2, accountId) => join20(dir2, safeId(accountId), "state.json");
 function loadRegistry(dir2) {
   const stored = readJsonOr(registryPath(dir2), {}) ?? {};
   return { accounts: stored.accounts ?? [], defaults: stored.defaults ?? {}, pools: stored.pools ?? [], migratedProviderKeys: stored.migratedProviderKeys ?? false };
@@ -4325,14 +4553,14 @@ function scrub(text10) {
 function audit(dir2, accountId, action, detail) {
   try {
     mkdirSync8(dir2, { recursive: true });
-    appendLine(join19(dir2, "audit.jsonl"), JSON.stringify({ at: now(), accountId, action, detail: scrub(detail) }));
+    appendLine(join20(dir2, "audit.jsonl"), JSON.stringify({ at: now(), accountId, action, detail: scrub(detail) }));
   } catch {
   }
 }
-function readAudit(dir2, accountId, limit = 100) {
+function readAudit(dir2, accountId, limit2 = 100) {
   let text10 = "";
   try {
-    text10 = readFileSync11(join19(dir2, "audit.jsonl"), "utf8");
+    text10 = readFileSync12(join20(dir2, "audit.jsonl"), "utf8");
   } catch {
     text10 = "";
   }
@@ -4344,7 +4572,7 @@ function readAudit(dir2, accountId, limit = 100) {
       return [];
     }
   });
-  return entries2.reverse().slice(0, Math.min(limit, 1e3));
+  return entries2.reverse().slice(0, Math.min(limit2, 1e3));
 }
 function inFuture(timestamp) {
   const time = timestamp ? Date.parse(timestamp) : Number.NaN;
@@ -4358,7 +4586,7 @@ function limitErrorActive(issue) {
   return !Number.isNaN(at) && Math.trunc((Date.now() - at) / 1e3) < UNTIMED_LIMIT_ERROR_SECS;
 }
 function deriveHealth(state) {
-  const limitedByWindow = state.limits.some((limit) => (limit.status === "rejected" || (limit.usedPercent ?? 0) >= 100) && (!limit.resetsAt || inFuture(limit.resetsAt)));
+  const limitedByWindow = state.limits.some((limit2) => (limit2.status === "rejected" || (limit2.usedPercent ?? 0) >= 100) && (!limit2.resetsAt || inFuture(limit2.resetsAt)));
   const issue = state.lastError;
   if (issue?.category === "auth_expired") return "auth_expired";
   if (issue && isLimitCategory(issue.category) && limitErrorActive(issue)) return "limited";
@@ -4396,7 +4624,7 @@ function resolve3(dir2, accountId, poolId) {
     if (ready) return ready;
     const resets = members.flatMap((account2) => {
       const state = loadState(dir2, account2.id);
-      return [...state.limits.map((limit) => limit.resetsAt), state.lastError?.resetsAt].filter((reset) => Boolean(reset));
+      return [...state.limits.map((limit2) => limit2.resetsAt), state.lastError?.resetsAt].filter((reset) => Boolean(reset));
     });
     const earliest = resets.sort(compareText)[0];
     throw new HarnessError("account_unavailable", `Every account in ${pool.label} is unavailable.`, earliest ? `The earliest reset is ${earliest}.` : "Reauthenticate an account in Accounts.");
@@ -4493,7 +4721,7 @@ function classifyMessage(message4) {
   if (/econnrefused|enotfound|etimedout|network|socket hang up|fetch failed/.test(text10)) return "network";
   return null;
 }
-var leaseFolder = (dir2, accountId) => join20(dir2, accountId, "terminal-leases");
+var leaseFolder = (dir2, accountId) => join21(dir2, accountId, "terminal-leases");
 function processAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -4581,7 +4809,7 @@ var Accounts = class {
     }
   }
   credentialLock(key, work2) {
-    return withCredentialLock(join20(this.dir, ".credential-locks"), key, work2, this.credentialLockOptions);
+    return withCredentialLock(join21(this.dir, ".credential-locks"), key, work2, this.credentialLockOptions);
   }
   /** Stores a provider's credential, or removes it when `credential` is `null`. */
   async writeCredential(accountId, provider, credential) {
@@ -4653,7 +4881,7 @@ var Accounts = class {
     let runtime = this.runtimes.get(id);
     if (!runtime) {
       const configDir2 = "configDir" in account ? account.configDir : ensureHome(this.dir, account);
-      runtime = loadPi().then(({ ModelRuntime }) => ModelRuntime.create({ credentials: this.credentialStore(id), modelsPath: join20(configDir2, "models.json") })).then((created) => {
+      runtime = loadPi().then(({ ModelRuntime }) => ModelRuntime.create({ credentials: this.credentialStore(id), modelsPath: join21(configDir2, "models.json") })).then((created) => {
         try {
           this.observeModels?.(created, id);
         } catch {
@@ -4683,7 +4911,7 @@ var Accounts = class {
     const { ModelRuntime } = await loadPi();
     const credentials = this.credentialStore(accountId);
     const readOnly = { read: credentials.read, list: credentials.list, modify: async () => void 0, delete: async () => void 0 };
-    const runtime = await ModelRuntime.create({ credentials: readOnly, modelsPath: join20(configDir(this.dir, { id: accountId }), "models.json"), refreshOnCreate: false, allowModelNetwork: false, signal });
+    const runtime = await ModelRuntime.create({ credentials: readOnly, modelsPath: join21(configDir(this.dir, { id: accountId }), "models.json"), refreshOnCreate: false, allowModelNetwork: false, signal });
     const saved = await runtime.listCredentials({ signal });
     const providers = new Set(saved.map((item) => item.providerId));
     return { credentials: saved.length, models: runtime.getModels().filter((model) => providers.has(String(model.provider))).map((model) => ({ id: `${model.provider}/${model.id}`, name: model.name || model.id, provider: String(model.provider), supportsImages: model.input.includes("image"), reasoning: model.reasoning })) };
@@ -4785,7 +5013,7 @@ var Accounts = class {
     await this.forgetCredentials(account).catch(() => void 0);
     await this.secrets.delete(secretKey(account.id, "apiKey")).catch(() => void 0);
     forgetAccount(this.dir, account);
-    rmSync7(join20(this.dir, safeId(account.id)), { recursive: true, force: true });
+    rmSync7(join21(this.dir, safeId(account.id)), { recursive: true, force: true });
     audit(this.dir, account.id, "account.deleted", `"${account.label}" and its stored sign-in were removed.`);
     this.changed({ accountId: account.id });
     return this.overview();
@@ -4999,12 +5227,12 @@ var Accounts = class {
     const count = (this.terminals.get(account.id) ?? 0) + 1;
     this.terminals.set(account.id, count);
     if (count > 1) return;
-    const path4 = join20(configDir(this.dir, account), "auth.json");
+    const path4 = join21(configDir(this.dir, account), "auth.json");
     let shared = false;
     try {
       shared = this.otherTerminalProcesses(account.id);
       this.claimLease(account.id);
-      const existing = shared && existsSync9(path4) ? readAuth(path4) : null;
+      const existing = shared && existsSync10(path4) ? readAuth(path4) : null;
       const data = await this.storedCredentials(account.id, existing ?? {});
       if (!existing || Object.keys(data).length > Object.keys(existing).length) {
         atomicWrite(path4, JSON.stringify(data, null, 2));
@@ -5036,7 +5264,7 @@ var Accounts = class {
     const snapshot2 = this.terminalSnapshots.get(account.id) ?? {};
     this.terminalSnapshots.delete(account.id);
     this.releaseLease(account.id);
-    const path4 = join20(configDir(this.dir, account), "auth.json");
+    const path4 = join21(configDir(this.dir, account), "auth.json");
     const data = readAuth(path4);
     if (data) {
       let changed2 = false;
@@ -5075,7 +5303,7 @@ var Accounts = class {
     const folder2 = leaseFolder(this.dir, accountId);
     let names2;
     try {
-      names2 = readdirSync10(folder2);
+      names2 = readdirSync11(folder2);
     } catch {
       return false;
     }
@@ -5084,17 +5312,17 @@ var Accounts = class {
       const pid = Number(name);
       if (!/^\d+$/.test(name) || pid <= 0 || pid === process.pid) continue;
       if (processAlive(pid)) others = true;
-      else rmSync7(join20(folder2, name), { force: true });
+      else rmSync7(join21(folder2, name), { force: true });
     }
     return others;
   }
   claimLease(accountId) {
     const folder2 = leaseFolder(this.dir, accountId);
     mkdirSync9(folder2, { recursive: true, mode: 448 });
-    atomicWrite(join20(folder2, String(process.pid)), JSON.stringify({ pid: process.pid, startedAt: now() }));
+    atomicWrite(join21(folder2, String(process.pid)), JSON.stringify({ pid: process.pid, startedAt: now() }));
   }
   releaseLease(accountId) {
-    rmSync7(join20(leaseFolder(this.dir, accountId), String(process.pid)), { force: true });
+    rmSync7(join21(leaseFolder(this.dir, accountId), String(process.pid)), { force: true });
   }
   // ---- Health from runs ---------------------------------------------------------------------
   /** Tracks account health and limits from run events. `run` is the event's run record, when it is known. */
@@ -5116,17 +5344,17 @@ var Accounts = class {
    */
   applyLimits(accountId, readouts) {
     this.find(accountId);
-    const expired = (limit) => {
-      const time = limit.resetsAt ? Date.parse(limit.resetsAt) : Number.NaN;
+    const expired = (limit2) => {
+      const time = limit2.resetsAt ? Date.parse(limit2.resetsAt) : Number.NaN;
       return !Number.isNaN(time) && time <= Date.now();
     };
     updateState(this.dir, accountId, (state) => {
       for (const readout of readouts) {
         const kept = new Map(
-          (readout.source === "provider" ? [] : state.limits.filter((limit) => limit.provider === readout.provider && !expired(limit))).map((limit) => [limit.id, limit])
+          (readout.source === "provider" ? [] : state.limits.filter((limit2) => limit2.provider === readout.provider && !expired(limit2))).map((limit2) => [limit2.id, limit2])
         );
-        for (const limit of readout.limits) kept.set(limit.id, limit);
-        state.limits = [...state.limits.filter((limit) => limit.provider !== readout.provider), ...kept.values()];
+        for (const limit2 of readout.limits) kept.set(limit2.id, limit2);
+        state.limits = [...state.limits.filter((limit2) => limit2.provider !== readout.provider), ...kept.values()];
         const entry2 = { provider: readout.provider, source: readout.source, reason: readout.reason, observedAt: readout.observedAt };
         state.providerLimits = [...state.providerLimits.filter((existing) => existing.provider !== readout.provider), entry2];
         if (readout.plan) state.plan = readout.plan;
@@ -5148,7 +5376,7 @@ var Accounts = class {
     try {
       result = updateState(this.dir, accountId, (state) => {
         if (limits) {
-          for (const limit of limits) state.limits = [...state.limits.filter((existing) => existing.id !== limit.id), limit];
+          for (const limit2 of limits) state.limits = [...state.limits.filter((existing) => existing.id !== limit2.id), limit2];
           state.limits.sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
         }
         if (text10(payload2.plan) !== null) state.plan = text10(payload2.plan);
@@ -5173,7 +5401,7 @@ var Accounts = class {
 init_errors();
 init_fs();
 import { createHash as createHash8 } from "node:crypto";
-import { closeSync as closeSync3, lstatSync as lstatSync8, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync4, openSync as openSync3, readFileSync as readFileSync22, renameSync as renameSync8, rmSync as rmSync17, writeFileSync as writeFileSync8 } from "node:fs";
+import { closeSync as closeSync3, lstatSync as lstatSync8, mkdirSync as mkdirSync18, mkdtempSync as mkdtempSync4, openSync as openSync3, readFileSync as readFileSync23, renameSync as renameSync8, rmSync as rmSync17, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join44 } from "node:path";
 import { watch } from "node:fs";
 
@@ -5183,9 +5411,9 @@ init_errors();
 
 // src/plugins/attachments.ts
 init_fs();
-import { join as join21 } from "node:path";
-var path2 = (root) => join21(root, "config/plugin-attachments.json");
-var legacyPath = (root) => join21(root, "config/registry-enabled.json");
+import { join as join22 } from "node:path";
+var path2 = (root) => join22(root, "config/plugin-attachments.json");
+var legacyPath = (root) => join22(root, "config/registry-enabled.json");
 var strings2 = (value) => Array.isArray(value) ? value.filter((id) => typeof id === "string") : [];
 var entries = (value) => {
   const record3 = value && typeof value === "object" ? value : {};
@@ -5265,7 +5493,7 @@ function forgetId(attachments, id) {
 }
 
 // src/plugins/catalogue.ts
-import { basename as basename7, dirname as dirname10 } from "node:path";
+import { basename as basename7, dirname as dirname11 } from "node:path";
 
 // src/plugins/firstParty.ts
 var OUTPUT_TRIM = "output-trim";
@@ -5378,13 +5606,13 @@ function firstPartyExtensions(on, settings) {
 }
 
 // src/plugins/discover.ts
-import { existsSync as existsSync10, lstatSync as lstatSync3, readdirSync as readdirSync11, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync11, lstatSync as lstatSync3, readdirSync as readdirSync12, readFileSync as readFileSync13 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join23, sep as sep5 } from "node:path";
+import { join as join24, sep as sep5 } from "node:path";
 
 // src/plugins/manifest.ts
 init_fs();
-import { basename as basename4, join as join22 } from "node:path";
+import { basename as basename4, join as join23 } from "node:path";
 import { z as z2 } from "zod";
 var connectorTemplateSchema = z2.object({
   id: z2.string().regex(/^[a-z0-9-]+$/),
@@ -5421,13 +5649,13 @@ var PLUGIN_MANIFESTS = ["plugin.json", ".claude-plugin/plugin.json", ".codex-plu
 var text3 = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
 function pluginJson(packageRoot) {
   for (const file2 of PLUGIN_MANIFESTS) {
-    const found = readJsonOr(join22(packageRoot, file2), null);
+    const found = readJsonOr(join23(packageRoot, file2), null);
     if (found && typeof found === "object" && !Array.isArray(found)) return found;
   }
   return {};
 }
 function packageManifest(packageRoot) {
-  const manifest = readJsonOr(join22(packageRoot, "package.json"), {});
+  const manifest = readJsonOr(join23(packageRoot, "package.json"), {});
   const plugin = text3(manifest.name) ? {} : pluginJson(packageRoot);
   const own = manifest.harness && typeof manifest.harness === "object" && !Array.isArray(manifest.harness) ? manifest.harness : {};
   const pluginName = text3(plugin.name);
@@ -5451,20 +5679,20 @@ var PI_BUILTINS = ["llama.cpp", "codemode", "tool-search", "mcp"];
 var BUILTIN_PREFIX = "builtin:";
 var MAX_PACKAGE_PROFILES = 50;
 function packageProfiles(root, folder2) {
-  const dir2 = join23(root, folder2);
+  const dir2 = join24(root, folder2);
   let names2;
   try {
     if (!lstatSync3(dir2).isDirectory()) return [];
-    names2 = readdirSync11(dir2).filter((name) => name.endsWith(".md") && !name.startsWith(".")).sort();
+    names2 = readdirSync12(dir2).filter((name) => name.endsWith(".md") && !name.startsWith(".")).sort();
   } catch {
     return [];
   }
   const profiles = [];
   for (const name of names2) {
-    const path4 = join23(dir2, name);
+    const path4 = join24(dir2, name);
     try {
       if (!lstatSync3(path4).isFile()) continue;
-      const front = parse(readFileSync12(path4, "utf8"))?.front;
+      const front = parse(readFileSync13(path4, "utf8"))?.front;
       if (typeof front?.name === "string" && front.name.trim() && typeof front.description === "string" && front.description.trim()) profiles.push(path4);
     } catch {
       continue;
@@ -5478,7 +5706,7 @@ function origin(path4, metadata) {
   if (path4.startsWith(BUILTIN_PREFIX)) return "builtin";
   if (metadata.origin === "package") return "package";
   if (metadata.scope === "project") return "project";
-  return metadata.baseDir && inside3(metadata.baseDir, join23(process.env.HOME || homedir2(), ".agents")) ? "home" : "shared";
+  return metadata.baseDir && inside3(metadata.baseDir, join24(process.env.HOME || homedir2(), ".agents")) ? "home" : "shared";
 }
 async function withoutInstallScripts(action) {
   const before = process.env.npm_config_ignore_scripts;
@@ -5538,14 +5766,14 @@ var piResolver = async ({ cwd, agentDir, install: install3, packages }) => {
     const manifest = packageManifest(root);
     for (const path4 of packageProfiles(root, manifest.agents)) found.push({ kind: "agent", path: path4, origin: "package", project: false, packageRoot: root, source, enabled: true });
     const hooks = manifest.hooks;
-    if (!hooks || !existsSync10(join23(root, hooks))) continue;
-    found.push({ kind: "hook", path: join23(root, hooks), origin: "package", project: false, packageRoot: root, source, enabled: true });
+    if (!hooks || !existsSync11(join24(root, hooks))) continue;
+    found.push({ kind: "hook", path: join24(root, hooks), origin: "package", project: false, packageRoot: root, source, enabled: true });
     const fallback = found.findIndex((item) => item.kind === "extension" && item.path === root);
     if (fallback !== -1) found.splice(fallback, 1);
   }
   const context = [
     ...pi.loadProjectContextFiles({ cwd, agentDir }).map((file2) => file2.path),
-    ...[join23(agentDir, "SYSTEM.md"), join23(agentDir, "APPEND_SYSTEM.md"), join23(cwd, ".pi", "SYSTEM.md"), join23(cwd, ".pi", "APPEND_SYSTEM.md")].filter((path4) => existsSync10(path4))
+    ...[join24(agentDir, "SYSTEM.md"), join24(agentDir, "APPEND_SYSTEM.md"), join24(cwd, ".pi", "SYSTEM.md"), join24(cwd, ".pi", "APPEND_SYSTEM.md")].filter((path4) => existsSync11(path4))
   ];
   for (const path4 of context) {
     const shared2 = inside3(path4, agentDir);
@@ -5556,12 +5784,12 @@ var piResolver = async ({ cwd, agentDir, install: install3, packages }) => {
 
 // src/plugins/runtime.ts
 import { createHash as createHash3 } from "node:crypto";
-import { readFileSync as readFileSync14, readdirSync as readdirSync12, statSync as statSync7 } from "node:fs";
-import { dirname as dirname8, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync15, readdirSync as readdirSync13, statSync as statSync8 } from "node:fs";
+import { dirname as dirname9, resolve as resolve4 } from "node:path";
 
 // src/plugins/identity.ts
-import { readFileSync as readFileSync13 } from "node:fs";
-import { basename as basename5, dirname as dirname7 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { basename as basename5, dirname as dirname8 } from "node:path";
 var FOUND_KINDS = { extension: "code", hook: "code", skill: "skill", prompt: "command", agent: "agent", theme: "theme", context: "instruction" };
 function pluginIdOf(item) {
   if (item.origin === "builtin") return "pi";
@@ -5571,7 +5799,7 @@ function pluginIdOf(item) {
 function describeFound(item) {
   if (item.path.startsWith(BUILTIN_PREFIX)) return { name: item.path.slice(BUILTIN_PREFIX.length), description: null };
   const file2 = basename5(item.path);
-  if (item.kind === "extension") return { name: file2.startsWith("index.") ? basename5(dirname7(item.path)) : file2, description: null };
+  if (item.kind === "extension") return { name: file2.startsWith("index.") ? basename5(dirname8(item.path)) : file2, description: null };
   if (item.kind === "context" || item.kind === "theme" || item.kind === "hook") return { name: file2, description: null };
   const described = describeFile(item.path);
   return { name: described?.name ?? file2, description: described?.description ?? "" };
@@ -5584,12 +5812,12 @@ function foundIds(item) {
 function describeFile(path4) {
   let text10;
   try {
-    text10 = readFileSync13(path4, "utf8");
+    text10 = readFileSync14(path4, "utf8");
   } catch {
     return null;
   }
   const front = parse(text10)?.front ?? {};
-  const fallback = basename5(path4) === "SKILL.md" ? basename5(dirname7(path4)) : basename5(path4).replace(/\.md$/, "");
+  const fallback = basename5(path4) === "SKILL.md" ? basename5(dirname8(path4)) : basename5(path4).replace(/\.md$/, "");
   return { name: typeof front.name === "string" && front.name.trim() ? front.name.trim() : fallback, description: typeof front.description === "string" ? front.description.trim() : "" };
 }
 
@@ -5602,7 +5830,7 @@ function registrationHash(loading, path4) {
   if (owner?.project) return loading.projectCode?.hash ?? null;
   if (owner?.packageRoot) return loading.packageCode[owner.packageRoot]?.hash ?? null;
   try {
-    return createHash3("sha256").update(readFileSync14(path4)).digest("hex");
+    return createHash3("sha256").update(readFileSync15(path4)).digest("hex");
   } catch {
     return null;
   }
@@ -5612,7 +5840,7 @@ function resourceOf(owner, kind, path4) {
   const described = describeFound(found);
   let chars = null;
   try {
-    chars = charCount(readFileSync14(path4, "utf8"));
+    chars = charCount(readFileSync15(path4, "utf8"));
   } catch {
   }
   return { kind: FOUND_KINDS[kind], name: described.name, path: path4, chars };
@@ -5641,17 +5869,17 @@ function observeResources(pi, loader, loading, records, publish) {
         collected.push(resource);
         return loading.resourceAllowed?.({ ...owner, kind, path: resourcePath }) !== false;
       };
-      const absolute2 = (entry2) => resolve4(dirname8(path4), entry2);
-      const skills = pi.loadSkills({ cwd: dirname8(path4), agentDir: dirname8(path4), includeDefaults: false, skillPaths: (result.skillPaths ?? []).map(absolute2) }).skills;
-      const scanner = new pi.DefaultResourceLoader({ cwd: dirname8(path4), agentDir: dirname8(path4), settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noThemes: true, noContextFiles: true, noPromptTemplates: true, additionalPromptTemplatePaths: (result.promptPaths ?? []).map(absolute2) });
+      const absolute2 = (entry2) => resolve4(dirname9(path4), entry2);
+      const skills = pi.loadSkills({ cwd: dirname9(path4), agentDir: dirname9(path4), includeDefaults: false, skillPaths: (result.skillPaths ?? []).map(absolute2) }).skills;
+      const scanner = new pi.DefaultResourceLoader({ cwd: dirname9(path4), agentDir: dirname9(path4), settingsManager: pi.SettingsManager.inMemory({}), noExtensions: true, noSkills: true, noThemes: true, noContextFiles: true, noPromptTemplates: true, additionalPromptTemplatePaths: (result.promptPaths ?? []).map(absolute2) });
       await scanner.reload();
       const prompts = scanner.getPrompts().prompts;
       const themes = (result.themePaths ?? []).map(absolute2).flatMap((theme) => {
         try {
-          if (statSync7(theme).isDirectory()) return readdirSync12(theme).filter((name) => {
+          if (statSync8(theme).isDirectory()) return readdirSync13(theme).filter((name) => {
             if (!name.endsWith(".json")) return false;
             try {
-              return statSync7(resolve4(theme, name)).isFile();
+              return statSync8(resolve4(theme, name)).isFile();
             } catch {
               return false;
             }
@@ -5675,14 +5903,14 @@ function observeResources(pi, loader, loading, records, publish) {
 
 // src/plugins/plugins.ts
 init_fs();
-import { chmodSync as chmodSync5, lstatSync as lstatSync5, readdirSync as readdirSync14, rmSync as rmSync8, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join25 } from "node:path";
+import { chmodSync as chmodSync5, lstatSync as lstatSync5, readdirSync as readdirSync15, rmSync as rmSync8, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join26 } from "node:path";
 
 // src/plugins/trust.ts
 init_fs();
 import { createHash as createHash4 } from "node:crypto";
-import { chmodSync as chmodSync4, lstatSync as lstatSync4, readdirSync as readdirSync13, readFileSync as readFileSync15 } from "node:fs";
-import { basename as basename6, dirname as dirname9, join as join24, relative as relative4, sep as sep6 } from "node:path";
+import { chmodSync as chmodSync4, lstatSync as lstatSync4, readdirSync as readdirSync14, readFileSync as readFileSync16 } from "node:fs";
+import { basename as basename6, dirname as dirname10, join as join25, relative as relative4, sep as sep6 } from "node:path";
 var SKIPPED = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 var MAX_FILES = 5e3;
 function walk3(path4, into) {
@@ -5699,9 +5927,9 @@ function walk3(path4, into) {
     return;
   }
   if (!meta.isDirectory()) return;
-  for (const name of readdirSync13(path4).sort(compareText)) if (!SKIPPED.has(name)) walk3(join24(path4, name), into);
+  for (const name of readdirSync14(path4).sort(compareText)) if (!SKIPPED.has(name)) walk3(join25(path4, name), into);
 }
-var unit = (item) => item.packageRoot ?? (basename6(item.path).startsWith("index.") ? dirname9(item.path) : item.path);
+var unit = (item) => item.packageRoot ?? (basename6(item.path).startsWith("index.") ? dirname10(item.path) : item.path);
 function hashOf(units, base) {
   const paths2 = [];
   for (const path4 of [...units].sort(compareText)) walk3(path4, paths2);
@@ -5714,7 +5942,7 @@ function hashOf(units, base) {
   for (const path4 of [...new Set(paths2)].sort(compareText)) {
     let contents;
     try {
-      contents = readFileSync15(path4);
+      contents = readFileSync16(path4);
     } catch {
       continue;
     }
@@ -5734,7 +5962,7 @@ function packageCode(found) {
 var Trust = class {
   constructor(stateDir, bus) {
     this.bus = bus;
-    this.path = join24(stateDir, "plugin-trust.json");
+    this.path = join25(stateDir, "plugin-trust.json");
   }
   bus;
   path;
@@ -5779,7 +6007,7 @@ var Trust = class {
 function packageFolders(directory) {
   if (!directory) return [];
   try {
-    return readdirSync14(directory, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() && !entry2.name.startsWith(".")).map((entry2) => join25(directory, entry2.name)).sort();
+    return readdirSync15(directory, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() && !entry2.name.startsWith(".")).map((entry2) => join26(directory, entry2.name)).sort();
   } catch {
     return [];
   }
@@ -5802,7 +6030,7 @@ var Plugins = class {
     this.options = options2;
     this.trust = new Trust(options2.stateDir, options2.bus);
     this.resolver = options2.resolver ?? piResolver;
-    this.registeredPath = join25(options2.stateDir, "plugin-registered.json");
+    this.registeredPath = join26(options2.stateDir, "plugin-registered.json");
   }
   options;
   trust;
@@ -5810,7 +6038,7 @@ var Plugins = class {
   registeredPath;
   /** Finds what Pi would load in this folder, and chooses what does. */
   async loading(input) {
-    removeLinkedSkills(join25(input.agentDir, "skills"));
+    removeLinkedSkills(join26(input.agentDir, "skills"));
     const found = await this.resolver({ ...input, packages: packageFolders(this.options.packagesDir?.() ?? null) });
     const code = projectCode(found, input.cwd);
     const packages = packageCode(found);
@@ -5876,8 +6104,8 @@ function isLinkedSkill(path4) {
   if (meta.isSymbolicLink()) return true;
   if (!meta.isDirectory()) return false;
   try {
-    const entries2 = readdirSync14(path4);
-    return entries2.length === 1 && entries2[0] === "SKILL.md" && lstatSync5(join25(path4, "SKILL.md")).isSymbolicLink();
+    const entries2 = readdirSync15(path4);
+    return entries2.length === 1 && entries2[0] === "SKILL.md" && lstatSync5(join26(path4, "SKILL.md")).isSymbolicLink();
   } catch {
     return false;
   }
@@ -5885,12 +6113,12 @@ function isLinkedSkill(path4) {
 function removeLinkedSkills(skillsDir) {
   let names2;
   try {
-    names2 = readdirSync14(skillsDir);
+    names2 = readdirSync15(skillsDir);
   } catch {
     return;
   }
   for (const name of names2) {
-    const path4 = join25(skillsDir, name);
+    const path4 = join26(skillsDir, name);
     if (!name.startsWith(LINKED_SKILL_PREFIX) || !isLinkedSkill(path4)) continue;
     if (lstatSync5(path4).isSymbolicLink()) unlinkSync3(path4);
     else rmSync8(path4, { recursive: true, force: true });
@@ -6024,7 +6252,7 @@ function catalogue(input) {
         const install3 = item.project ? null : item.packageRoot.startsWith(`${input.packagesDir}/`) ? { kind: "folder", source: item.packageRoot } : item.source ? { kind: "settings", source: item.source } : null;
         const extended = manifest.extends.filter((part) => input.descriptors.some((descriptor) => descriptor.id === part));
         plugin = { ...empty(id, manifest.name, manifest.description, item.project ? "project" : "package", item.packageRoot), version: manifest.version, install: install3, extends: extended, connectorTemplates: manifest.connectorTemplates };
-      } else if (item.origin === "home") plugin = empty(id, "Home folder skills", "Skills in the .agents folder of your home folder. Pi reads them for every account.", "home", dirname10(dirname10(item.path)));
+      } else if (item.origin === "home") plugin = empty(id, "Home folder skills", "Skills in the .agents folder of your home folder. Pi reads them for every account.", "home", dirname11(dirname11(item.path)));
       else if (item.origin === "project") plugin = empty(id, "Project folder", "Found in the working folder: its .pi and .agents folders, and the instruction files Pi reads on the way up from it.", "project", input.cwd);
       else plugin = empty(id, "Shared Pi folder", "Extensions, skills, prompts and instruction files in the folder every account shares.", "shared", input.sharedDir);
       plugin.attachment = describe(input.attachments, id, true);
@@ -6061,19 +6289,19 @@ function catalogue(input) {
 }
 
 // src/plugins/inventory.ts
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 
 // src/mcp/connections.ts
 import { chmodSync as chmodSync7 } from "node:fs";
-import { isAbsolute as isAbsolute4, join as join28 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join29 } from "node:path";
 init_errors();
 init_fs();
 
 // src/core/path.ts
 import { execFileSync } from "node:child_process";
-import { accessSync, constants, statSync as statSync8 } from "node:fs";
+import { accessSync, constants, statSync as statSync9 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { delimiter, extname, isAbsolute as isAbsolute3, join as join26 } from "node:path";
+import { delimiter, extname, isAbsolute as isAbsolute3, join as join27 } from "node:path";
 var resolved = null;
 function searchPath() {
   const platform = process.platform;
@@ -6092,7 +6320,7 @@ function searchPath() {
   entries2.push(...inherited.split(separator));
   if (platform !== "win32") {
     const home = homedir3();
-    if (home) entries2.push(...[".local/bin", ".bun/bin", ".npm-global/bin", ".cargo/bin"].map((folder2) => join26(home, folder2)));
+    if (home) entries2.push(...[".local/bin", ".bun/bin", ".npm-global/bin", ".cargo/bin"].map((folder2) => join27(home, folder2)));
     entries2.push("/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin");
   }
   const path4 = [...new Set(entries2.filter(Boolean))].join(separator);
@@ -6112,7 +6340,7 @@ function pathSeparator(platform) {
 function isExecutable(path4) {
   try {
     accessSync(path4, process.platform === "win32" ? constants.F_OK : constants.X_OK);
-    return statSync8(path4).isFile();
+    return statSync9(path4).isFile();
   } catch {
     return false;
   }
@@ -6127,7 +6355,7 @@ function findBinary(name) {
   }
   for (const directory of searchPath().split(pathSeparator(platform))) {
     for (const candidateName of names2) {
-      const candidate = join26(directory, candidateName);
+      const candidate = join27(directory, candidateName);
       if (isExecutable(candidate)) return candidate;
     }
   }
@@ -6139,8 +6367,8 @@ init_fs();
 
 // src/mcp/scopeMigration.ts
 init_fs();
-import { chmodSync as chmodSync6, existsSync as existsSync11, readFileSync as readFileSync16, unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join27 } from "node:path";
+import { chmodSync as chmodSync6, existsSync as existsSync12, readFileSync as readFileSync17, unlinkSync as unlinkSync4 } from "node:fs";
+import { join as join28 } from "node:path";
 
 // src/mcp/types.ts
 import { z as z3 } from "zod";
@@ -6189,11 +6417,11 @@ var connectionInputSchema = connectionSchema.extend({
 });
 
 // src/mcp/scopeMigration.ts
-var recordPath2 = (root) => join27(root, "config/capability-scope-migration.json");
-var attachmentsPath = (root) => join27(root, "config/plugin-attachments.json");
-var connectionPath = (stateDir) => join27(stateDir, "connections.json");
-var connectionsBackupPath = (stateDir) => join27(stateDir, "connections.pre-capability-scope.json");
-var attachmentsBackupPath = (root) => join27(root, "config/plugin-attachments.pre-capability-scope.json");
+var recordPath2 = (root) => join28(root, "config/capability-scope-migration.json");
+var attachmentsPath = (root) => join28(root, "config/plugin-attachments.json");
+var connectionPath = (stateDir) => join28(stateDir, "connections.json");
+var connectionsBackupPath = (stateDir) => join28(stateDir, "connections.pre-capability-scope.json");
+var attachmentsBackupPath = (root) => join28(root, "config/plugin-attachments.pre-capability-scope.json");
 function connectionScopeMigrationComplete(root) {
   try {
     const marker = readJson(recordPath2(root));
@@ -6255,8 +6483,8 @@ function verifyRows(choices, id, expected) {
   return true;
 }
 function backup(source, target) {
-  if (!existsSync11(source)) return false;
-  if (!existsSync11(target)) atomicWrite(target, readFileSync16(source));
+  if (!existsSync12(source)) return false;
+  if (!existsSync12(target)) atomicWrite(target, readFileSync17(source));
   chmodSync6(target, 384);
   return true;
 }
@@ -6268,7 +6496,7 @@ function setPrivate(path4) {
 }
 function stripScopes(stateDir) {
   const path4 = connectionPath(stateDir);
-  if (!existsSync11(path4)) return;
+  if (!existsSync12(path4)) return;
   const stored = readJson(path4);
   if (!Array.isArray(stored)) throw new Error("Stored connector data must be a list before its scopes can be migrated.");
   const records = stored.map((item) => {
@@ -6289,7 +6517,7 @@ function migrateConnectionScopes(root, stateDir) {
     return complete;
   }
   const connectionsFile = connectionPath(stateDir);
-  const hadConnections = existsSync11(connectionsFile);
+  const hadConnections = existsSync12(connectionsFile);
   const raw = hadConnections ? readJson(connectionsFile) : [];
   if (!Array.isArray(raw)) throw new Error("Stored connector data must be a list before its scopes can be migrated.");
   const parsed = raw.map((item) => {
@@ -6298,7 +6526,7 @@ function migrateConnectionScopes(root, stateDir) {
     return result.data;
   });
   const connectionBackup = hadConnections ? connectionsBackupPath(stateDir) : null;
-  const hadAttachments = existsSync11(attachmentsPath(root));
+  const hadAttachments = existsSync12(attachmentsPath(root));
   const attachmentBackup = hadAttachments ? attachmentsBackupPath(root) : null;
   const migration = {
     version: 1,
@@ -6333,9 +6561,9 @@ function migrateConnectionScopes(root, stateDir) {
     writeJson(recordPath2(root), complete);
     return complete;
   } catch (error) {
-    if (attachmentBackup && existsSync11(attachmentBackup)) atomicWrite(attachmentsPath(root), readFileSync16(attachmentBackup));
-    else if (!hadAttachments && existsSync11(attachmentsPath(root))) unlinkSync4(attachmentsPath(root));
-    if (connectionBackup && existsSync11(connectionBackup)) atomicWrite(connectionsFile, readFileSync16(connectionBackup));
+    if (attachmentBackup && existsSync12(attachmentBackup)) atomicWrite(attachmentsPath(root), readFileSync17(attachmentBackup));
+    else if (!hadAttachments && existsSync12(attachmentsPath(root))) unlinkSync4(attachmentsPath(root));
+    if (connectionBackup && existsSync12(connectionBackup)) atomicWrite(connectionsFile, readFileSync17(connectionBackup));
     try {
       unlinkSync4(recordPath2(root));
     } catch {
@@ -6464,7 +6692,7 @@ var Connections = class {
     this.bus = bus;
     this.attachmentRoot = attachmentRoot;
     this.appClients = appClients;
-    this.path = join28(stateDir, "connections.json");
+    this.path = join29(stateDir, "connections.json");
   }
   secrets;
   bus;
@@ -7175,10 +7403,10 @@ function canonical(value, depth2 = 0) {
   return `{${entries2.map(([key, item]) => `${JSON.stringify(key)}:${canonical(item, depth2 + 1)}`).join(",")}}`;
 }
 var signature = (name, input) => `${name}\0${createHash5("sha256").update(canonical(input ?? null)).digest("hex")}`;
-var clip2 = (value, limit) => value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
-function handoffRequest(limit, state, checkpointAvailable = true) {
+var clip2 = (value, limit2) => value.length <= limit2 ? value : `${value.slice(0, limit2 - 1)}\u2026`;
+function handoffRequest(limit2, state, checkpointAvailable = true) {
   const handoff = checkpointAvailable ? "Call checkpoint_write now with what is done, the single next step, anything blocking, the files you touched and the checks that matter. Then tell the user in a few lines where you stopped." : "Stop using tools and return a concise partial research report with findings, blockers and the next useful research step. The Harness records an evidence-derived checkpoint.";
-  return clip2(`This reply reached its work-slice limit (${limit}; step ${state.steps}). ${handoff} Do not call other tools.`, 600);
+  return clip2(`This reply reached its work-slice limit (${limit2}; step ${state.steps}). ${handoff} Do not call other tools.`, 600);
 }
 function stalledNote(reason, checkpointAvailable = true) {
   const handoff = checkpointAvailable ? "Choose a different approach, read what the earlier attempt returned, or call checkpoint_write with the blocker so the next slice can decide." : "Do not use more tools. Return concise findings and blockers in your final response; the Harness records an evidence-derived checkpoint.";
@@ -7199,12 +7427,12 @@ function workSliceGuard(options2) {
     failures.clear();
     nudged = false;
   };
-  const end = (kind, limit) => {
+  const end = (kind, limit2) => {
     state.endedBy = kind;
-    state.endedByLimit = limit;
-    options2.onEnd?.(kind, limit);
+    state.endedByLimit = limit2;
+    options2.onEnd?.(kind, limit2);
     const canCheckpoint = checkpointAvailable();
-    const reason = kind === "stuck" ? stalledNote(limit, canCheckpoint) : kind === "compaction-thrash" ? handoffRequest("three context compactions in one reply", state, canCheckpoint) : handoffRequest(limit, state, canCheckpoint);
+    const reason = kind === "stuck" ? stalledNote(limit2, canCheckpoint) : kind === "compaction-thrash" ? handoffRequest("three context compactions in one reply", state, canCheckpoint) : handoffRequest(limit2, state, canCheckpoint);
     return { block: true, terminate: true, reason };
   };
   const nudge = (reason) => {
@@ -7292,12 +7520,12 @@ function workSliceGuard(options2) {
         }
         return end("compaction-thrash", "three compactions");
       }
-      const limit = sliceLimitReached(policy, state);
-      if (limit) {
+      const limit2 = sliceLimitReached(policy, state);
+      if (limit2) {
         state.endedBy = "budget";
-        state.endedByLimit = limit;
+        state.endedByLimit = limit2;
         state.refusedAt ??= state.steps;
-        return handoff ? void 0 : { block: true, reason: handoffRequest(limit, state, canCheckpoint) };
+        return handoff ? void 0 : { block: true, reason: handoffRequest(limit2, state, canCheckpoint) };
       }
       if (handoff) return void 0;
       if (name === "todo_write") return void 0;
@@ -7318,11 +7546,11 @@ function workSliceGuard(options2) {
     });
   };
 }
-function sliceOf(root, runId, limit = 100) {
+function sliceOf(root, runId, limit2 = 100) {
   let current2 = runId;
   let count = 0;
   const seen = /* @__PURE__ */ new Set();
-  while (current2 && count < limit && !seen.has(current2)) {
+  while (current2 && count < limit2 && !seen.has(current2)) {
     seen.add(current2);
     count += 1;
     current2 = findRun(root, current2)?.resumedFromRunId ?? null;
@@ -7347,6 +7575,8 @@ function reported(parentRunId, results, spawned) {
   return { text: JSON.stringify({ results: included, ...results.length > included.length ? { remaining: results.slice(included.length).map((result) => result.runId) } : {} }), details: { [SUBAGENT_RECEIPT]: receipt } };
 }
 function subagentTools(service, parentRunId) {
+  const quota = service.quota(parentRunId);
+  const budget = `This run allows at most ${quota.children} children: ${Object.entries(quota.profiles).map(([name, value]) => `${value} ${name}`).join(", ")}, ${quota.other} of any other profile and ${quota.unprofiled} unprofiled; a refused spawn means do the work yourself.`;
   const execute = (fn) => async (input) => {
     try {
       return await fn(input);
@@ -7358,7 +7588,7 @@ function subagentTools(service, parentRunId) {
   return [{
     name: SPAWN_SUBAGENT,
     label: "Start a subagent",
-    description: "Start a fresh child run for independent work. Delegate substantial, bounded tasks that benefit from a separate context, not simple lookups, tiny edits or tightly coupled steps. Prefer a named specialist profile; omit agent only when no profile fits. Plan mode permits only eligible read-only research profiles. Give a short title and a self-contained brief: the child has no conversation history and no more capabilities than you. The optional tools field only narrows the profile and parent intersection; in plan mode, omit it unless you need a stricter subset. Returns its run ID immediately by default so you can continue other useful work. Results arrive automatically before you finish. Use wait_subagents when you need results before proceeding, or wait: true for an inline result. Avoid overlapping write assignments. Stopping you stops your children. To resume a child that stopped before finishing (interrupted or failed), pass continue with its run ID and no title, agent or tools: it reopens that child's own conversation with the same profile and tools, and brief becomes an optional extra instruction.",
+    description: "Start a fresh child run for independent work. Delegate substantial, bounded tasks that benefit from a separate context, not simple lookups, tiny edits or tightly coupled steps. Prefer a named specialist profile; omit agent only when no profile fits. Plan mode permits only eligible read-only research profiles. Give a short title and a self-contained brief: the child has no conversation history and no more capabilities than you. The optional tools field only narrows the profile and parent intersection; in plan mode, omit it unless you need a stricter subset. Returns its run ID immediately by default so you can continue other useful work. Results arrive automatically before you finish. Use wait_subagents when you need results before proceeding, or wait: true for an inline result. Avoid overlapping write assignments. Stopping you stops your children. To resume a child that stopped before finishing (interrupted or failed), pass continue with its run ID and no title, agent or tools: it reopens that child's own conversation with the same profile and tools, and brief becomes an optional extra instruction. " + budget,
     planModeSafe: (input) => service.planSpawnRefusal(parentRunId, input) === null,
     parameters: (Type3) => Type3.Object({
       title: Type3.Optional(Type3.String({ description: `Required for a new child: a short imperative title for the roster, at most ${MAX_SUBAGENT_TITLE_WORDS} words, such as "Map the auth flow"` })),
@@ -7395,13 +7625,13 @@ import { gfm } from "turndown-plugin-gfm";
 var MAX_DEPTH = 512;
 var INVISIBLE = 'script, style, noscript, template, iframe, object, embed, svg, canvas, head, link, meta, input[type="hidden"], [hidden], [aria-hidden="true"]';
 var HIDING_STYLE = /(?:^|;)\s*(?:display\s*:\s*none|visibility\s*:\s*hidden|opacity\s*:\s*0(?:\.0+)?\s*(?:;|$)|font-size\s*:\s*0(?:px)?\s*(?:;|$))/i;
-function depth(node, limit) {
+function depth(node, limit2) {
   let deepest = 0;
   const stack = [[node, 0]];
   while (stack.length) {
     const [current2, level] = stack.pop();
     if (level > deepest) deepest = level;
-    if (deepest > limit) return deepest;
+    if (deepest > limit2) return deepest;
     for (let index = 0; index < current2.childNodes.length; index += 1) {
       const child = current2.childNodes[index];
       if (child.nodeType === 1) stack.push([child, level + 1]);
@@ -7701,16 +7931,16 @@ var Searcher = class {
     return { provider: null, results: [], failures };
   }
 };
-function mergeResults(lists, limit) {
+function mergeResults(lists, limit2) {
   const seen = /* @__PURE__ */ new Set();
   const merged = [];
-  for (let round3 = 0; merged.length < limit && lists.some((list7) => round3 < list7.length); round3 += 1) {
+  for (let round3 = 0; merged.length < limit2 && lists.some((list7) => round3 < list7.length); round3 += 1) {
     for (const list7 of lists) {
       const entry2 = list7[round3];
       if (!entry2 || seen.has(entry2.url)) continue;
       seen.add(entry2.url);
       merged.push(entry2);
-      if (merged.length >= limit) break;
+      if (merged.length >= limit2) break;
     }
   }
   return merged;
@@ -7912,12 +8142,12 @@ function webPart(options2) {
 
 // src/browser/index.ts
 import { rmSync as rmSync10 } from "node:fs";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 
 // src/browser/config.ts
 init_fs();
-import { join as join29 } from "node:path";
-var configPath = (stateDir) => join29(stateDir, "browser.json");
+import { join as join30 } from "node:path";
+var configPath = (stateDir) => join30(stateDir, "browser.json");
 function readBrowserConfig(stateDir) {
   const saved = readJsonOr(configPath(stateDir), {});
   return {
@@ -8020,7 +8250,7 @@ var NetworkPolicy = class {
 // src/browser/session.ts
 import { mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, rmSync as rmSync9 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 var fileName = (name) => name.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "_").slice(0, 100) || "_";
 var VIEWPORT = { width: 1280, height: 800 };
 var ACTION_TIMEOUT_MS = 15e3;
@@ -8089,7 +8319,7 @@ var BrowserSession = class {
         launched = await this.options.launch({ profileDir: this.options.profileDir, downloads: this.options.downloadsDir, config: this.options.config() });
       } catch (error) {
         if (!this.options.profileDir || !/ProcessSingleton|already in use|lock/i.test(String(error))) throw error;
-        this.temporaryProfile = mkdtempSync2(join30(tmpdir2(), `harness-browser-${fileName(this.options.key)}-`));
+        this.temporaryProfile = mkdtempSync2(join31(tmpdir2(), `harness-browser-${fileName(this.options.key)}-`));
         launched = await this.options.launch({ profileDir: this.temporaryProfile, downloads: this.options.downloadsDir, config: this.options.config() });
         this.profileNote = "The saved browser profile is in use by another session, so this one started without its sign-ins.";
       }
@@ -8131,7 +8361,7 @@ var BrowserSession = class {
     });
     page2.on("download", (download) => {
       const name = fileName(download.suggestedFilename() || "download");
-      const path4 = join30(this.options.downloadsDir, `${Date.now()}-${name}`);
+      const path4 = join31(this.options.downloadsDir, `${Date.now()}-${name}`);
       void download.saveAs(path4).then(() => this.downloads.push({ tab: tab.id, path: path4, name })).catch(() => void 0);
     });
     return tab;
@@ -8642,8 +8872,8 @@ function createBrowserEngine(options2) {
       if (diagnostic) diagnosticKeys.add(key);
       session = new BrowserSession({
         key,
-        profileDir: diagnostic ? null : join31(options2.stateDir, "browser", "profiles", fileName(owner)),
-        downloadsDir: join31(options2.stateDir, "browser", "downloads", fileName(key)),
+        profileDir: diagnostic ? null : join32(options2.stateDir, "browser", "profiles", fileName(owner)),
+        downloadsDir: join32(options2.stateDir, "browser", "downloads", fileName(key)),
         config: diagnostic ? () => ({ ...config(), cdpUrl: null, headed: false }) : config,
         network,
         launch: options2.launch ?? launchBrowser,
@@ -8658,7 +8888,7 @@ function createBrowserEngine(options2) {
     const session = sessions.get(key);
     sessions.delete(key);
     await session?.close();
-    if (diagnosticKeys.delete(key)) rmSync10(join31(options2.stateDir, "browser", "downloads", fileName(key)), { recursive: true, force: true });
+    if (diagnosticKeys.delete(key)) rmSync10(join32(options2.stateDir, "browser", "downloads", fileName(key)), { recursive: true, force: true });
   };
   return {
     diagnostics: () => [browserDiagnostic(config)],
@@ -8677,8 +8907,8 @@ function browserPluginPart(engine) {
 // src/annotations/store.ts
 init_errors();
 init_fs();
-import { existsSync as existsSync12, lstatSync as lstatSync6, mkdirSync as mkdirSync11, readdirSync as readdirSync15, rmSync as rmSync11 } from "node:fs";
-import { join as join32 } from "node:path";
+import { existsSync as existsSync13, lstatSync as lstatSync6, mkdirSync as mkdirSync11, readdirSync as readdirSync16, rmSync as rmSync11 } from "node:fs";
+import { join as join33 } from "node:path";
 var MAX_NOTES = 1e4;
 var MAX_HISTORY = 100;
 var codepoints = (value) => Array.from(value).length;
@@ -8794,16 +9024,16 @@ function visibleTo(note, caller) {
   return note.grants.some((grant2) => grant2.principal.sessionId && grant2.principal.sessionId === caller.sessionId || grant2.principal.agentId && grant2.principal.agentId === caller.agentId);
 }
 function notesDir(root) {
-  return join32(root, "annotations");
+  return join33(root, "annotations");
 }
 function folder(root) {
   const dir2 = notesDir(root);
-  if (existsSync12(dir2) && (lstatSync6(dir2).isSymbolicLink() || !lstatSync6(dir2).isDirectory())) throw new HarnessError("invalid_data", "Note storage must be a plain folder.");
+  if (existsSync13(dir2) && (lstatSync6(dir2).isSymbolicLink() || !lstatSync6(dir2).isDirectory())) throw new HarnessError("invalid_data", "Note storage must be a plain folder.");
   mkdirSync11(dir2, { recursive: true });
   return dir2;
 }
 function file(root, id) {
-  return join32(folder(root), `${safeId(id)}.json`);
+  return join33(folder(root), `${safeId(id)}.json`);
 }
 function validNote(note, id) {
   if (!note || note.id !== id || note.author !== "user" || !Number.isSafeInteger(note.version) || note.version < 1 || !Array.isArray(note.grants) || !Array.isArray(note.history)) {
@@ -8826,13 +9056,13 @@ function upgradeDelivery(note) {
 }
 function read2(root, id) {
   const path4 = file(root, id);
-  if (!existsSync12(path4)) throw notFound("Note");
+  if (!existsSync13(path4)) throw notFound("Note");
   if (lstatSync6(path4).isSymbolicLink()) throw new HarnessError("invalid_data", "Note records must not be links.");
   return validNote(readJson(path4), id);
 }
 function all2(root) {
   const notes = [];
-  for (const name of readdirSync15(folder(root))) {
+  for (const name of readdirSync16(folder(root))) {
     if (!name.endsWith(".json")) continue;
     try {
       notes.push(read2(root, name.slice(0, -".json".length)));
@@ -8851,8 +9081,8 @@ function listAll(root, filter = {}) {
 function list2(root, filter = {}) {
   const matching = matchingNotes(root, filter);
   const offset = Math.max(0, Math.floor(filter.offset ?? 0));
-  const limit = Math.max(1, Math.min(200, Math.floor(filter.limit ?? 50)));
-  return { notes: matching.slice(offset, offset + limit), total: matching.length };
+  const limit2 = Math.max(1, Math.min(200, Math.floor(filter.limit ?? 50)));
+  return { notes: matching.slice(offset, offset + limit2), total: matching.length };
 }
 function save2(root, note, operation) {
   note.version += 1;
@@ -8872,7 +9102,7 @@ function create(root, input) {
   const target = validateTarget(input?.target);
   const body2 = normalizeBody(input?.body);
   const tags = normalizeTags(input?.tags);
-  if (readdirSync15(folder(root)).filter((name) => name.endsWith(".json")).length >= MAX_NOTES) {
+  if (readdirSync16(folder(root)).filter((name) => name.endsWith(".json")).length >= MAX_NOTES) {
     throw new HarnessError("annotation_limit", `At most ${MAX_NOTES} notes may be kept.`);
   }
   const at = now();
@@ -8930,7 +9160,7 @@ function importNotes(root, notes) {
     try {
       if (!id) throw invalid("A note needs an id.");
       safeId(id);
-      if (existsSync12(file(root, id))) {
+      if (existsSync13(file(root, id))) {
         skipped.push({ id, reason: "exists" });
         continue;
       }
@@ -10180,16 +10410,16 @@ function hubServerMethods(harness) {
 
 // src/refine/runner.ts
 init_fs();
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 
 // src/refine/library.ts
 init_fs();
-import { existsSync as existsSync14, mkdirSync as mkdirSync13, readdirSync as readdirSync17, readFileSync as readFileSync18, rmSync as rmSync13, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join34 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync13, readdirSync as readdirSync18, readFileSync as readFileSync19, rmSync as rmSync13, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join35 } from "node:path";
 
 // src/refine/evidence.ts
-import { copyFileSync as copyFileSync4, cpSync, existsSync as existsSync13, mkdirSync as mkdirSync12, readdirSync as readdirSync16, readFileSync as readFileSync17, rmSync as rmSync12, statSync as statSync9, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname11, extname as extname2, join as join33, relative as relative5, sep as sep7 } from "node:path";
+import { copyFileSync as copyFileSync4, cpSync, existsSync as existsSync14, mkdirSync as mkdirSync12, readdirSync as readdirSync17, readFileSync as readFileSync18, rmSync as rmSync12, statSync as statSync10, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname12, extname as extname2, join as join34, relative as relative5, sep as sep7 } from "node:path";
 var GRADER_VERDICT_MARKERS = [
   "deterministic_eval_summary",
   "deterministic_eval_result",
@@ -10207,15 +10437,15 @@ function files(dir2) {
   const out = [];
   let names2;
   try {
-    names2 = readdirSync16(dir2);
+    names2 = readdirSync17(dir2);
   } catch {
     return out;
   }
   for (const name of names2.sort()) {
-    const path4 = join33(dir2, name);
+    const path4 = join34(dir2, name);
     let isDir2 = false;
     try {
-      isDir2 = statSync9(path4).isDirectory();
+      isDir2 = statSync10(path4).isDirectory();
     } catch {
       continue;
     }
@@ -10238,13 +10468,13 @@ function globToRegExp(glob) {
   return new RegExp(`^(?:[^]*/)?${out}$`);
 }
 function assertNoLeakPaths(root, globs = []) {
-  if (!globs.length || !existsSync13(root)) return;
+  if (!globs.length || !existsSync14(root)) return;
   const rx = globs.map(globToRegExp);
   const hits = files(root).map((path4) => rel(root, path4)).filter((path4) => rx.some((r) => r.test(path4)));
   if (hits.length) throw new Error(`answer-key path(s) would enter model context: ${hits.sort().slice(0, 8).join(", ")}`);
 }
 function assertNoGraderVerdicts(root, markers = GRADER_VERDICT_MARKERS) {
-  if (!existsSync13(root)) return;
+  if (!existsSync14(root)) return;
   for (const path4 of files(root)) {
     const name = rel(root, path4);
     for (const marker of markers) {
@@ -10253,7 +10483,7 @@ function assertNoGraderVerdicts(root, markers = GRADER_VERDICT_MARKERS) {
     if (!SCANNED.has(extname2(path4).toLowerCase())) continue;
     let body2;
     try {
-      body2 = readFileSync17(path4, "utf8");
+      body2 = readFileSync18(path4, "utf8");
     } catch {
       continue;
     }
@@ -10275,8 +10505,8 @@ function copyFolder(src, dst) {
   let n = 0;
   for (const path4 of files(src)) {
     if (path4.includes(`${sep7}__pycache__${sep7}`) || path4.endsWith(".pyc")) continue;
-    const target = join33(dst, relative5(src, path4));
-    mkdirSync12(dirname11(target), { recursive: true });
+    const target = join34(dst, relative5(src, path4));
+    mkdirSync12(dirname12(target), { recursive: true });
     copyFileSync4(path4, target);
     n++;
   }
@@ -10284,18 +10514,18 @@ function copyFolder(src, dst) {
 }
 function copySource(task, root) {
   const src = task.sourceDir;
-  if (!src || !existsSync13(src)) return 0;
+  if (!src || !existsSync14(src)) return 0;
   const leak = (task.leakGlobs ?? []).map(globToRegExp);
   let n = 0;
   for (const path4 of files(src)) {
     const name = rel(src, path4);
     if (name.split("/").includes("__pycache__") || leak.some((r) => r.test(name))) continue;
-    const target = join33(root, "source", name);
-    mkdirSync12(dirname11(target), { recursive: true });
+    const target = join34(root, "source", name);
+    mkdirSync12(dirname12(target), { recursive: true });
     copyFileSync4(path4, target);
     n++;
   }
-  if (n) assertNoLeakPaths(join33(root, "source"), task.leakGlobs);
+  if (n) assertNoLeakPaths(join34(root, "source"), task.leakGlobs);
   return n;
 }
 function unifiedDiff(before, after, fromLabel, toLabel) {
@@ -10345,15 +10575,15 @@ function layout(evidence) {
 }
 function writeRollout(dest, rollout, executor, obsTrunc) {
   let failure2 = "";
-  mkdirSync12(join33(dest, "rollouts"), { recursive: true });
+  mkdirSync12(join34(dest, "rollouts"), { recursive: true });
   try {
-    writeFileSync3(join33(dest, "rollouts", `${rollout.label}.md`), executor.trajectory(rollout, { obsTrunc }));
+    writeFileSync3(join34(dest, "rollouts", `${rollout.label}.md`), executor.trajectory(rollout, { obsTrunc }));
   } catch (error) {
     const message4 = error instanceof Error ? error.message : String(error);
-    writeFileSync3(join33(dest, "rollouts", `${rollout.label}.md`), `(trajectory unavailable: ${message4})`);
+    writeFileSync3(join34(dest, "rollouts", `${rollout.label}.md`), `(trajectory unavailable: ${message4})`);
     failure2 = `${rollout.label}: ${message4}`;
   }
-  const dir2 = join33(dest, "deliverables", rollout.label);
+  const dir2 = join34(dest, "deliverables", rollout.label);
   mkdirSync12(dir2, { recursive: true });
   let produced = {};
   try {
@@ -10363,11 +10593,11 @@ function writeRollout(dest, rollout, executor, obsTrunc) {
   }
   const names2 = Object.keys(produced).sort();
   for (const name of names2) {
-    const target = join33(dir2, name);
-    mkdirSync12(dirname11(target), { recursive: true });
+    const target = join34(dir2, name);
+    mkdirSync12(dirname12(target), { recursive: true });
     writeFileSync3(target, produced[name]);
   }
-  writeFileSync3(join33(dir2, "INDEX.md"), names2.length ? `# ${rollout.label} produced ${names2.length} file(s)
+  writeFileSync3(join34(dir2, "INDEX.md"), names2.length ? `# ${rollout.label} produced ${names2.length} file(s)
 
 ${names2.map((name) => `- \`${name}\``).join("\n")}
 ` : `# ${rollout.label} produced nothing
@@ -10388,11 +10618,11 @@ function build(dest, input) {
   rmSync12(dest, { recursive: true, force: true });
   mkdirSync12(dest, { recursive: true });
   const obsTrunc = Math.max(input.obsTrunc ?? 5e4, MIN_OBS_TRUNC);
-  writeFileSync3(join33(dest, "task.md"), task.prompt);
+  writeFileSync3(join34(dest, "task.md"), task.prompt);
   const sourceFiles = copySource(task, dest);
   for (const [label, notes] of Object.entries(input.decisions ?? {})) {
-    mkdirSync12(join33(dest, "decisions"), { recursive: true });
-    writeFileSync3(join33(dest, "decisions", `${label}.md`), notes || "No decision notes returned.");
+    mkdirSync12(join34(dest, "decisions"), { recursive: true });
+    writeFileSync3(join34(dest, "decisions", `${label}.md`), notes || "No decision notes returned.");
   }
   const rollouts = [];
   const deliverables = [];
@@ -10404,35 +10634,35 @@ function build(dest, input) {
     deliverables.push(rollout.label);
   }
   let harnessFiles = 0;
-  if (input.variantDir && existsSync13(input.variantDir)) {
+  if (input.variantDir && existsSync14(input.variantDir)) {
     assertNoLeakPaths(input.variantDir, task.leakGlobs);
-    harnessFiles = copyFolder(input.variantDir, join33(dest, "harness"));
+    harnessFiles = copyFolder(input.variantDir, join34(dest, "harness"));
   }
   const pool = [];
   for (const entry2 of input.pool ?? []) {
-    const dir2 = join33(dest, "pool", entry2.label);
+    const dir2 = join34(dest, "pool", entry2.label);
     mkdirSync12(dir2, { recursive: true });
-    if (entry2.variantDir && existsSync13(entry2.variantDir)) {
+    if (entry2.variantDir && existsSync14(entry2.variantDir)) {
       assertNoLeakPaths(entry2.variantDir, task.leakGlobs);
-      copyFolder(entry2.variantDir, join33(dir2, "harness"));
-      const reference = readVariant(PI_SURFACE, join33(dest, "harness"));
+      copyFolder(entry2.variantDir, join34(dir2, "harness"));
+      const reference = readVariant(PI_SURFACE, join34(dest, "harness"));
       const candidate = readVariant(PI_SURFACE, entry2.variantDir);
-      writeFileSync3(join33(dir2, "harness.diff"), unifiedDiff(reference, candidate, "current", entry2.label));
+      writeFileSync3(join34(dir2, "harness.diff"), unifiedDiff(reference, candidate, "current", entry2.label));
     }
     if (entry2.rollout) {
       try {
-        writeFileSync3(join33(dir2, "rollout.md"), executor.trajectory(entry2.rollout, { obsTrunc }));
-        writeFileSync3(join33(dir2, "produced.md"), renderDeliverable(executor, entry2.rollout) || "(nothing produced)");
+        writeFileSync3(join34(dir2, "rollout.md"), executor.trajectory(entry2.rollout, { obsTrunc }));
+        writeFileSync3(join34(dir2, "produced.md"), renderDeliverable(executor, entry2.rollout) || "(nothing produced)");
       } catch (error) {
-        writeFileSync3(join33(dir2, "rollout.md"), `(unavailable: ${error instanceof Error ? error.message : String(error)})`);
+        writeFileSync3(join34(dir2, "rollout.md"), `(unavailable: ${error instanceof Error ? error.message : String(error)})`);
       }
     }
     pool.push(entry2.label);
   }
   let library = false;
-  if (input.libraryDir && existsSync13(input.libraryDir) && readdirSync16(input.libraryDir).length) {
+  if (input.libraryDir && existsSync14(input.libraryDir) && readdirSync17(input.libraryDir).length) {
     assertNoLeakPaths(input.libraryDir, task.leakGlobs);
-    cpSync(input.libraryDir, join33(dest, "library"), { recursive: true });
+    cpSync(input.libraryDir, join34(dest, "library"), { recursive: true });
     library = true;
   }
   assertNoLeakPaths(dest, task.leakGlobs);
@@ -10466,7 +10696,7 @@ function slug(text10) {
   return text10.replace(/\s*[/\\]\s*/g, "__").replace(/[^A-Za-z0-9_.\-]/g, "_").replace(/^\.+/, "_").slice(0, 120).trim() || "unknown";
 }
 function libraryRoot(root) {
-  return join34(root, "library");
+  return join35(root, "library");
 }
 var Library = class {
   constructor(root, scope, area = scope, surface = PI_SURFACE) {
@@ -10481,39 +10711,39 @@ var Library = class {
   area;
   surface;
   get dir() {
-    return join34(libraryRoot(this.root), this.scope, slug(this.area));
+    return join35(libraryRoot(this.root), this.scope, slug(this.area));
   }
   get index() {
-    return join34(this.dir, "INDEX.md");
+    return join35(this.dir, "INDEX.md");
   }
   entryDir(task) {
-    return join34(this.dir, "variants", slug(task));
+    return join35(this.dir, "variants", slug(task));
   }
   /** The folder handed to an improver, or null when nothing has been learned here yet. */
   contextDir() {
-    return existsSync14(this.index) && this.entries().length ? this.dir : null;
+    return existsSync15(this.index) && this.entries().length ? this.dir : null;
   }
   entries() {
-    const dir2 = join34(this.dir, "variants");
+    const dir2 = join35(this.dir, "variants");
     try {
-      return readdirSync17(dir2, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() && existsSync14(join34(dir2, entry2.name, "EXPERIENCE.md"))).map((entry2) => entry2.name).sort();
+      return readdirSync18(dir2, { withFileTypes: true }).filter((entry2) => entry2.isDirectory() && existsSync15(join35(dir2, entry2.name, "EXPERIENCE.md"))).map((entry2) => entry2.name).sort();
     } catch {
       return [];
     }
   }
   variantOf(task) {
-    return readVariant(this.surface, join34(this.entryDir(task), "variant"));
+    return readVariant(this.surface, join35(this.entryDir(task), "variant"));
   }
   experienceText(task) {
     try {
-      return readFileSync18(join34(this.entryDir(task), "EXPERIENCE.md"), "utf8");
+      return readFileSync19(join35(this.entryDir(task), "EXPERIENCE.md"), "utf8");
     } catch {
       return null;
     }
   }
   list() {
     return this.entries().map((name) => {
-      const text10 = readFileSync18(join34(this.dir, "variants", name, "EXPERIENCE.md"), "utf8");
+      const text10 = readFileSync19(join35(this.dir, "variants", name, "EXPERIENCE.md"), "utf8");
       return {
         task: name,
         label: /^- adopted: `([^`]+)`/m.exec(text10)?.[1] ?? "",
@@ -10528,7 +10758,7 @@ var Library = class {
     let removed = false;
     for (const task of tasks) {
       const dir2 = this.entryDir(task);
-      if (existsSync14(dir2)) {
+      if (existsSync15(dir2)) {
         rmSync13(dir2, { recursive: true, force: true });
         removed = true;
       }
@@ -10545,8 +10775,8 @@ var Library = class {
     assertVariantHasNoGraderVerdicts(variant);
     assertVariantHasNoGraderVerdicts({ "EXPERIENCE.md": JSON.stringify(experience2) + (input.why ?? "") });
     const dir2 = this.entryDir(task);
-    rmSync13(join34(dir2, "variant"), { recursive: true, force: true });
-    writeVariant(this.surface, variant, join34(dir2, "variant"), { stubs: false });
+    rmSync13(join35(dir2, "variant"), { recursive: true, force: true });
+    writeVariant(this.surface, variant, join35(dir2, "variant"), { stubs: false });
     const lines2 = [`# ${task}`, "", `- adopted: \`${input.label ?? ""}\`${input.runId ? `  (run \`${input.runId}\`)` : ""}`, `- components: ${inventory(this.surface, variant)}`, ""];
     if (input.why?.trim()) lines2.push("## Why this was chosen", input.why.trim(), "");
     if (experience2.edits?.trim()) lines2.push("## What each edit did", experience2.edits.trim(), "");
@@ -10554,7 +10784,7 @@ var Library = class {
     for (const key of ["cue", "lesson", "evidence", "confidence"]) if (experience2[key]) lines2.push(`- **${key}**: ${String(experience2[key]).trim()}`);
     lines2.push("");
     mkdirSync13(dir2, { recursive: true });
-    writeFileSync4(join34(dir2, "EXPERIENCE.md"), lines2.join("\n"));
+    writeFileSync4(join35(dir2, "EXPERIENCE.md"), lines2.join("\n"));
     this.rebuildIndex();
     return dir2;
   }
@@ -10563,7 +10793,7 @@ var Library = class {
     const names2 = this.entries();
     if (!names2.length) rows.push("_(empty \u2014 this is the first task in this area)_");
     for (const name of names2) {
-      const cue = field(readFileSync18(join34(this.dir, "variants", name, "EXPERIENCE.md"), "utf8"), "cue");
+      const cue = field(readFileSync19(join35(this.dir, "variants", name, "EXPERIENCE.md"), "utf8"), "cue");
       rows.push(`## \`variants/${name}/\``, `- variant: \`variants/${name}/variant/\` \u2014 ${inventory(this.surface, this.variantOf(name))}`, `- why:     \`variants/${name}/EXPERIENCE.md\``);
       if (cue) rows.push(`- cue:     ${cue}`);
       rows.push("");
@@ -10590,22 +10820,22 @@ function field(text10, name) {
 }
 function libraryScopes(root) {
   try {
-    return readdirSync17(libraryRoot(root), { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => entry2.name).sort();
+    return readdirSync18(libraryRoot(root), { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => entry2.name).sort();
   } catch {
     return [];
   }
 }
 function libraryAreas(root, scope) {
   try {
-    return readdirSync17(join34(libraryRoot(root), safeId(scope)), { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => entry2.name).sort();
+    return readdirSync18(join35(libraryRoot(root), safeId(scope)), { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => entry2.name).sort();
   } catch {
     return [];
   }
 }
 
 // src/refine/recursion.ts
-import { existsSync as existsSync15 } from "node:fs";
-import { join as join35 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join36 } from "node:path";
 
 // src/refine/ledger.ts
 var expectedRollouts = (k) => 4 * k;
@@ -11146,7 +11376,7 @@ async function runStage(ctx, input) {
   let folder2;
   let mission2;
   try {
-    folder2 = build(join35(ctx.workDir, "context", label), {
+    folder2 = build(join36(ctx.workDir, "context", label), {
       task: ctx.task,
       executor: ctx.executor,
       rollouts: input.rollouts,
@@ -11193,7 +11423,7 @@ Fix it in \`context/harness/\` and reply again.` : ""),
     usd += reply.costUsd;
     attempts += reply.cached ? 0 : Math.max(1, reply.attempts);
     allCached = allCached && reply.cached;
-    if (!reply.workspace || !existsSync15(reply.workspace)) {
+    if (!reply.workspace || !existsSync16(reply.workspace)) {
       err = "the harness directory did not come back from the session; edit the files in `context/harness/` in place";
       continue;
     }
@@ -11210,7 +11440,7 @@ Fix it in \`context/harness/\` and reply again.` : ""),
     const accepted = acceptVariant(ctx.task, ctx.executor, next, fallback);
     if (accepted.error) {
       err = accepted.error;
-      writeVariant(PI_SURFACE, next, join35(folder2.root, "harness"));
+      writeVariant(PI_SURFACE, next, join36(folder2.root, "harness"));
       continue;
     }
     const notes = /<notes>([\s\S]*?)<\/notes>/.exec(reply.text)?.[1]?.trim() ?? reply.text.trim();
@@ -11222,7 +11452,7 @@ function recordSessions(ledger, stages) {
   for (const stage2 of stages) ledger.session(stage2.label, stage2.usd, { cached: stage2.cached, attempts: stage2.attempts });
 }
 async function roll(ctx, label, variant) {
-  const variantDir = writeVariant(PI_SURFACE, variant, join35(ctx.workDir, "variants", label));
+  const variantDir = writeVariant(PI_SURFACE, variant, join36(ctx.workDir, "variants", label));
   const runId = ctx.runIdOf(label);
   ctx.onEvent?.({ type: "rollout.started", label });
   let rollout;
@@ -11230,7 +11460,7 @@ async function roll(ctx, label, variant) {
     checkAborted(ctx.signal);
     rollout = await ctx.executor.execute(ctx.task, variantDir, label, runId);
   } catch (error) {
-    rollout = { label, runId, dir: join35(ctx.workDir, "missing", label), ok: false, delivered: false, costUsd: 0, wallMs: 0, error: error instanceof Error ? error.message : String(error) };
+    rollout = { label, runId, dir: join36(ctx.workDir, "missing", label), ok: false, delivered: false, costUsd: 0, wallMs: 0, error: error instanceof Error ? error.message : String(error) };
   }
   ctx.onEvent?.({ type: "rollout.finished", label, ok: rollout.ok, delivered: rollout.delivered, error: rollout.error });
   return rollout;
@@ -11249,7 +11479,7 @@ function newResult(mode2, ctx, k, base) {
   for (const rollout of base) ledger.rollout(rollout.label, rollout.costUsd);
   return { mode: mode2, taskId: ctx.task.id, k, stages: [], variants: {}, rollouts: Object.fromEntries(base.map((rollout) => [rollout.label, rollout])), finals: [], ledger, similarity: null, errors: [] };
 }
-var variantPath = (ctx, label) => join35(ctx.workDir, "variants", label);
+var variantPath = (ctx, label) => join36(ctx.workDir, "variants", label);
 async function runParallel(ctx, k, base) {
   const result = newResult("agg", ctx, k, base);
   const prompts = ctx.task.prompts ?? defaultPrompts();
@@ -11340,7 +11570,7 @@ function runMode(mode2, ctx, k, base) {
 init_fs();
 import { createHash as createHash6 } from "node:crypto";
 import { cpSync as cpSync2, mkdirSync as mkdirSync14, rmSync as rmSync14, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function seeded(seed2) {
   let a = seed2 >>> 0;
   return () => {
@@ -11404,7 +11634,7 @@ function renderPool(candidates, executor, sel) {
 }
 function persist(sel, root) {
   try {
-    writeJson(join36(root, "selection.json"), sel);
+    writeJson(join37(root, "selection.json"), sel);
   } catch (error) {
     sel.ok = false;
     sel.error = `${sel.error} | could not persist selection: ${error instanceof Error ? error.message : String(error)}`.slice(0, 400);
@@ -11426,14 +11656,14 @@ async function runSelection(input) {
     return sel;
   }
   sel.idMap = assignIds(Object.keys(pool), task.id, k, mode2);
-  const root = join36(input.workDir, "selection", `${mode2}${k}`);
+  const root = join37(input.workDir, "selection", `${mode2}${k}`);
   rmSync14(root, { recursive: true, force: true });
-  mkdirSync14(join36(root, "candidates"), { recursive: true });
-  writeFileSync5(join36(root, "task.md"), task.prompt);
+  mkdirSync14(join37(root, "candidates"), { recursive: true });
+  writeFileSync5(join37(root, "task.md"), task.prompt);
   copySource(task, root);
   for (const [anon, label] of Object.entries(sel.idMap)) {
     const text10 = artifacts[label];
-    writeFileSync5(join36(root, "candidates", `${anon}.md`), `<!-- candidate ${anon}: ${text10.length.toLocaleString("en-US")} chars, ${text10.split("\n").length.toLocaleString("en-US")} lines. COMPLETE -- nothing trimmed. Navigate with grep/offsets; evaluating a candidate means opening the part that determines whether it works. -->
+    writeFileSync5(join37(root, "candidates", `${anon}.md`), `<!-- candidate ${anon}: ${text10.length.toLocaleString("en-US")} chars, ${text10.split("\n").length.toLocaleString("en-US")} lines. COMPLETE -- nothing trimmed. Navigate with grep/offsets; evaluating a candidate means opening the part that determines whether it works. -->
 ${text10}`);
   }
   const ids2 = Object.keys(sel.idMap).sort().join(", ");
@@ -11485,7 +11715,7 @@ function trivialSelection(input) {
   choose(sel, label, pool);
   sel.ok = true;
   sel.why = "trivial pool: single final at k=1; delivered without a selector session";
-  const root = join36(input.workDir, "selection", `${mode2}${k}`);
+  const root = join37(input.workDir, "selection", `${mode2}${k}`);
   rmSync14(root, { recursive: true, force: true });
   mkdirSync14(root, { recursive: true });
   persist(sel, root);
@@ -11495,21 +11725,21 @@ async function reflectAdoption(input) {
   const { task, selection: sel } = input;
   const chosen = input.rollouts[sel.chosenLabel];
   if (!sel.ok || !chosen) return {};
-  const root = join36(input.workDir, "reflection", `${sel.mode}${sel.k}`);
-  const variants = join36(input.workDir, "variants");
+  const root = join37(input.workDir, "reflection", `${sel.mode}${sel.k}`);
+  const variants = join37(input.workDir, "variants");
   let layout2 = "";
   try {
     const built = build(root, {
       task,
       executor: input.executor,
       rollouts: Object.values(input.rollouts),
-      variantDir: join36(variants, sel.chosenLabel),
-      pool: Object.entries(input.rollouts).filter(([label]) => !label.startsWith("base")).map(([label, rollout]) => ({ label, variantDir: join36(variants, label), rollout })),
+      variantDir: join37(variants, sel.chosenLabel),
+      pool: Object.entries(input.rollouts).filter(([label]) => !label.startsWith("base")).map(([label, rollout]) => ({ label, variantDir: join37(variants, label), rollout })),
       decisions: input.decisions
     });
     layout2 = layout(built);
-    writeVariant(PI_SURFACE, input.baseVariant, join36(root, "base_harness"), { stubs: false });
-    writeFileSync5(join36(root, "adoption.json"), `${JSON.stringify({ chosen_label: sel.chosenLabel, candidate_ids: sel.idMap, reason: sel.why }, null, 2)}
+    writeVariant(PI_SURFACE, input.baseVariant, join37(root, "base_harness"), { stubs: false });
+    writeFileSync5(join37(root, "adoption.json"), `${JSON.stringify({ chosen_label: sel.chosenLabel, candidate_ids: sel.idMap, reason: sel.why }, null, 2)}
 `);
     assertNoLeakPaths(root, task.leakGlobs);
     assertNoGraderVerdicts(root);
@@ -11541,7 +11771,7 @@ ${layout2}`
     return {};
   }
   const out = parseExperience(text10);
-  if (out.edits) writeFileSync5(join36(root, "edits.md"), `${out.edits}
+  if (out.edits) writeFileSync5(join37(root, "edits.md"), `${out.edits}
 `);
   try {
     assertVariantHasNoGraderVerdicts({ "EXPERIENCE.md": JSON.stringify(out) });
@@ -11549,7 +11779,7 @@ ${layout2}`
     return {};
   }
   sel.experience = out;
-  persist(sel, join36(input.workDir, "selection", `${sel.mode}${sel.k}`));
+  persist(sel, join37(input.workDir, "selection", `${sel.mode}${sel.k}`));
   return out;
 }
 function parseExperience(text10) {
@@ -11571,10 +11801,10 @@ function parseExperience(text10) {
 
 // src/refine/runner.ts
 function refineDir(root, id) {
-  return join37(root, "refine", safeId(id));
+  return join38(root, "refine", safeId(id));
 }
 function readSummary(root, id) {
-  return readJson(join37(refineDir(root, id), "summary.json"));
+  return readJson(join38(refineDir(root, id), "summary.json"));
 }
 var modeToken = (mode2) => mode2 === "parallel" ? "agg" : "seq";
 async function runRefinement(input) {
@@ -11612,7 +11842,7 @@ async function runRefinement(input) {
     ...input.settings ? { settings: input.settings } : {}
   };
   const save3 = () => {
-    writeJson(join37(workDir, "summary.json"), summary4);
+    writeJson(join38(workDir, "summary.json"), summary4);
     emit({ type: "summary", summary: structuredClone(summary4) });
   };
   const finish = (status) => {
@@ -11622,11 +11852,11 @@ async function runRefinement(input) {
     emit({ type: "phase", phase: "done" });
     return summary4;
   };
-  writeJson(join37(workDir, "task.json"), { task, k, mode: mode2 });
+  writeJson(join38(workDir, "task.json"), { task, k, mode: mode2 });
   save3();
   const libraryDir = library.contextDir();
   emit({ type: "phase", phase: "base" });
-  const baseDir = writeVariant(PI_SURFACE, baseVariant, join37(workDir, "variants", "base"));
+  const baseDir = writeVariant(PI_SURFACE, baseVariant, join38(workDir, "variants", "base"));
   const labels = Array.from({ length: k }, (_, i) => `base${i + 1}`);
   const base = await mapLimit(labels, input.rolloutWidth ?? 4, async (label) => {
     emit({ type: "rollout.started", label });
@@ -11635,7 +11865,7 @@ async function runRefinement(input) {
       if (input.signal?.aborted) throw new Error("Refinement was cancelled.");
       rollout = await executor.execute(task, baseDir, label, runIdOf(label));
     } catch (error) {
-      rollout = { label, runId: runIdOf(label), dir: join37(workDir, "missing", label), ok: false, delivered: false, costUsd: 0, wallMs: 0, error: error instanceof Error ? error.message : String(error) };
+      rollout = { label, runId: runIdOf(label), dir: join38(workDir, "missing", label), ok: false, delivered: false, costUsd: 0, wallMs: 0, error: error instanceof Error ? error.message : String(error) };
     }
     emit({ type: "rollout.finished", label, ok: rollout.ok, delivered: rollout.delivered, error: rollout.error });
     return rollout;
@@ -11804,7 +12034,7 @@ function ftsAny(query) {
   }
   return terms.length ? terms.join(" OR ") : null;
 }
-function search2(root, query, scope, limit) {
+function search2(root, query, scope, limit2) {
   const fts = ftsAny(query);
   if (!fts) return [];
   return withIndex(
@@ -11825,7 +12055,7 @@ function search2(root, query, scope, limit) {
       scope.projectId ?? null,
       scope.since ?? null,
       scope.since ?? null,
-      Math.min(Math.max(limit, 1), SEARCH_MAX)
+      Math.min(Math.max(limit2, 1), SEARCH_MAX)
     ).map((row) => ({ runId: row.run_id, seq: Number(row.seq), role: row.role, at: row.at ?? "", mode: row.mode ?? "", sessionId: row.session_id ?? "", projectId: row.project_id, snippet: row.snippet }))
   );
 }
@@ -11883,8 +12113,8 @@ function searchTool2(env, context, params) {
   if (!query) throw invalid("Give a query.");
   const scope = callerScope(env.root, context, params);
   const requested = params?.limit;
-  const limit = typeof requested === "number" && Number.isInteger(requested) && requested >= 0 ? requested : SEARCH_DEFAULT;
-  const hits = search2(env.root, query, scope, limit + 4 + (context.recallExcludeAgents?.length ? SEARCH_MAX : 0)).filter((hit2) => hit2.runId !== context.runId && !excluded(env, context, hit2.sessionId)).slice(0, Math.min(Math.max(limit, 1), SEARCH_MAX));
+  const limit2 = typeof requested === "number" && Number.isInteger(requested) && requested >= 0 ? requested : SEARCH_DEFAULT;
+  const hits = search2(env.root, query, scope, limit2 + 4 + (context.recallExcludeAgents?.length ? SEARCH_MAX : 0)).filter((hit2) => hit2.runId !== context.runId && !excluded(env, context, hit2.sessionId)).slice(0, Math.min(Math.max(limit2, 1), SEARCH_MAX));
   if (!hits.length) {
     return scope.sessionId && !isSession(context) ? 'Nothing in your own conversations matches. Pass scope "all" to search every conversation and Harness run.' : "Nothing in the recorded history matches.";
   }
@@ -12004,7 +12234,7 @@ function connectedAppServerMethods(harness) {
 }
 
 // src/tools/dispatch.ts
-import { existsSync as existsSync17, readdirSync as readdirSync19, readFileSync as readFileSync19 } from "node:fs";
+import { existsSync as existsSync17, readdirSync as readdirSync20, readFileSync as readFileSync20 } from "node:fs";
 import { join as join40 } from "node:path";
 init_errors();
 
@@ -12081,14 +12311,14 @@ function searchTool3(env, context, params) {
   const status = textParam2(params, "status");
   const since = dateValue(params, "since");
   const until2 = dateValue(params, "until");
-  const limit = boundedInteger(params, "limit", SEARCH_DEFAULT2, 1, SEARCH_MAX2);
+  const limit2 = boundedInteger(params, "limit", SEARCH_DEFAULT2, 1, SEARCH_MAX2);
   const cursor = decodeCursor(textParam2(params, "cursor"));
   if (status && !runStatusSchema.safeParse(status).success) throw invalid(`Unknown run status ${status}.`);
   const projects = listProjects(env.root);
   const project = projectKey ? projects.find((entry2) => entry2.id === projectKey || entry2.slug === projectKey || entry2.name.toLowerCase() === projectKey.toLowerCase()) : null;
   if (projectKey && !project) throw invalid(`There is no project called ${projectKey}.`);
   const matching = readAllRuns(env.root).filter((run2) => !hidden(env, context, run2)).filter((run2) => !agent || run2.agentId === agent || run2.agentId !== null && env.directory.agentName(run2.agentId)?.toLowerCase() === agent.toLowerCase()).filter((run2) => !projectKey || run2.projectId === project?.id).filter((run2) => !mode2 || run2.mode === mode2).filter((run2) => !status || run2.status === status).filter((run2) => !since || Date.parse(run2.startedAt) >= since.timestamp).filter((run2) => !until2 || Date.parse(run2.startedAt) <= until2.timestamp).filter((run2) => !cursor || afterCursor(run2, cursor)).sort((left, right) => compareText(right.startedAt, left.startedAt) || compareText(right.id, left.id));
-  const page2 = matching.slice(0, limit);
+  const page2 = matching.slice(0, limit2);
   const hasMore = matching.length > page2.length;
   return JSON.stringify({
     runs: page2.map((run2) => summary2(env, run2, projects)),
@@ -12159,12 +12389,12 @@ function readTool2(env, context, params) {
   const run2 = findRun(env.root, runId);
   if (!run2 || hidden(env, context, run2)) throw notFound("Run");
   const afterSequence = boundedInteger(params, "afterSequence", -1, -1, Number.MAX_SAFE_INTEGER);
-  const limit = boundedInteger(params, "limit", READ_DEFAULT, 1, READ_MAX);
+  const limit2 = boundedInteger(params, "limit", READ_DEFAULT, 1, READ_MAX);
   const captured = snapshot(env.root, run2.id);
   const candidates = captured.events.filter((event) => event.sequence > afterSequence);
   const events2 = [];
   let eventChars = 0;
-  for (const event of candidates.slice(0, limit)) {
+  for (const event of candidates.slice(0, limit2)) {
     const bounded4 = publicEvent(event);
     const size2 = JSON.stringify(bounded4).length;
     if (events2.length && eventChars + size2 > PAGE_MAX_CHARS) break;
@@ -12187,14 +12417,14 @@ function readTool2(env, context, params) {
 // src/plugins/proposals.ts
 init_errors();
 import { createHash as createHash7, randomUUID as randomUUID5 } from "node:crypto";
-import { mkdirSync as mkdirSync15, readdirSync as readdirSync18, renameSync as renameSync5, rmSync as rmSync15, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname12, join as join38 } from "node:path";
+import { mkdirSync as mkdirSync15, readdirSync as readdirSync19, renameSync as renameSync5, rmSync as rmSync15, rmdirSync as rmdirSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname13, join as join39 } from "node:path";
 init_fs();
 var MAX_FILES2 = 100;
 var MAX_FILE_BYTES = 256 * 1024;
 var MAX_TOTAL_BYTES = 1024 * 1024;
-var dir = (root) => join38(root, "plugin-proposals");
-var pathOf = (root, id) => join38(dir(root), `${safeId(id)}.json`);
+var dir = (root) => join39(root, "plugin-proposals");
+var pathOf = (root, id) => join39(dir(root), `${safeId(id)}.json`);
 function validate2(name, description, input) {
   if (typeof name !== "string" || !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(name)) throw invalid("Plugin name must be lowercase letters, digits, underscores or hyphens.");
   if (typeof description !== "string" || !description.trim() || Buffer.byteLength(description, "utf8") > 4096 || /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(description)) throw invalid("Description must be non-empty valid text of at most 4096 bytes.");
@@ -12238,7 +12468,7 @@ function preview(root, id) {
 function list4(root) {
   let names2;
   try {
-    names2 = readdirSync18(dir(root));
+    names2 = readdirSync19(dir(root));
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -12266,19 +12496,19 @@ async function accept(harness, id, hash) {
   reviewed(proposal, hash);
   const pluginId = `package:${proposal.name}`;
   if (existing.some((plugin) => plugin.id === pluginId)) throw invalid("A plugin with this name already exists.");
-  const parent = join38(root, "plugins");
-  const destination = join38(parent, proposal.name);
+  const parent = join39(root, "plugins");
+  const destination = join39(parent, proposal.name);
   mkdirSync15(parent, { recursive: true });
-  const stage2 = join38(parent, `.proposal-${randomUUID5()}`);
+  const stage2 = join39(parent, `.proposal-${randomUUID5()}`);
   mkdirSync15(stage2);
   let reserved = false;
   try {
     for (const [path4, content] of Object.entries(proposal.files)) {
-      const target = join38(stage2, path4);
-      mkdirSync15(dirname12(target), { recursive: true });
+      const target = join39(stage2, path4);
+      mkdirSync15(dirname13(target), { recursive: true });
       writeFileSync6(target, content, { flag: "wx" });
     }
-    writeFileSync6(join38(stage2, "package.json"), proposal.manifest, { flag: "wx" });
+    writeFileSync6(join39(stage2, "package.json"), proposal.manifest, { flag: "wx" });
     const found = { kind: "extension", path: stage2, origin: "package", project: false, packageRoot: stage2, source: stage2, enabled: true };
     const code = packageCode([found]).get(stage2);
     if (harness.plugins.trust.has(code.hash)) throw invalid("Identical package code is already trusted; change it before accepting.");
@@ -12308,24 +12538,6 @@ async function accept(harness, id, hash) {
   }
 }
 
-// src/tools/defaultSkills.ts
-import { existsSync as existsSync16 } from "node:fs";
-import { dirname as dirname13, join as join39 } from "node:path";
-import { fileURLToPath } from "node:url";
-function defaultSkillPath() {
-  let dir2 = dirname13(fileURLToPath(import.meta.url));
-  for (; ; ) {
-    const path4 = join39(dir2, "builtin", "skills", "plugin-authoring", "SKILL.md");
-    if (existsSync16(path4)) return path4;
-    const parent = dirname13(dir2);
-    if (parent === dir2) throw new Error("The bundled plugin-authoring skill is missing.");
-    dir2 = parent;
-  }
-}
-function defaultSkillPaths(variantDir) {
-  return variantDir && existsSync16(join39(variantDir, "skills", "plugin-authoring", "SKILL.md")) ? [] : [defaultSkillPath()];
-}
-
 // src/tools/dispatch.ts
 function str(params, key) {
   const value = params[key];
@@ -12380,20 +12592,19 @@ ${tail}` : ""}`;
   }
 }
 function loadSkill(variantDir, name) {
-  const skills = variantDir && existsSync17(join40(variantDir, "skills")) ? readdirSync19(join40(variantDir, "skills"), { withFileTypes: true }).filter((entry2) => entry2.isDirectory() && existsSync17(join40(variantDir, "skills", entry2.name, "SKILL.md"))).map((entry2) => entry2.name).sort() : [];
-  const defaults = defaultSkillPaths(variantDir);
-  if (defaults.length) skills.push("plugin-authoring");
+  const skills = variantDir && existsSync17(join40(variantDir, "skills")) ? readdirSync20(join40(variantDir, "skills"), { withFileTypes: true }).filter((entry2) => entry2.isDirectory() && existsSync17(join40(variantDir, "skills", entry2.name, "SKILL.md"))).map((entry2) => entry2.name).sort() : [];
+  if (!skills.includes("plugin-authoring") && defaultSkillPaths(variantDir).length) skills.push("plugin-authoring");
   skills.sort();
   const wanted = name.trim().replace(/^skills\//, "").replace(/`/g, "");
   if (!wanted) return skills.length ? `Your skills: ${skills.join(", ")}. Load one with skill_load and its name.` : "You have no skills.";
-  if (!/^[a-z0-9][a-z0-9_-]*$/.test(wanted)) throw invalid("A skill name is lowercase letters, digits, _ or -.");
+  if (!SKILL_NAME.test(wanted)) throw invalid("A skill name is lowercase letters, digits, _ or -.");
   if (!skills.includes(wanted)) return `There is no skill named ${wanted}.${skills.length ? ` Your skills: ${skills.join(", ")}.` : ""}`;
-  if (wanted === "plugin-authoring" && defaults.length) return readFileSync19(defaults[0], "utf8");
-  const dir2 = join40(variantDir, "skills", wanted);
-  const helpers = existsSync17(join40(dir2, "scripts")) ? readdirSync19(join40(dir2, "scripts")) : [];
-  return `${readFileSync19(join40(dir2, "SKILL.md"), "utf8")}${helpers.length ? `
+  const skill = readSkillFile(variantDir, wanted);
+  if (!skill) return `There is no skill named ${wanted}.${skills.length ? ` Your skills: ${skills.join(", ")}.` : ""}`;
+  const helperNote = skill.helpers.length ? `
 
-(This skill's helpers are in ${join40(dir2, "scripts")}: ${helpers.join(", ")}.)` : ""}`;
+(This skill's helpers are in ${join40(skill.baseDir, "scripts")}: ${skill.helpers.join(", ")}.)` : "";
+  return `${readFileSync20(skill.path, "utf8")}${helperNote}`;
 }
 
 // src/tools/harnessTools.ts
@@ -12592,6 +12803,7 @@ var VARIANT_PLUGIN = {
     { id: "memory", name: "Memory", description: "c3: durable facts about this kind of work." },
     { id: "subagents", name: "Subagents", description: "c5: the list of this variant's subagents." },
     { id: "scripts", name: "Scripts", description: "c7: where this variant's scripts are." },
+    { id: "required-skills", name: "Required skills", description: "Skills the person named as required for one request." },
     { id: "reporting", name: "Reporting", description: "Fixed foundation text, not part of the variant: how the final reply is shaped." }
   ],
   tools: tools3(SKILL_TOOLS)
@@ -12718,7 +12930,7 @@ var HARNESS_PLUGINS = BUILTIN_PLUGIN_REGISTRY.descriptors();
 var size = (path4) => {
   if (!path4) return null;
   try {
-    return charCount(readFileSync20(path4, "utf8"));
+    return charCount(readFileSync21(path4, "utf8"));
   } catch {
     return null;
   }
@@ -12903,7 +13115,7 @@ function forgetAgent(harness, agentId) {
 }
 
 // src/plugins/install.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync16, renameSync as renameSync6, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync16, renameSync as renameSync6, statSync as statSync11 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { basename as basename8, isAbsolute as isAbsolute5, join as join42, resolve as resolve5 } from "node:path";
 init_errors();
@@ -12925,7 +13137,7 @@ async function manager(harness) {
 var changed = (harness) => harness.bus.emit({ type: "plugins.changed" });
 async function install(harness, params) {
   const source = normalizeSource(params.source);
-  if (isAbsolute5(source) && !(existsSync18(source) && statSync10(source).isDirectory())) throw invalid("That folder does not exist.");
+  if (isAbsolute5(source) && !(existsSync18(source) && statSync11(source).isDirectory())) throw invalid("That folder does not exist.");
   await ensureAdopted(harness);
   const before = new Set((await list3(harness, params)).map((plugin) => plugin.id));
   const { settings, packages } = await manager(harness);
@@ -13001,7 +13213,7 @@ async function update2(harness, params) {
 
 // src/variant/components.ts
 init_errors();
-import { lstatSync as lstatSync7, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync3, readdirSync as readdirSync20, readFileSync as readFileSync21, renameSync as renameSync7, rmSync as rmSync16, writeFileSync as writeFileSync7 } from "node:fs";
+import { lstatSync as lstatSync7, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync3, readdirSync as readdirSync21, readFileSync as readFileSync22, renameSync as renameSync7, rmSync as rmSync16, writeFileSync as writeFileSync7 } from "node:fs";
 import { basename as basename9, dirname as dirname14, join as join43 } from "node:path";
 init_fs();
 var KINDS = ["skills", "prompts", "rules"];
@@ -13016,7 +13228,7 @@ var kindDir = (root, kind) => join43(root, "registry", kind);
 function itemFrom(kind, stem, file2) {
   let text10;
   try {
-    text10 = readFileSync21(file2, "utf8");
+    text10 = readFileSync22(file2, "utf8");
   } catch {
     return null;
   }
@@ -13039,7 +13251,7 @@ function itemsIn(directory) {
   for (const kind of KINDS) {
     let names2;
     try {
-      names2 = readdirSync20(join43(directory, kind));
+      names2 = readdirSync21(join43(directory, kind));
     } catch {
       continue;
     }
@@ -13069,7 +13281,7 @@ function isInVariant(root, variant, id) {
   if (!item) return false;
   if (item.kind === "skills") return variant["skills/" + skillName(item) + "/SKILL.md"] !== void 0;
   if (item.kind === "rules") {
-    const text10 = readFileSync21(item.path, "utf8");
+    const text10 = readFileSync22(item.path, "utf8");
     const body2 = (parse(text10)?.body ?? text10).trim();
     return Boolean(body2) && (variant[GUARDRAILS] ?? "").includes(body2);
   }
@@ -13079,7 +13291,7 @@ function addToVariant(root, variant, id) {
   const item = list5(root).find((candidate) => candidate.id === id);
   if (!item) throw notFound("That library item");
   const next = { ...variant };
-  const text10 = readFileSync21(item.path, "utf8");
+  const text10 = readFileSync22(item.path, "utf8");
   const body2 = (parse(text10)?.body ?? text10).trim();
   if (item.kind === "rules") {
     const current2 = (next[GUARDRAILS] ?? "").trimEnd();
@@ -13099,7 +13311,7 @@ ${body2}
 `;
   const folder2 = dirname14(item.path);
   if (basename9(item.path) === "SKILL.md" && isDir(join43(folder2, "scripts"))) {
-    for (const file2 of readdirSync20(join43(folder2, "scripts"))) next[`skills/${name}/scripts/${file2}`] = readFileSync21(join43(folder2, "scripts", file2), "utf8");
+    for (const file2 of readdirSync21(join43(folder2, "scripts"))) next[`skills/${name}/scripts/${file2}`] = readFileSync22(join43(folder2, "scripts", file2), "utf8");
   }
   autotrigger(PI_SURFACE, next);
   return next;
@@ -13419,7 +13631,7 @@ function acquire(path4) {
       throw new HarnessError("hub_busy", "Another installation is using this library. Wait and retry.");
     }
     try {
-      const pid = Number(readFileSync22(path4, "utf8"));
+      const pid = Number(readFileSync23(path4, "utf8"));
       if (Number.isInteger(pid) && pid > 0) {
         try {
           process.kill(pid, 0);
@@ -13478,7 +13690,7 @@ var Hub = class {
         const path4 = join44(this.harness.dataRoot, "hub", "documents", receipt.document);
         const stat = lstatSync8(path4);
         if (!stat.isFile() || stat.size > HUB_MAX_BYTES) return "incomplete";
-        return digest(readFileSync22(path4)) === receipt.entry.delivery.sha256 ? "installed" : "changed";
+        return digest(readFileSync23(path4)) === receipt.entry.delivery.sha256 ? "installed" : "changed";
       } catch {
         return "incomplete";
       }
@@ -13493,7 +13705,7 @@ var Hub = class {
         if (receipt.entry.delivery.kind !== "document" || receipt.document !== `${receiptName(receipt.entry)}.json`) return false;
         const path4 = join44(root, "hub", "documents", receipt.document);
         const stat = lstatSync8(path4);
-        return stat.isFile() && stat.size <= HUB_MAX_BYTES && digest(readFileSync22(path4)) === receipt.entry.delivery.sha256;
+        return stat.isFile() && stat.size <= HUB_MAX_BYTES && digest(readFileSync23(path4)) === receipt.entry.delivery.sha256;
       }
       if (receipt.entry.delivery.kind === "registry") return receipt.resourceIds.length > 0 && receipt.resourceIds.every((id) => {
         if (!/^(skills|prompts|rules)\/[a-z0-9-]{1,64}$/.test(id)) return false;
@@ -13772,7 +13984,7 @@ var Hub = class {
     const path4 = join44(this.harness.env.root, "hub", "documents", receipt.document);
     const stat = lstatSync8(path4);
     if (!stat.isFile() || stat.size > HUB_MAX_BYTES) throw invalid("The saved document is not a bounded regular file.");
-    const content = readFileSync22(path4, "utf8");
+    const content = readFileSync23(path4, "utf8");
     if (receipt.entry.delivery.kind === "pi-package" || digest(content) !== receipt.entry.delivery.sha256) throw invalid("The saved document differs from the installed version. Import edited files explicitly instead.");
     return { entry: receipt.entry, content };
   }
@@ -14253,8 +14465,8 @@ function pageTools(tools4, options2 = {}) {
   const query = options2.query?.trim().toLowerCase();
   const matching = query ? tools4.filter((tool) => tool.name.toLowerCase().includes(query) || (tool.description ?? "").toLowerCase().includes(query)) : tools4;
   const offset = Math.max(0, Math.floor(options2.offset ?? 0));
-  const limit = Math.max(1, Math.min(Math.floor(options2.limit ?? TOOL_PAGE), 100));
-  const page2 = compactTools(matching.slice(offset, offset + limit));
+  const limit2 = Math.max(1, Math.min(Math.floor(options2.limit ?? TOOL_PAGE), 100));
+  const page2 = compactTools(matching.slice(offset, offset + limit2));
   const next = offset + page2.length;
   return { tools: page2, total: matching.length, ...next < matching.length ? { more: matching.length - next, nextOffset: next } : {} };
 }
@@ -14681,19 +14893,19 @@ ${action}`, standing: "switch", timeoutMs: 3e5 });
 };
 
 // src/history/lessons.ts
-import { mkdtempSync as mkdtempSync7, readFileSync as readFileSync25, rmSync as rmSync20, writeFileSync as writeFileSync10 } from "node:fs";
+import { mkdtempSync as mkdtempSync7, readFileSync as readFileSync26, rmSync as rmSync20, writeFileSync as writeFileSync10 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
 import { join as join48 } from "node:path";
 
 // src/refine/pi.ts
 init_fs();
 import { createHash as createHash10, randomUUID as randomUUID9 } from "node:crypto";
-import { cpSync as cpSync4, existsSync as existsSync20, mkdirSync as mkdirSync19, mkdtempSync as mkdtempSync6, readFileSync as readFileSync24, rmSync as rmSync19, writeFileSync as writeFileSync9 } from "node:fs";
+import { cpSync as cpSync4, existsSync as existsSync20, mkdirSync as mkdirSync19, mkdtempSync as mkdtempSync6, readFileSync as readFileSync25, rmSync as rmSync19, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
 import { dirname as dirname15, join as join47 } from "node:path";
 
 // src/refine/host.ts
-import { cpSync as cpSync3, existsSync as existsSync19, mkdtempSync as mkdtempSync5, readdirSync as readdirSync21, readFileSync as readFileSync23, rmSync as rmSync18, statSync as statSync11 } from "node:fs";
+import { cpSync as cpSync3, existsSync as existsSync19, mkdtempSync as mkdtempSync5, readdirSync as readdirSync22, readFileSync as readFileSync24, rmSync as rmSync18, statSync as statSync12 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join46, relative as relative6, sep as sep8 } from "node:path";
 var TEXT_LIMIT = 2e5;
@@ -14701,7 +14913,7 @@ var FILES_LIMIT = 40;
 function files2(dir2, into = [], base = dir2) {
   let names2;
   try {
-    names2 = readdirSync21(dir2);
+    names2 = readdirSync22(dir2);
   } catch {
     return into;
   }
@@ -14709,7 +14921,7 @@ function files2(dir2, into = [], base = dir2) {
     if (name === ".git" || name === "node_modules" || name.startsWith(".")) continue;
     const path4 = join46(dir2, name);
     try {
-      if (statSync11(path4).isDirectory()) files2(path4, into, base);
+      if (statSync12(path4).isDirectory()) files2(path4, into, base);
       else into.push(relative6(base, path4).split(sep8).join("/"));
     } catch {
     }
@@ -14719,7 +14931,7 @@ function files2(dir2, into = [], base = dir2) {
 }
 function readable(path4) {
   try {
-    const buffer = readFileSync23(path4);
+    const buffer = readFileSync24(path4);
     if (buffer.length > TEXT_LIMIT || buffer.includes(0)) return null;
     return buffer.toString("utf8");
   } catch {
@@ -14753,9 +14965,9 @@ var DEFAULT_REFINE_HOST = {
 
 // src/refine/trajectory.ts
 var TRUNC = (n) => `\u2026(+${n} chars \u2014 render truncation)`;
-function clip4(text10, limit) {
+function clip4(text10, limit2) {
   const clean2 = text10.replace(/\0/g, "");
-  return limit > 0 && clean2.length > limit ? `${clean2.slice(0, limit)}${TRUNC(clean2.length - limit)}` : clean2;
+  return limit2 > 0 && clean2.length > limit2 ? `${clean2.slice(0, limit2)}${TRUNC(clean2.length - limit2)}` : clean2;
 }
 function renderEvents(events2, options2) {
   const out = [];
@@ -14947,7 +15159,7 @@ var PiExecutor = class {
     const out = {};
     for (const name of record3.files ?? []) {
       try {
-        out[name] = readFileSync24(join47(rollout.dir, "deliverables", name), "utf8");
+        out[name] = readFileSync25(join47(rollout.dir, "deliverables", name), "utf8");
       } catch {
       }
     }
@@ -15047,7 +15259,7 @@ var slug2 = (text10) => text10.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace
 function keptLessons(root) {
   return paths(root).filter((path4) => path4.startsWith(`${LESSONS_FOLDER}/`)).flatMap((path4) => {
     try {
-      const text10 = readFileSync25(join48(wikiDir(root), `${path4}.md`), "utf8");
+      const text10 = readFileSync26(join48(wikiDir(root), `${path4}.md`), "utf8");
       const parsed = parse(text10);
       const front = parsed?.front ?? {};
       const sources = Array.isArray(front.sources) ? front.sources.filter((id) => typeof id === "string") : [];
@@ -15175,7 +15387,7 @@ ${run2.goal}
 init_errors();
 init_fs();
 import { randomUUID as randomUUID10 } from "node:crypto";
-import { existsSync as existsSync21, readdirSync as readdirSync22 } from "node:fs";
+import { existsSync as existsSync21, readdirSync as readdirSync23 } from "node:fs";
 import { join as join49 } from "node:path";
 var variantsFolder = (dir2) => existsSync21(join49(dir2, "variants")) || !existsSync21(join49(dir2, "harnesses")) ? join49(dir2, "variants") : join49(dir2, "harnesses");
 var Refinements = class {
@@ -15231,7 +15443,7 @@ var Refinements = class {
     const dir2 = join49(this.options.root(), "refine");
     if (!existsSync21(dir2)) return [];
     const out = [];
-    for (const name of readdirSync22(dir2).sort().reverse()) {
+    for (const name of readdirSync23(dir2).sort().reverse()) {
       if (name === "library") continue;
       const summary4 = readSummary(this.options.root(), name);
       if (summary4 && (!options2.scope || summary4.scope === options2.scope)) out.push(summary4);
@@ -15251,7 +15463,7 @@ var Refinements = class {
     const dir2 = refineDir(root, id);
     const baseVariant = readVariant(PI_SURFACE, join49(variantsFolder(dir2), "base"));
     const finals = new Set(summary4.recursion?.finals ?? []);
-    const labels = existsSync21(join49(dir2, "rollouts")) ? readdirSync22(join49(dir2, "rollouts")).sort() : [];
+    const labels = existsSync21(join49(dir2, "rollouts")) ? readdirSync23(join49(dir2, "rollouts")).sort() : [];
     return labels.map((label) => {
       const record3 = readJsonOr(join49(dir2, "rollouts", label, "rollout.json"), {});
       const base = summary4.base.find((entry2) => entry2.label === label);
@@ -15310,7 +15522,7 @@ var Refinements = class {
 };
 
 // src/variant/migrate.ts
-import { existsSync as existsSync22, readdirSync as readdirSync23, renameSync as renameSync9 } from "node:fs";
+import { existsSync as existsSync22, readdirSync as readdirSync24, renameSync as renameSync9 } from "node:fs";
 import { join as join50 } from "node:path";
 function move(from, to, moved) {
   if (!existsSync22(from) || existsSync22(to)) return;
@@ -15319,7 +15531,7 @@ function move(from, to, moved) {
 }
 function folders(path4) {
   try {
-    return readdirSync23(path4, { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => entry2.name);
+    return readdirSync24(path4, { withFileTypes: true }).filter((entry2) => entry2.isDirectory()).map((entry2) => entry2.name);
   } catch {
     return [];
   }
@@ -15657,11 +15869,11 @@ var Doctor = class {
 
 // src/doctor/checks.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
-import { accessSync as accessSync5, constants as constants6, existsSync as existsSync27, readFileSync as readFileSync29, statSync as statSync18 } from "node:fs";
-import { basename as basename12, delimiter as delimiter2, isAbsolute as isAbsolute8, join as join59 } from "node:path";
+import { accessSync as accessSync5, constants as constants6, existsSync as existsSync27, readFileSync as readFileSync30, statSync as statSync20 } from "node:fs";
+import { basename as basename12, delimiter as delimiter2, isAbsolute as isAbsolute8, join as join60 } from "node:path";
 
 // src/core/shell.ts
-import { accessSync as accessSync3, constants as constants3, statSync as statSync12 } from "node:fs";
+import { accessSync as accessSync3, constants as constants3, statSync as statSync13 } from "node:fs";
 import { win32 } from "node:path";
 var POWERSHELL_ARGS = ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command"];
 var POWERSHELL_UTF8 = "try { [Console]::OutputEncoding=[System.Text.Encoding]::UTF8 } catch {}\n";
@@ -15708,7 +15920,7 @@ function isWslLauncher(path4, env) {
 function isFile(path4) {
   try {
     accessSync3(path4, constants3.F_OK);
-    return statSync12(path4).isFile();
+    return statSync13(path4).isFile();
   } catch {
     return false;
   }
@@ -15718,19 +15930,19 @@ function isFile(path4) {
 import { AsyncLocalStorage } from "node:async_hooks";
 import { spawn as spawn2 } from "node:child_process";
 import { randomUUID as randomUUID12 } from "node:crypto";
-import { accessSync as accessSync4, constants as constants4, existsSync as existsSync24, lstatSync as lstatSync11, mkdtempSync as mkdtempSync8, realpathSync as realpathSync4, readdirSync as readdirSync24, rmSync as rmSync21, statSync as statSync14 } from "node:fs";
+import { accessSync as accessSync4, constants as constants4, existsSync as existsSync24, lstatSync as lstatSync11, mkdtempSync as mkdtempSync8, realpathSync as realpathSync4, readdirSync as readdirSync25, rmSync as rmSync21, statSync as statSync15 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
 import { join as join53 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/core/workspace.ts
 init_errors();
-import { lstatSync as lstatSync10, realpathSync as realpathSync3, statSync as statSync13 } from "node:fs";
+import { lstatSync as lstatSync10, realpathSync as realpathSync3, statSync as statSync14 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { basename as basename10, dirname as dirname16, isAbsolute as isAbsolute7, join as join52, relative as relative7, resolve as resolve8, sep as sep9 } from "node:path";
 function resolveWorkspaceRoot(cwd) {
   const canonicalCwd = realpathSync3(cwd);
-  if (!statSync13(canonicalCwd).isDirectory()) throw invalid("The working directory must be a directory.");
+  if (!statSync14(canonicalCwd).isDirectory()) throw invalid("The working directory must be a directory.");
   if (dirname16(canonicalCwd) === canonicalCwd) throw invalid("The filesystem root cannot be used as an active project workspace.");
   let directory = canonicalCwd;
   while (true) {
@@ -15752,14 +15964,14 @@ function resolveWritePath(candidate, cwd = process.cwd()) {
 }
 function isWithinWorkspace(workspaceRoot, canonicalCandidate) {
   const canonicalRoot = realpathSync3(workspaceRoot);
-  if (!statSync13(canonicalRoot).isDirectory()) throw invalid("The workspace root must be a directory.");
+  if (!statSync14(canonicalRoot).isDirectory()) throw invalid("The workspace root must be a directory.");
   const fromRoot = relative7(canonicalRoot, canonicalCandidate);
   return fromRoot === "" || fromRoot !== ".." && !fromRoot.startsWith(`..${sep9}`) && !isAbsolute7(fromRoot);
 }
 function verifyWorkspaceRoot(workspaceRoot) {
   const canonicalRoot = realpathSync3(workspaceRoot);
   if (dirname16(canonicalRoot) === canonicalRoot) throw invalid("The filesystem root cannot be used as an active project workspace.");
-  if (canonicalRoot !== resolve8(workspaceRoot) || !statSync13(canonicalRoot).isDirectory()) {
+  if (canonicalRoot !== resolve8(workspaceRoot) || !statSync14(canonicalRoot).isDirectory()) {
     throw invalid("The active project workspace changed after this run began.");
   }
   return canonicalRoot;
@@ -15802,7 +16014,7 @@ function systemExecutable(candidates) {
   for (const candidate of candidates) {
     try {
       accessSync4(candidate, constants4.X_OK);
-      if (statSync14(candidate).isFile()) return candidate;
+      if (statSync15(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -16023,7 +16235,7 @@ function assertNoExternalHardlinks(workspaceRoot) {
   const visit = (directory) => {
     let entries2;
     try {
-      entries2 = readdirSync24(directory, { withFileTypes: true });
+      entries2 = readdirSync25(directory, { withFileTypes: true });
     } catch (error) {
       throw new Error(`Workspace hard-link inspection failed at ${directory}; Bash was not run: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -16110,8 +16322,8 @@ function createWorkspaceBashOperations(workspaceRoot, options2 = {}) {
 }
 
 // src/terminal/terminals.ts
-import { chmodSync as chmodSync11, existsSync as existsSync26, lstatSync as lstatSync13, mkdirSync as mkdirSync22, readFileSync as readFileSync28, unlinkSync as unlinkSync5, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname20, join as join58 } from "node:path";
+import { chmodSync as chmodSync11, existsSync as existsSync26, lstatSync as lstatSync13, mkdirSync as mkdirSync22, readFileSync as readFileSync29, unlinkSync as unlinkSync5, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname20, join as join59 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { Type as Type2 } from "typebox";
 init_errors();
@@ -16201,6 +16413,239 @@ function withWorkspaceWriteScope(tool, note = "") {
   };
 }
 
+// src/context/attribution.ts
+import { readdirSync as readdirSync26, statSync as statSync16 } from "node:fs";
+import { join as join54 } from "node:path";
+var CHARS_PER_TOKEN = 4;
+function tokensOf(chars) {
+  return Math.max(0, Math.ceil(chars / CHARS_PER_TOKEN));
+}
+var HARNESS_TOOL_GROUPS = /* @__PURE__ */ new Set(["History", "Wiki", "Native", "World", "Progress", "Session", "Annotations"]);
+var FOUNDATION_SECTIONS = /* @__PURE__ */ new Set(["harness-identity", "tools", "reporting"]);
+var DYNAMIC_SECTIONS = /* @__PURE__ */ new Set(["wiki", "session-state", "references", "required-skills"]);
+var GROUP_ORDER2 = ["foundation", "variant", "application", "conversation", "reserved"];
+function lastEvent(events2, type) {
+  for (let index = events2.length - 1; index >= 0; index -= 1) {
+    const event = events2[index];
+    if (event?.type === type) return event.payload;
+  }
+  return null;
+}
+function sectionGroup(section2, dynamic) {
+  if (dynamic.has(section2.id)) return "conversation";
+  if (section2.sources.some((source) => source.kind === "variant")) return "variant";
+  return FOUNDATION_SECTIONS.has(section2.id) ? "foundation" : "application";
+}
+function toolChars(tool) {
+  try {
+    return JSON.stringify({ name: tool.name, description: tool.description, parameters: tool.parameters }).length;
+  } catch {
+    return tool.name.length + tool.description.length;
+  }
+}
+function shareOf(tokens, window) {
+  if (!window) return null;
+  return Math.max(0, Math.min(100, tokens / window * 100));
+}
+function skillCost(paths2) {
+  const sizes = [];
+  for (const path4 of paths2) {
+    let entries2;
+    try {
+      entries2 = readdirSync26(path4);
+    } catch {
+      continue;
+    }
+    for (const entry2 of entries2) {
+      try {
+        const stat = statSync16(join54(path4, entry2, "SKILL.md"));
+        if (stat.isFile()) sizes.push(stat.size);
+      } catch {
+      }
+    }
+  }
+  if (!sizes.length) return null;
+  const average = sizes.reduce((sum, size2) => sum + size2, 0) / sizes.length;
+  return { items: sizes.length, tokensEach: tokensOf(average) };
+}
+function onDemandOf(env, pack) {
+  const scope = pack.variant?.scope;
+  if (!scope) return [];
+  let built;
+  try {
+    built = materialise(env.root, { scope });
+  } catch {
+    return [];
+  }
+  const rows = [];
+  const skills = skillCost(built.skillPaths);
+  if (skills) rows.push({ id: "skills", title: "Skills (c6)", items: skills.items, tokensEach: skills.tokensEach, note: "loaded when a situation matches" });
+  if (built.subagents.length) rows.push({ id: "subagents", title: "Subagents (c5)", items: built.subagents.length, tokensEach: null, note: "each runs in its own context" });
+  const scripts = Object.keys(built.files).filter((path4) => path4.startsWith("scripts/") && !path4.endsWith("README.md"));
+  if (scripts.length) rows.push({ id: "scripts", title: "Scripts (c7)", items: scripts.length, tokensEach: null, note: "run, not read into context" });
+  return rows;
+}
+function attribution(env, runId) {
+  const pack = load2(env.root, runId);
+  if (!pack) return null;
+  const events2 = readEvents(env.root, runId);
+  const snapshot2 = lastEvent(events2, "context.snapshot");
+  const usage = lastEvent(events2, "usage.updated");
+  const sizes = pack.delivery?.sizes;
+  const updatedIds = pack.delivery?.updatedSectionIds ?? [];
+  const dynamic = pack.delivery ? new Set(updatedIds) : new Set([...DYNAMIC_SECTIONS].filter((id) => pack.sections.some((section2) => section2.id === id)));
+  const stable = pack.sections.filter((section2) => !dynamic.has(section2.id));
+  const window = typeof usage?.contextWindow === "number" && usage.contextWindow > 0 ? usage.contextWindow : null;
+  const measuredTokens = typeof usage?.contextTokens === "number" && usage.contextTokens > 0 ? usage.contextTokens : null;
+  let approximate = !sizes;
+  if (snapshot2?.systemPromptTruncated || snapshot2?.contextUpdateTruncated || snapshot2?.toolsTruncated) approximate = true;
+  const rows = [];
+  for (const section2 of stable) {
+    const chars = sizes?.system[section2.id] ?? section2.size;
+    const variantChars = section2.id === "tools" ? Math.min(section2.sources.find((source2) => source2.kind === "variant")?.chars ?? 0, chars) : 0;
+    const own = Math.max(0, chars - variantChars);
+    if (own > 0) {
+      rows.push({
+        id: section2.id,
+        title: section2.title,
+        group: sectionGroup(section2, dynamic),
+        tokens: tokensOf(own),
+        chars: own,
+        share: null,
+        always: true,
+        estimated: true,
+        budget: section2.budget,
+        ...section2.cut ? { cut: true } : {},
+        ...section2.sources.length ? { sources: section2.sources.map((source2) => ({ ...source2 })) } : {}
+      });
+    }
+    if (variantChars > 0) {
+      rows.push({ id: "tool-guidance", title: "Tool guidance (c4)", group: "variant", tokens: tokensOf(variantChars), chars: variantChars, share: null, always: true, estimated: true });
+    }
+  }
+  const framing = sizes?.systemFraming ?? 0;
+  if (framing > 0) {
+    rows.push({ id: "framing", title: "Prompt framing", group: "foundation", tokens: tokensOf(framing), chars: framing, share: null, always: true, estimated: true, note: "headings and the context-update guidance" });
+  }
+  const groupOfTool = /* @__PURE__ */ new Map();
+  for (const group of pack.toolGroups) for (const name of group.tools) groupOfTool.set(name, group.group);
+  for (const [group, harnessOwned] of [["foundation", true], ["application", false]]) {
+    const owned = (snapshot2?.tools ?? []).filter((tool) => HARNESS_TOOL_GROUPS.has(groupOfTool.get(tool.name) ?? "") === harnessOwned);
+    if (!owned.length) continue;
+    const chars = owned.reduce((sum, tool) => sum + toolChars(tool), 0);
+    const byGroup = /* @__PURE__ */ new Map();
+    for (const tool of owned) {
+      const name = groupOfTool.get(tool.name) ?? "Other tools";
+      byGroup.set(name, (byGroup.get(name) ?? 0) + 1);
+    }
+    rows.push({
+      id: harnessOwned ? "tools-harness" : "tools-application",
+      title: `Tool schemas \xB7 ${owned.length} ${owned.length === 1 ? "tool" : "tools"}`,
+      group,
+      tokens: tokensOf(chars),
+      chars,
+      share: null,
+      always: true,
+      estimated: true,
+      tools: [...byGroup].map(([name, count]) => ({ group: name, count }))
+    });
+  }
+  for (const id of updatedIds) {
+    const section2 = pack.sections.find((entry2) => entry2.id === id);
+    if (!section2) continue;
+    const chars = sizes?.update[section2.id] ?? section2.size;
+    if (!chars) continue;
+    rows.push({ id: section2.id, title: section2.title, group: "conversation", tokens: tokensOf(chars), chars, share: null, always: false, estimated: true });
+  }
+  const updateFraming = updatedIds.length ? sizes?.updateFraming ?? 0 : 0;
+  if (updateFraming > 0) {
+    rows.push({ id: "context-update", title: "Context update framing", group: "conversation", tokens: tokensOf(updateFraming), chars: updateFraming, share: null, always: false, estimated: true, note: "the message the sections arrived in" });
+  }
+  const prefix = rows.slice();
+  let prefixTokens = prefix.reduce((sum, row) => sum + row.tokens, 0);
+  let note = approximate ? "The pack was recorded without every per-section size, so the split is approximate." : "Rows are estimated from recorded characters, four per token, and reconciled to the measured request.";
+  let messages = 0;
+  let source = "estimate";
+  if (measuredTokens !== null) {
+    source = "measured";
+    const remainder = measuredTokens - prefixTokens;
+    if (remainder >= 0) messages = remainder;
+    else {
+      const scale = prefixTokens > 0 ? measuredTokens / prefixTokens : 0;
+      for (const row of prefix) {
+        row.tokens = Math.max(0, Math.floor(row.tokens * scale));
+        row.note = "scaled to the measured total";
+      }
+      prefixTokens = prefix.reduce((sum, row) => sum + row.tokens, 0);
+      messages = 0;
+      note = "The estimated prefix exceeded the measured request, so every row was scaled down to it.";
+    }
+    rows.push({ id: "messages", title: "Messages and tool results", group: "conversation", tokens: messages, chars: null, share: null, always: false, estimated: false, note: "measured by subtraction" });
+  } else {
+    note = `${note} No request has been measured yet.`;
+  }
+  const reserve = snapshot2?.compaction?.enabled === true ? Math.max(0, Math.round(snapshot2.compaction.reserveTokens)) : null;
+  if (reserve !== null) {
+    rows.push({ id: "compaction-reserve", title: "Compaction reserve", group: "reserved", tokens: reserve, chars: null, share: null, always: true, estimated: true, note: "Pi, auto-compaction" });
+  }
+  for (const row of rows) row.share = shareOf(row.tokens, window);
+  const used = measuredTokens ?? prefixTokens;
+  const free = window === null ? null : Math.max(0, window - used - (reserve ?? 0));
+  const totals2 = { foundation: 0, variant: 0, application: 0, conversation: 0, reserved: 0 };
+  for (const row of rows) totals2[row.group] += row.tokens;
+  const history = [];
+  const compactions = [];
+  for (const event of events2) {
+    if (event.type === "usage.updated") {
+      const payload2 = event.payload;
+      const used2 = typeof payload2.contextTokens === "number" ? payload2.contextTokens : null;
+      const request2 = typeof payload2.request?.index === "number" ? payload2.request.index : null;
+      const index = request2 ?? (typeof payload2.request === "number" ? payload2.request : null);
+      if (used2 === null || index === null) continue;
+      history.push({ request: index, used: used2, share: shareOf(used2, window), at: event.timestamp });
+    } else if (event.type === "compaction.ended") {
+      const payload2 = event.payload;
+      compactions.push({ at: event.timestamp, before: typeof payload2.tokensBefore === "number" ? payload2.tokensBefore : null, after: typeof payload2.tokensAfter === "number" ? payload2.tokensAfter : null });
+    }
+  }
+  return {
+    runId,
+    model: usage?.model ?? null,
+    provider: usage?.provider ?? null,
+    window,
+    used,
+    share: shareOf(used, window),
+    source,
+    request: typeof usage?.request?.index === "number" ? usage.request.index : null,
+    compaction: reserve === null ? null : { enabled: true, reserveTokens: reserve },
+    free,
+    rows: rows.sort((left, right) => GROUP_ORDER2.indexOf(left.group) - GROUP_ORDER2.indexOf(right.group)),
+    history,
+    compactions,
+    onDemand: onDemandOf(env, pack),
+    totals: totals2,
+    recordedAt: pack.compiledAt ?? null,
+    note
+  };
+}
+function rowText(env, runId, rowId) {
+  const pack = load2(env.root, runId);
+  if (!pack) return null;
+  if (rowId === "tools-harness" || rowId === "tools-application") {
+    const events2 = readEvents(env.root, runId);
+    const tools4 = lastEvent(events2, "context.snapshot")?.tools ?? [];
+    if (!tools4.length) return null;
+    const names2 = /* @__PURE__ */ new Map();
+    for (const group of pack.toolGroups) for (const name of group.tools) names2.set(name, group.group);
+    const harnessOwned = rowId === "tools-harness";
+    const lines2 = tools4.filter((tool) => HARNESS_TOOL_GROUPS.has(names2.get(tool.name) ?? "") === harnessOwned).map((tool) => `${names2.get(tool.name) ?? "Other tools"}: ${tool.name}`);
+    return { id: rowId, title: harnessOwned ? "Harness tool schemas" : "Application tool schemas", text: lines2.join("\n") };
+  }
+  const section2 = pack.sections.find((entry2) => entry2.id === rowId);
+  if (!section2) return null;
+  return { id: section2.id, title: section2.title, text: section2.body };
+}
+
 // src/sessions/workspaceBoundary.ts
 var WORKSPACE_FILE_WRITE_TOOLS = /* @__PURE__ */ new Set(["edit", "write"]);
 function inspectWorkspaceWrite(workspaceRoot, cwd, tool, input) {
@@ -16289,16 +16734,16 @@ function putIdle(path4, stream) {
   entries2.add(entry2);
   idle.set(path4, entries2);
 }
-function request(connection, body2, what, timeoutMs) {
+function request(connection, body2, what, timeoutMs, signal) {
   const reused = takeIdle(connection.socket);
-  return attempt(connection, body2, what, timeoutMs, reused).catch((error) => {
-    if (reused && error instanceof StaleConnection) return attempt(connection, body2, what, timeoutMs, void 0);
+  return attempt(connection, body2, what, timeoutMs, reused, signal).catch((error) => {
+    if (reused && error instanceof StaleConnection) return attempt(connection, body2, what, timeoutMs, void 0, signal);
     throw error;
   });
 }
 var StaleConnection = class extends Error {
 };
-function attempt(connection, body2, what, timeoutMs, reused) {
+function attempt(connection, body2, what, timeoutMs, reused, signal) {
   return new Promise((resolve19, reject2) => {
     const stream = reused ?? createConnection(connection.socket);
     let buffer = "";
@@ -16332,6 +16777,7 @@ function attempt(connection, body2, what, timeoutMs, reused) {
       if (settled3) return;
       settled3 = true;
       clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
       stream.off("connect", send);
       stream.off("data", onData);
       stream.off("error", onError);
@@ -16348,6 +16794,15 @@ function attempt(connection, body2, what, timeoutMs, reused) {
       stream.destroy();
       finish(() => reject2(new SocketError("timeout", `The harness did not answer ${what}.`)));
     }, timeoutMs);
+    const onAbort = () => {
+      stream.destroy();
+      finish(() => reject2(new SocketError("aborted", `${what} was cancelled.`)));
+    };
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
     stream.on("data", onData);
     stream.on("error", onError);
     stream.on("close", onClose);
@@ -16355,8 +16810,8 @@ function attempt(connection, body2, what, timeoutMs, reused) {
     else stream.on("connect", send);
   });
 }
-function socketCall(connection, call, params = {}, timeoutMs = 12e4, control) {
-  return request(connection, { call, params, ...control ? { control } : {} }, call, timeoutMs);
+function socketCall(connection, call, params = {}, timeoutMs = 12e4, control, signal) {
+  return request(connection, { call, params, ...control ? { control } : {} }, call, timeoutMs, signal);
 }
 
 // src/terminal/cli.ts
@@ -16631,7 +17086,10 @@ var TerminalController = class {
   }
   hooks;
   run = null;
+  lastRunId = null;
   pending = /* @__PURE__ */ new Map();
+  pendingRevision = 0;
+  pendingWaiters = /* @__PURE__ */ new Set();
   subagents = new SubagentMonitor();
   subagentParentRunId = null;
   ready = false;
@@ -16644,12 +17102,41 @@ var TerminalController = class {
   nativeId;
   seen = /* @__PURE__ */ new Map();
   commands = [];
+  pendingChanged() {
+    this.pendingRevision += 1;
+    for (const wake of this.pendingWaiters) wake();
+  }
+  setPending(key, value) {
+    this.pending.set(key, value);
+    this.pendingChanged();
+  }
+  deletePending(key) {
+    if (this.pending.delete(key)) this.pendingChanged();
+  }
+  async waitPending(revision) {
+    if (revision === this.pendingRevision && !this.disposed) {
+      await new Promise((resolve19) => {
+        const wake = () => {
+          clearTimeout(timer);
+          this.pendingWaiters.delete(wake);
+          resolve19();
+        };
+        const timer = setTimeout(wake, 2e4);
+        this.pendingWaiters.add(wake);
+      });
+    }
+    return { revision: this.pendingRevision, requests: [...this.pending.values()] };
+  }
   get nativeSessionId() {
     return this.nativeId;
   }
   get activeRun() {
     return this.run && !this.run.finished ? this.run : null;
   }
+  /** The run this terminal is showing, or the last one it finished: `/context` reads it after a reply. */
+  get lastRun() {
+    return this.activeRun?.runId ?? this.lastRunId;
+  }
   state() {
     return { ready: this.ready, dirty: this.dirty, active: !!this.activeRun || !!this.delivery };
   }
@@ -16665,6 +17152,7 @@ var TerminalController = class {
     if (delivery && text10 && delivery.text !== text10) throw new Error("The native prompt did not match the reserved delivery. Inspect the terminal before continuing.");
     const run2 = this.hooks.begin({ reservedRunId: delivery?.runId ?? null, nativeTurnId, text: text10, ...launch });
     this.run = run2;
+    this.lastRunId = run2.runId;
     this.subagentParentRunId = run2.runId;
     this.subagents.begin(run2.runId);
     run2.onInterrupt(() => void this.commands.push({ type: "interrupt" }));
@@ -16677,7 +17165,10 @@ var TerminalController = class {
     this.run?.finish(outcome, message4 ? { code: "terminal_attention", message: message4 } : void 0, reason);
     this.run = null;
     this.seen.clear();
-    this.pending.clear();
+    if (this.pending.size) {
+      this.pending.clear();
+      this.pendingChanged();
+    }
   }
   /** Hands the native process an instruction and waits until it acknowledges the prompt. */
   async send(runId, text10) {
@@ -16729,16 +17220,16 @@ var TerminalController = class {
     if (this.disposed || !this.activeRun || !descendant && event.runId !== this.activeRun.runId) return;
     if (event.type === "question.requested") {
       const payload2 = event.payload;
-      this.pending.set(String(payload2.questionId), { ...payload2, type: "question", requestId: payload2.questionId, runId: event.runId });
+      this.setPending(String(payload2.questionId), { ...payload2, type: "question", requestId: payload2.questionId, runId: event.runId });
     } else if (event.type === "approval.requested") {
       const payload2 = event.payload;
       if (!payload2.automatic && (descendant || payload2.target === "workspace-write")) {
-        this.pending.set(String(payload2.approvalId), { ...payload2, type: "approval", requestId: payload2.approvalId, runId: event.runId });
+        this.setPending(String(payload2.approvalId), { ...payload2, type: "approval", requestId: payload2.approvalId, runId: event.runId });
       }
     } else if (event.type === "approval.resolved") {
-      this.pending.delete(String(event.payload.approvalId));
+      this.deletePending(String(event.payload.approvalId));
     } else if (event.type === "question.answered") {
-      this.pending.delete(String(event.payload.questionId));
+      this.deletePending(String(event.payload.questionId));
     }
   }
   /** A child event that belongs to the active terminal parent run. */
@@ -16773,6 +17264,7 @@ var TerminalController = class {
       return {};
     }
     if (call === "terminal.pending") return { requests: [...this.pending.values()] };
+    if (call === "terminal.pending.wait") return this.waitPending(data.revision);
     if (call === "terminal.interrupt") return this.activeRun && this.hooks.interrupt ? this.hooks.interrupt(this.activeRun.runId) : {};
     if (call === "terminal.policy") {
       const run3 = this.activeRun;
@@ -16852,7 +17344,7 @@ var TerminalController = class {
       rememberable: policy.rememberable === true,
       standing: policy.standing
     });
-    this.pending.set(key, {
+    this.setPending(key, {
       type: "approval",
       requestId: key,
       runId: run2.runId,
@@ -16866,7 +17358,7 @@ var TerminalController = class {
     try {
       return { decision: await response };
     } finally {
-      this.pending.delete(key);
+      this.deletePending(key);
     }
   }
   async accept(event, data) {
@@ -16935,9 +17427,9 @@ var TerminalController = class {
         const summary4 = typeof data.summary === "string" && data.summary.trim() ? data.summary.trim() : void 0;
         const sketchMode = data.uiSketch === void 0 ? {} : { uiSketch: data.uiSketch };
         const response2 = run2.requestAnswer({ requestId: key, ...summary4 ? { summary: summary4 } : {}, ...sketchMode, question: String(data.question ?? ""), options: data.options ?? [], multiSelect: !!data.multiSelect, allowText: true });
-        this.pending.set(key, { type: "question", requestId: key, ...summary4 ? { summary: summary4 } : {}, ...sketchMode, question: String(data.question ?? ""), options: data.options ?? [], multiSelect: !!data.multiSelect });
+        this.setPending(key, { type: "question", requestId: key, ...summary4 ? { summary: summary4 } : {}, ...sketchMode, question: String(data.question ?? ""), options: data.options ?? [], multiSelect: !!data.multiSelect });
         this.seen.set(key, response2);
-        return response2.finally(() => this.pending.delete(key));
+        return response2.finally(() => this.deletePending(key));
       }
       const response = run2.requestApproval({
         requestId: key,
@@ -16946,12 +17438,12 @@ var TerminalController = class {
         operation: { tool: String(data.tool ?? data.target), args: data.args ?? {} },
         rememberable: false
       });
-      this.pending.set(key, { type: "approval", requestId: key, target: String(data.target ?? "Action"), action: String(data.action ?? "{}") });
+      this.setPending(key, { type: "approval", requestId: key, target: String(data.target ?? "Action"), action: String(data.action ?? "{}") });
       this.seen.set(key, response);
       try {
         return { decision: await response };
       } finally {
-        this.pending.delete(key);
+        this.deletePending(key);
       }
     }
     if (event === "usage") run2.emit("usage.updated", data);
@@ -16971,6 +17463,7 @@ var TerminalController = class {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    this.pendingChanged();
     this.ready = false;
     this.delivery?.reject(new Error("The terminal stopped before prompt acknowledgement."));
     this.delivery = null;
@@ -17013,32 +17506,32 @@ exit /b %ERRORLEVEL%\r
 
 // src/terminal/socket.ts
 import { randomBytes } from "node:crypto";
-import { chmodSync as chmodSync10, mkdirSync as mkdirSync21, readdirSync as readdirSync25, rmSync as rmSync22, statSync as statSync16 } from "node:fs";
+import { chmodSync as chmodSync10, mkdirSync as mkdirSync21, readdirSync as readdirSync27, rmSync as rmSync22, statSync as statSync18 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
 import { tmpdir as tmpdir7 } from "node:os";
-import { dirname as dirname18, join as join55 } from "node:path";
+import { dirname as dirname18, join as join56 } from "node:path";
 init_errors();
 init_fs();
 var MAX_REQUEST_BYTES = 1024 * 1024;
 var MAX_SOCKET_PATH = 100;
 function socketPath(stateDir) {
   if (process.platform === "win32") return `\\\\.\\pipe\\xingular-harness-${randomBytes(12).toString("hex")}`;
-  const path4 = join55(stateDir, "run", `harness-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
+  const path4 = join56(stateDir, "run", `harness-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
   if (Buffer.byteLength(path4) <= MAX_SOCKET_PATH) return path4;
-  return join55(tmpdir7(), `xh-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
+  return join56(tmpdir7(), `xh-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
 }
 var OWN_SOCKET = /^harness-(\d+)-[0-9a-f]+\.sock$/;
 function pruneDeadSockets(folder2) {
   let names2;
   try {
-    names2 = readdirSync25(folder2);
+    names2 = readdirSync27(folder2);
   } catch {
     return;
   }
   for (const name of names2) {
     const pid = Number(OWN_SOCKET.exec(name)?.[1]);
     if (!pid || pid === process.pid || isRunning(pid)) continue;
-    rmSync22(join55(folder2, name), { force: true });
+    rmSync22(join56(folder2, name), { force: true });
   }
 }
 function isRunning(pid) {
@@ -17050,8 +17543,8 @@ function isRunning(pid) {
   }
 }
 function alternateSocketPath(path4) {
-  const candidate = join55(dirname18(path4), `harness-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
-  return Buffer.byteLength(candidate) <= MAX_SOCKET_PATH ? candidate : join55(tmpdir7(), `xh-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
+  const candidate = join56(dirname18(path4), `harness-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
+  return Buffer.byteLength(candidate) <= MAX_SOCKET_PATH ? candidate : join56(tmpdir7(), `xh-${process.pid}-${randomBytes(8).toString("hex")}.sock`);
 }
 var isPipePath = (path4) => path4.startsWith("\\\\.\\pipe\\");
 function refusedBind(path4, error) {
@@ -17066,7 +17559,7 @@ function refusedBind(path4, error) {
   }
   let folder2;
   try {
-    const stat = statSync16(dirname18(path4));
+    const stat = statSync18(dirname18(path4));
     folder2 = `${dirname18(path4)} is owned by uid ${stat.uid} with mode ${(stat.mode & 511).toString(8)}`;
   } catch {
     folder2 = `${dirname18(path4)} could not be read`;
@@ -17263,12 +17756,12 @@ var SessionSocket = class {
 };
 
 // src/terminal/logs.ts
-import { closeSync as closeSync5, openSync as openSync5, readSync, statSync as statSync17 } from "node:fs";
-import { join as join56 } from "node:path";
+import { closeSync as closeSync5, openSync as openSync5, readSync, statSync as statSync19 } from "node:fs";
+import { join as join57 } from "node:path";
 var LOG_READ_CHUNK_BYTES = 32 * 1024;
 function harnessLogInfo(stateDir) {
   try {
-    const stat = statSync17(join56(stateDir, "harness.log"));
+    const stat = statSync19(join57(stateDir, "harness.log"));
     if (!stat.isFile()) throw new Error("The Harness diagnostics path is not a regular file.");
     return { size: stat.size };
   } catch (error) {
@@ -17280,8 +17773,8 @@ function readHarnessLogChunk(stateDir, snapshotSize, offset) {
   if (!Number.isSafeInteger(snapshotSize) || snapshotSize < 0 || !Number.isSafeInteger(offset) || offset < 0 || offset >= snapshotSize) {
     throw new Error("The Harness diagnostics snapshot range is invalid.");
   }
-  const path4 = join56(stateDir, "harness.log");
-  const current2 = statSync17(path4);
+  const path4 = join57(stateDir, "harness.log");
+  const current2 = statSync19(path4);
   if (!current2.isFile() || current2.size < snapshotSize) throw new Error("The Harness diagnostics file changed while it was being read.");
   const length = Math.min(LOG_READ_CHUNK_BYTES, snapshotSize - offset);
   const buffer = Buffer.allocUnsafe(length);
@@ -17325,7 +17818,7 @@ function readTerminalTrajectory(root, sessionId, nativeSessionId, runId, afterSe
 }
 
 // src/terminal/browserControl.ts
-import { constants as constants5, closeSync as closeSync6, fstatSync, lstatSync as lstatSync12, openSync as openSync6, readFileSync as readFileSync27, readdirSync as readdirSync26, realpathSync as realpathSync5 } from "node:fs";
+import { constants as constants5, closeSync as closeSync6, fstatSync, lstatSync as lstatSync12, openSync as openSync6, readFileSync as readFileSync28, readdirSync as readdirSync28, realpathSync as realpathSync5 } from "node:fs";
 
 // src/plugins/surfaces.ts
 function describePlugin(plugin) {
@@ -17336,7 +17829,7 @@ function describePlugin(plugin) {
 // src/terminal/browserControl.ts
 init_errors();
 import * as path3 from "node:path";
-import { basename as basename11, dirname as dirname19, join as join57, relative as relative8, resolve as resolve9 } from "node:path";
+import { basename as basename11, dirname as dirname19, join as join58, relative as relative8, resolve as resolve9 } from "node:path";
 var MAX_CONTENT = 256 * 1024;
 function isWithinBoundary(boundary, file2, pathApi = path3) {
   const within2 = pathApi.relative(boundary, file2);
@@ -17347,7 +17840,7 @@ function readText2(path4) {
   try {
     const stat = fstatSync(fd);
     if (!stat.isFile() || stat.size > MAX_CONTENT) throw invalid("Preview requires a regular text file smaller than 256 KiB.");
-    return readFileSync27(fd, "utf8");
+    return readFileSync28(fd, "utf8");
   } finally {
     closeSync6(fd);
   }
@@ -17446,7 +17939,7 @@ var BrowserControl = class {
       });
       if (/^skills\/[^/]+\/SKILL\.md$/.test(path4) && current2 !== void 0) {
         const name = path4.split("/")[1];
-        const fullPath = join57(pinned.dir, path4);
+        const fullPath = join58(pinned.dir, path4);
         if (!items.some((item) => item.section === "skills" && item.path === fullPath)) add({
           id: `variant-skill:${path4}`,
           section: "skills",
@@ -17497,7 +17990,7 @@ var BrowserControl = class {
     if (!item.path) throw invalid("This resource has no file.");
     const plugin = snapshot2.plugins.find((plugin2) => plugin2.id === item.pluginId);
     const registryItem = item.componentId ? list5(root).find((entry2) => entry2.id === item.componentId) : void 0;
-    const boundary = realpathSync5(registryItem && !registryItem.builtin ? join57(root, "registry") : plugin?.path ?? dirname19(item.path));
+    const boundary = realpathSync5(registryItem && !registryItem.builtin ? join58(root, "registry") : plugin?.path ?? dirname19(item.path));
     const file2 = realpathSync5(item.path);
     if (!isWithinBoundary(boundary, file2)) throw invalid("Resource is outside its owner folder.");
     return { content: readText2(file2) };
@@ -17511,9 +18004,9 @@ var BrowserControl = class {
     let directories = 0;
     const visit = (directory, depth2 = 0) => {
       if (++directories > 100 || depth2 > 16) throw invalid("Skill import exceeds its directory limit.");
-      for (const name of readdirSync26(directory)) {
+      for (const name of readdirSync28(directory)) {
         if (name.startsWith(".")) continue;
-        const path4 = join57(directory, name);
+        const path4 = join58(directory, name);
         const stat = lstatSync12(path4);
         if (stat.isSymbolicLink()) throw invalid("Skill imports cannot contain symbolic links.");
         if (stat.isDirectory()) {
@@ -17523,7 +18016,7 @@ var BrowserControl = class {
         if (!stat.isFile() || files3.length >= 100 || stat.size > 10 * 1024 * 1024) throw invalid("Skill import exceeds its file limit.");
         bytes += stat.size;
         if (bytes > 10 * 1024 * 1024) throw invalid("Skill import exceeds 10 MiB.");
-        files3.push({ path: relative8(folder2, path4), content: readFileSync27(path4).toString("base64"), encoding: "base64" });
+        files3.push({ path: relative8(folder2, path4), content: readFileSync28(path4).toString("base64"), encoding: "base64" });
       }
     };
     if (lstatSync12(folder2).isSymbolicLink()) throw invalid("Choose a regular skill folder.");
@@ -17568,12 +18061,12 @@ function resourceIdentity(loading) {
 }
 function defaultAssets() {
   const here = dirname20(fileURLToPath2(import.meta.url));
-  const dist = [here, join58(here, "..", ".."), join58(here, "..", "..", "dist"), join58(here, "..", "dist")].find((folder2) => existsSync26(join58(folder2, "terminal-pi.js"))) ?? here;
+  const dist = [here, join59(here, "..", ".."), join59(here, "..", "..", "dist"), join59(here, "..", "dist")].find((folder2) => existsSync26(join59(folder2, "terminal-pi.js"))) ?? here;
   return {
     node: process.execPath,
-    cli: join58(dist, "cli.js"),
-    piExtension: join58(dist, "terminal-pi.js"),
-    openTui: join58(dist, "terminal-opentui.js")
+    cli: join59(dist, "cli.js"),
+    piExtension: join59(dist, "terminal-pi.js"),
+    openTui: join59(dist, "terminal-opentui.js")
   };
 }
 var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set(["read", "grep", "find", "ls"]);
@@ -17690,10 +18183,10 @@ var Terminals = class {
   }
   /** The commands a terminal session finds on PATH. Rewritten only when they change. */
   ensureCommands() {
-    const bin = join58(this.options.stateDir, "run", "bin");
+    const bin = join59(this.options.stateDir, "run", "bin");
     mkdirSync22(bin, { recursive: true });
     for (const name of ["agentx-wiki", "agentx-mcp", "agentx-wiki.cmd", "agentx-mcp.cmd"]) {
-      const path4 = join58(bin, name);
+      const path4 = join59(bin, name);
       try {
         if (lstatSync13(path4).isFile()) unlinkSync5(path4);
       } catch {
@@ -17701,10 +18194,10 @@ var Terminals = class {
     }
     for (const [name, mode2] of [[WIKI_COMMAND, "wiki"], [APPS_COMMAND, "mcp"]]) {
       for (const file2 of terminalCommandFiles(process.platform, this.assets.node, this.assets.cli, name, mode2)) {
-        const path4 = join58(bin, file2.name);
+        const path4 = join59(bin, file2.name);
         let current2 = null;
         try {
-          current2 = readFileSync28(path4, "utf8");
+          current2 = readFileSync29(path4, "utf8");
         } catch {
           current2 = null;
         }
@@ -18034,6 +18527,13 @@ var Terminals = class {
         throw new HarnessError("unknown_method", `Unknown call ${call}.`);
     }
   }
+  /** `/context`: what the session's latest request was made of, and one row's text on request. */
+  contextCall(live, params) {
+    const runId = live.controller.lastRun;
+    if (!runId) return { attribution: null, text: null };
+    const text10 = typeof params.section === "string" && params.section ? rowText(this.options.env, runId, params.section) : null;
+    return { attribution: attribution(this.options.env, runId), text: text10 };
+  }
   /** `/usage:analysis` and `/usage:limit`: usage for this session's own account, project or session. */
   async usageCall(live, call, params) {
     const usage = this.options.usage;
@@ -18187,7 +18687,7 @@ var Terminals = class {
     return live;
   }
   historyDir(input) {
-    return join58(input.sessionFolder, "pi");
+    return join59(input.sessionFolder, "pi");
   }
   runRecord(live, runId, text10) {
     const { input } = live;
@@ -18685,6 +19185,7 @@ ${formatBashCommandForApproval(command)}`,
             return { globalTools: policy.globalTools.pi ?? [] };
           }
           if (call.startsWith("terminal.usage.")) return this.usageCall(live, call, params);
+          if (call === "terminal.context") return this.contextCall(live, params);
           if (call !== "terminal.resources") return live.controller.control(call, params);
           const current2 = await this.options.plugins?.loading({ cwd: input.cwd, agentDir: configDir(accounts.dir, preparedAccount), install: false, caller: { projectId: input.projectId ?? null } }) ?? null;
           const currentVariant = variant ? materialise(root, { dir: variant.dir, scope: variant.scope }, { trust: this.options.trust ?? null }) : null;
@@ -18797,11 +19298,11 @@ ${formatBashCommandForApproval(command)}`,
 var pass = (evidence) => ({ status: "pass", evidence });
 var fail = (evidence, remedy) => ({ status: "fail", evidence, remedy });
 function resolvedExecutable(name) {
-  const paths2 = isAbsolute8(name) ? [name] : (process.env.PATH ?? "").split(delimiter2).filter(Boolean).map((dir2) => join59(dir2, name));
+  const paths2 = isAbsolute8(name) ? [name] : (process.env.PATH ?? "").split(delimiter2).filter(Boolean).map((dir2) => join60(dir2, name));
   for (const path4 of paths2) {
     try {
       accessSync5(path4, constants6.X_OK);
-      if (statSync18(path4).isFile()) return path4;
+      if (statSync20(path4).isFile()) return path4;
     } catch {
     }
   }
@@ -18821,7 +19322,7 @@ async function builtinChecks(harness, context, secrets, assets = defaultAssets()
       const saved = harness.accounts.overview().accounts.find((item) => item.id === selected.id);
       const inspected = await harness.accounts.inspect(selected.id, signal);
       if (!inspected.credentials) return fail("The pinned account has no saved provider credentials.", "Sign in or add a key in /accounts.");
-      return { status: saved.state.health === "ok" || saved.state.health === "unknown" ? "pass" : "warning", evidence: `Credentials are configured. Saved health: ${saved.state.health}; checked ${saved.state.lastCheckedAt ?? "never"}. ${saved.state.limits.map((limit) => `${limit.label || limit.id}: ${limit.usedPercent}% used; resets ${limit.resetsAt ?? "unknown"}`).join("; ")} ${saved.state.lastError ? `Saved issue: ${saved.state.lastError.category}.` : ""} This does not verify authentication with the provider.`, remedy: saved.state.health === "ok" ? void 0 : "Use the model live probe to verify current provider access." };
+      return { status: saved.state.health === "ok" || saved.state.health === "unknown" ? "pass" : "warning", evidence: `Credentials are configured. Saved health: ${saved.state.health}; checked ${saved.state.lastCheckedAt ?? "never"}. ${saved.state.limits.map((limit2) => `${limit2.label || limit2.id}: ${limit2.usedPercent}% used; resets ${limit2.resetsAt ?? "unknown"}`).join("; ")} ${saved.state.lastError ? `Saved issue: ${saved.state.lastError.category}.` : ""} This does not verify authentication with the provider.`, remedy: saved.state.health === "ok" ? void 0 : "Use the model live probe to verify current provider access." };
     }),
     check2("accounts.inventory", "account", "Other saved accounts", async () => {
       const others = harness.accounts.overview().accounts.filter((item) => item.id !== context.accountId);
@@ -18960,7 +19461,7 @@ async function builtinChecks(harness, context, secrets, assets = defaultAssets()
         if (item.path) {
           try {
             accessSync5(item.path, constants6.R_OK);
-            if (item.kind === "skill") readFileSync29(item.path, "utf8");
+            if (item.kind === "skill") readFileSync30(item.path, "utf8");
           } catch {
             problems.push(`${item.name}: resource cannot be read`);
           }
@@ -19116,7 +19617,7 @@ async function diagnosticProbe(harness, context, inputSignal, action) {
 
 // src/plugins/hooks.ts
 import { chmodSync as chmodSync12 } from "node:fs";
-import { join as join60 } from "node:path";
+import { join as join61 } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 init_fs();
 var HOOK_EVENTS = ["wiki.page.saved", "history.run.ended"];
@@ -19131,7 +19632,7 @@ function entryEvent(change) {
 var Hooks = class {
   constructor(options2) {
     this.options = options2;
-    this.statusPath = join60(options2.stateDir, "plugin-hooks.json");
+    this.statusPath = join61(options2.stateDir, "plugin-hooks.json");
     this.stop = onChange((change) => {
       if (change.wiki === this.wiki) this.emit(entryEvent(change));
     });
@@ -19247,7 +19748,7 @@ var Hooks = class {
 init_errors();
 init_fs();
 import { chmodSync as chmodSync13 } from "node:fs";
-import { join as join61 } from "node:path";
+import { join as join62 } from "node:path";
 var APPROVAL_KEYS = ["chat", "pi"];
 function decide(policy, key, sessionId, target) {
   if (policy.auto[key]) return "always";
@@ -19262,7 +19763,7 @@ var approvalKey = (run2) => run2.mode === "chat" ? "chat" : run2.harness;
 var Approvals = class {
   constructor(stateDir, bus) {
     this.bus = bus;
-    this.path = join61(stateDir, "approvals.json");
+    this.path = join62(stateDir, "approvals.json");
   }
   bus;
   path;
@@ -19664,7 +20165,7 @@ var RunRegistry = class {
 // src/sessions/sessions.ts
 import { randomUUID as randomUUID17 } from "node:crypto";
 import { existsSync as existsSync28, mkdirSync as mkdirSync23 } from "node:fs";
-import { isAbsolute as isAbsolute9, join as join62 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join63 } from "node:path";
 init_errors();
 init_fs();
 
@@ -19758,12 +20259,12 @@ function runLineageJoin(root, runId) {
 }
 
 // src/sessions/sessionState.ts
-import { readFileSync as readFileSync30 } from "node:fs";
+import { readFileSync as readFileSync31 } from "node:fs";
 function latestSessionName(historyFile) {
   if (!historyFile) return null;
   let text10;
   try {
-    text10 = readFileSync30(historyFile, "utf8");
+    text10 = readFileSync31(historyFile, "utf8");
   } catch {
     return null;
   }
@@ -19858,7 +20359,7 @@ init_errors();
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 import { spawn as spawn4 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
-import { constants as fsConstants, realpathSync as realpathSync6, statSync as statSync19 } from "node:fs";
+import { constants as fsConstants, realpathSync as realpathSync6, statSync as statSync21 } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { dirname as dirname21, resolve as resolve10 } from "node:path";
 var writeAuthorization = new AsyncLocalStorage2();
@@ -19931,7 +20432,7 @@ function nearestExistingDirectory(path4) {
   while (true) {
     try {
       const canonical2 = realpathSync6(current2);
-      if (!statSync19(canonical2).isDirectory()) throw new Error(`Write scope is not a directory: ${canonical2}`);
+      if (!statSync21(canonical2).isDirectory()) throw new Error(`Write scope is not a directory: ${canonical2}`);
       return canonical2;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -20295,6 +20796,17 @@ function contextToolSpecs(session) {
   });
   return { tools: tools4.map((entry2) => entry2.spec), truncated: source.length > MAX_TOOL_SPECS || tools4.some((entry2) => entry2.truncated) };
 }
+function compactionSettings(session) {
+  const manager2 = session.settingsManager;
+  if (!manager2?.getCompactionSettings) return null;
+  try {
+    const model = session.model?.id && session.model.provider ? { provider: session.model.provider, id: session.model.id } : void 0;
+    const settings = manager2.getCompactionSettings(model);
+    return { enabled: settings.enabled === true, reserveTokens: Math.max(0, Math.round(settings.reserveTokens || 0)) };
+  } catch {
+    return null;
+  }
+}
 var numberField = (event, key, fallback = 0) => typeof event[key] === "number" && Number.isFinite(event[key]) ? event[key] : fallback;
 var stringField = (event, key, fallback = "") => typeof event[key] === "string" ? event[key] : fallback;
 var lastLine = (text10) => {
@@ -20344,10 +20856,12 @@ async function runTurn(run2, session, params) {
   const systemPrompt = limitedText(session.systemPrompt ?? params.system, MAX_SYSTEM_PROMPT_CHARS);
   const contextUpdate = limitedText(params.update?.content ?? "", MAX_SYSTEM_PROMPT_CHARS);
   const toolSpecs = contextToolSpecs(session);
+  const compaction = compactionSettings(session);
   run2.emit("context.snapshot", {
     systemPrompt: systemPrompt.text,
     ...contextUpdate.text ? { contextUpdate: contextUpdate.text } : {},
     tools: toolSpecs.tools,
+    ...compaction ? { compaction } : {},
     ...systemPrompt.truncated ? { systemPromptTruncated: true } : {},
     ...contextUpdate.truncated ? { contextUpdateTruncated: true } : {},
     ...toolSpecs.truncated ? { toolsTruncated: true } : {}
@@ -20532,14 +21046,14 @@ async function runTurn(run2, session, params) {
         break;
       }
       case "compaction_end": {
-        const compaction = event;
-        const summary4 = evidenceText(compaction.result);
+        const compaction2 = event;
+        const summary4 = evidenceText(compaction2.result);
         const boundedSummary = summary4 ? limitedText(summary4) : null;
         run2.emit("compaction.ended", {
-          reason: stringField(compaction, "reason", "context limit"),
-          aborted: compaction.aborted === true,
-          ...typeof compaction.willRetry === "boolean" ? { willRetry: compaction.willRetry } : {},
-          ...stringField(compaction, "errorMessage") ? { error: stringField(compaction, "errorMessage").slice(0, 1e3) } : {},
+          reason: stringField(compaction2, "reason", "context limit"),
+          aborted: compaction2.aborted === true,
+          ...typeof compaction2.willRetry === "boolean" ? { willRetry: compaction2.willRetry } : {},
+          ...stringField(compaction2, "errorMessage") ? { error: stringField(compaction2, "errorMessage").slice(0, 1e3) } : {},
           ...boundedSummary ? { summary: boundedSummary.text, ...boundedSummary.truncated ? { summaryTruncated: true } : {} } : {}
         });
         if (slice) slice.compactions += 1;
@@ -21290,7 +21804,7 @@ Attached saved file references:`);
       ...input.effort ? { effort: input.effort } : {}
     });
     try {
-      writeJson(join62(runDir(root, runId), "caller.json"), caller);
+      writeJson(join63(runDir(root, runId), "caller.json"), caller);
     } catch {
     }
     const fail3 = (error, code = "provider_unavailable") => {
@@ -21497,7 +22011,7 @@ Attached saved file references:`);
 // src/sessions/sideQuestions.ts
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir as tmpdir8 } from "node:os";
-import { join as join63 } from "node:path";
+import { join as join64 } from "node:path";
 import { z as z6 } from "zod";
 init_errors();
 init_fs();
@@ -21557,12 +22071,12 @@ function redactText(value) {
   const scrubbed = /\b(?:credentials?|private[_-]?key|auth|cookie|secret|password|token|api[_-]?key|client[_-]?id)\b/i.test(redacted) ? String(scrubSensitive(redacted)) : redacted;
   return scrubbed.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
 }
-function bounded2(text10, limit, omitted, fromEnd = false) {
-  if (text10.length <= limit) return text10;
+function bounded2(text10, limit2, omitted, fromEnd = false) {
+  if (text10.length <= limit2) return text10;
   const marker = `
 [${omitted}]
 `;
-  const room = Math.max(0, limit - marker.length);
+  const room = Math.max(0, limit2 - marker.length);
   return fromEnd ? `${marker}${text10.slice(-room)}` : `${text10.slice(0, room)}${marker}`;
 }
 function eventPayload(event) {
@@ -21698,7 +22212,7 @@ ${note.body}`;
         return `${reference.label ?? reference.path}: this selected reference is unavailable.`;
       }
     });
-    const sessionDir = await mkdtemp(join63(tmpdir8(), "xh-side-question-"));
+    const sessionDir = await mkdtemp(join64(tmpdir8(), "xh-side-question-"));
     this.sessionDirs.set(runId, sessionDir);
     const caller = { ...input.caller, runId, sessionId };
     try {
@@ -21772,13 +22286,13 @@ init_fs();
 import { createHash as createHash15, randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync30, mkdirSync as mkdirSync25, realpathSync as realpathSync7, rmSync as rmSync23 } from "node:fs";
 import { tmpdir as tmpdir9 } from "node:os";
-import { basename as basename13, dirname as dirname23, isAbsolute as isAbsolute10, join as join65, resolve as resolve11 } from "node:path";
+import { basename as basename13, dirname as dirname23, isAbsolute as isAbsolute10, join as join66, resolve as resolve11 } from "node:path";
 
 // src/worktrees/copy.ts
 init_errors();
 init_fs();
 import { copyFileSync as copyFileSync5, existsSync as existsSync29, lstatSync as lstatSync14, mkdirSync as mkdirSync24 } from "node:fs";
-import { dirname as dirname22, join as join64 } from "node:path";
+import { dirname as dirname22, join as join65 } from "node:path";
 
 // src/worktrees/git.ts
 init_errors();
@@ -21877,8 +22391,8 @@ function copyFiles(from, to, paths2) {
     } catch {
       continue;
     }
-    const source = join64(from, relative10);
-    const target = join64(to, relative10);
+    const source = join65(from, relative10);
+    const target = join65(to, relative10);
     if (existsSync29(target)) {
       report.skipped.push({ path: relative10, reason: "exists" });
       continue;
@@ -21931,7 +22445,7 @@ async function ignoredFiles(checkout) {
     if (pathBytes > IGNORED_PATH_BYTES_CAP) throw ignoredFilesError("the ignored paths exceed the snapshot limit");
     let stat;
     try {
-      stat = lstatSync14(join64(checkout, relative10));
+      stat = lstatSync14(join65(checkout, relative10));
     } catch {
       throw ignoredFilesError(`could not inspect ${relative10}`);
     }
@@ -21946,7 +22460,7 @@ function ignoredFilesError(reason) {
   return new HarnessError("worktree_has_work", `Ignored files cannot be safely preserved: ${reason}.`, "Move or remove those files, then try again.");
 }
 async function includedFiles(checkout) {
-  const patterns2 = join64(checkout, INCLUDE_FILE);
+  const patterns2 = join65(checkout, INCLUDE_FILE);
   if (!existsSync29(patterns2)) return [];
   const ignored = new Set(nulList((await git(checkout, ["ls-files", "--others", "--ignored", "--exclude-standard", "-z"])).stdout));
   const matching = nulList((await git(checkout, ["ls-files", "--others", "--ignored", `--exclude-from=${patterns2}`, "-z"])).stdout);
@@ -21995,11 +22509,11 @@ var Worktrees = class {
   leaseCounts = /* @__PURE__ */ new Map();
   chain = Promise.resolve();
   constructor(stateDir, options2 = {}) {
-    this.root = options2.root ?? join65(stateDir, "worktrees");
+    this.root = options2.root ?? join66(stateDir, "worktrees");
     this.branchPrefix = options2.branchPrefix ?? "wt/";
     this.keep = options2.keep ?? 15;
-    this.registryFile = join65(stateDir, "worktrees.json");
-    this.trust = new SetupTrust(join65(stateDir, "worktree-setup-trust.json"));
+    this.registryFile = join66(stateDir, "worktrees.json");
+    this.trust = new SetupTrust(join66(stateDir, "worktree-setup-trust.json"));
     this.recover(true);
   }
   // ---- Registry -------------------------------------------------------------------------------
@@ -22091,15 +22605,15 @@ var Worktrees = class {
   }
   uniqueName(repoRoot, wanted) {
     const taken = new Set(this.read().worktrees.filter((record3) => record3.repoRoot === repoRoot && !record3.removed).map((record3) => record3.name));
-    const folder2 = join65(this.root, this.repoKey(repoRoot));
+    const folder2 = join66(this.root, this.repoKey(repoRoot));
     if (wanted !== void 0) {
       if (!NAME2.test(wanted)) throw invalid("A worktree name uses lowercase letters, digits and dashes (at most 63).");
-      if (taken.has(wanted) || existsSync30(join65(folder2, wanted))) throw new HarnessError("worktree_exists", `A worktree named ${wanted} already exists.`);
+      if (taken.has(wanted) || existsSync30(join66(folder2, wanted))) throw new HarnessError("worktree_exists", `A worktree named ${wanted} already exists.`);
       return wanted;
     }
     for (; ; ) {
       const name = `wt-${randomBytes2(3).toString("hex")}`;
-      if (!taken.has(name) && !existsSync30(join65(folder2, name))) return name;
+      if (!taken.has(name) && !existsSync30(join66(folder2, name))) return name;
     }
   }
   async branchName(repoRoot, name) {
@@ -22121,7 +22635,7 @@ var Worktrees = class {
       const baseCommit = (await git(repoRoot, ["rev-parse", "--verify", "-q", `${baseRef}^{commit}`], { allowFail: true })).stdout.trim();
       if (!baseCommit) throw invalid(`${baseRef} does not name a commit.`);
       const branch = input.branch ? await this.branchName(repoRoot, input.branch) : null;
-      const path4 = join65(this.root, this.repoKey(repoRoot), name);
+      const path4 = join66(this.root, this.repoKey(repoRoot), name);
       mkdirSync25(dirname23(path4), { recursive: true });
       await git(repoRoot, ["worktree", "add", ...branch ? ["-b", branch] : ["--detach"], path4, baseCommit]);
       const at = now();
@@ -22151,7 +22665,7 @@ var Worktrees = class {
         carried = copyFiles(repoRoot, path4, await untrackedFiles(repoRoot));
       }
       const included = copyFiles(repoRoot, path4, await includedFiles(repoRoot));
-      const setup = input.setup === false ? { state: "none", hash: null, log: null } : await runSetup({ checkout: path4, source: repoRoot, name, repoRoot, logFile: join65(this.root, "logs", `${record3.id}.setup.log`), trust: this.trust });
+      const setup = input.setup === false ? { state: "none", hash: null, log: null } : await runSetup({ checkout: path4, source: repoRoot, name, repoRoot, logFile: join66(this.root, "logs", `${record3.id}.setup.log`), trust: this.trust });
       return { worktree: record3, carried: { ...carried, patched }, included, setup };
     });
   }
@@ -22258,7 +22772,7 @@ var Worktrees = class {
   }
   /** Records the worktree's commits and working changes under a snapshot ref. */
   async snapshot(record3, ignored) {
-    const index = join65(tmpdir9(), `xharness-index-${record3.id}-${randomBytes2(4).toString("hex")}`);
+    const index = join66(tmpdir9(), `xharness-index-${record3.id}-${randomBytes2(4).toString("hex")}`);
     const env = { ...IDENTITY, GIT_INDEX_FILE: index };
     try {
       await git(record3.path, ["read-tree", "HEAD"], { env });
@@ -22373,7 +22887,7 @@ var Worktrees = class {
       if (dirty) throw new HarnessError("handoff_target_dirty", `The ${direction === "toSource" ? "main checkout" : "worktree"} has uncommitted changes.`, "Commit or stash them, then hand off again.");
       const patch = (await git(origin3, ["diff", "--binary", direction === "toSource" ? record3.baseCommit : "HEAD"])).stdout;
       const untracked = await untrackedFiles(origin3);
-      const collisions = untracked.filter((path4) => existsSync30(join65(target, path4)));
+      const collisions = untracked.filter((path4) => existsSync30(join66(target, path4)));
       if (collisions.length) throw new HarnessError("handoff_conflict", `${collisions.length} untracked file(s) already exist in the target, for example ${collisions[0]}.`);
       if (patch.trim()) {
         const check2 = await git(target, ["apply", "--check", "--binary", "--whitespace=nowarn"], { input: patch, allowFail: true });
@@ -22660,12 +23174,12 @@ var SUM = `COUNT(*) AS requests, SUM(input_tokens) AS input, SUM(cache_read_toke
   SUM(cache_write_tokens) AS cacheWrite, SUM(output_tokens) AS output, SUM(reasoning_tokens) AS reasoning,
   SUM(cost_usd) AS cost, SUM(CASE WHEN cost_usd IS NULL THEN 1 ELSE 0 END) AS unpriced,
   AVG(ttft_ms) AS ttft, AVG(duration_ms) AS duration`;
-function grouped(database, column, clause, params, limit) {
+function grouped(database, column, clause, params, limit2) {
   return all(
     database,
     `SELECT ${column} AS key, ${SUM} FROM usage_requests WHERE ${clause}
      GROUP BY ${column} ORDER BY SUM(COALESCE(input_tokens,0)+COALESCE(cache_read_tokens,0)+COALESCE(cache_write_tokens,0)+COALESCE(output_tokens,0)) DESC
-     LIMIT ${limit}`,
+     LIMIT ${limit2}`,
     ...params
   ).map((row) => ({ key: row.key ?? "", values: row }));
 }
@@ -22888,8 +23402,8 @@ function toIso(value, now2) {
 }
 var leftPercent = (usedPercent) => usedPercent === null ? null : Math.max(0, Math.min(100, 100 - usedPercent));
 var statusFor = (percent2, fallback = "allowed") => percent2 === null ? fallback : percent2 >= 100 ? "rejected" : percent2 >= 80 ? "warning" : "allowed";
-function entry(limit, observedAt) {
-  return { ...limit, provider: limit.provider, observedAt };
+function entry(limit2, observedAt) {
+  return { ...limit2, provider: limit2.provider, observedAt };
 }
 var ANTHROPIC_FAMILIES = [
   { key: "requests", label: "Requests", unit: "requests" },
@@ -22902,17 +23416,17 @@ function normalizeHeaders(provider, response, now2 = /* @__PURE__ */ new Date())
   const headers = headersOf(response.headers);
   const observedAt = now2.toISOString();
   const limits = /* @__PURE__ */ new Map();
-  const put2 = (limit) => {
-    limits.set(limit.id, limit);
+  const put2 = (limit2) => {
+    limits.set(limit2.id, limit2);
   };
   for (const family of ANTHROPIC_FAMILIES) {
     const prefix = `anthropic-ratelimit-${family.key}-`;
-    const limit = toNumber(headers.get(`${prefix}limit`));
+    const limit2 = toNumber(headers.get(`${prefix}limit`));
     const remaining = toNumber(headers.get(`${prefix}remaining`));
     const resetsAt = toIso(headers.get(`${prefix}reset`), now2);
-    if (limit === null && remaining === null && !resetsAt) continue;
-    const used = limit !== null && remaining !== null ? Math.max(0, limit - remaining) : null;
-    const usedPercent = limit !== null && limit > 0 && used !== null ? used / limit * 100 : null;
+    if (limit2 === null && remaining === null && !resetsAt) continue;
+    const used = limit2 !== null && remaining !== null ? Math.max(0, limit2 - remaining) : null;
+    const usedPercent = limit2 !== null && limit2 > 0 && used !== null ? used / limit2 * 100 : null;
     put2(entry({
       id: `${provider}:${family.key}`,
       label: family.label,
@@ -22920,7 +23434,7 @@ function normalizeHeaders(provider, response, now2 = /* @__PURE__ */ new Date())
       kind: "rate",
       unit: family.unit,
       used,
-      limit,
+      limit: limit2,
       remaining,
       usedPercent,
       remainingPercent: leftPercent(usedPercent),
@@ -22985,12 +23499,12 @@ function normalizeHeaders(provider, response, now2 = /* @__PURE__ */ new Date())
   }
   for (const [family, bucket] of families) {
     if (!RATE_FAMILIES.includes(family)) continue;
-    const limit = toNumber(bucket.limit);
+    const limit2 = toNumber(bucket.limit);
     const remaining = toNumber(bucket.remaining);
     const resetsAt = toIso(bucket.reset, now2);
-    if (limit === null && remaining === null && !resetsAt) continue;
-    const used = limit !== null && remaining !== null ? Math.max(0, limit - remaining) : null;
-    const usedPercent = limit !== null && limit > 0 && used !== null ? used / limit * 100 : null;
+    if (limit2 === null && remaining === null && !resetsAt) continue;
+    const used = limit2 !== null && remaining !== null ? Math.max(0, limit2 - remaining) : null;
+    const usedPercent = limit2 !== null && limit2 > 0 && used !== null ? used / limit2 * 100 : null;
     put2(entry({
       id: `${provider}:rate-${family}`,
       label: `${title(family)} (rate)`,
@@ -22998,7 +23512,7 @@ function normalizeHeaders(provider, response, now2 = /* @__PURE__ */ new Date())
       kind: "rate",
       unit: family.includes("token") ? "tokens" : "requests",
       used,
-      limit,
+      limit: limit2,
       remaining,
       usedPercent,
       remainingPercent: leftPercent(usedPercent),
@@ -23027,8 +23541,8 @@ function normalizeHeaders(provider, response, now2 = /* @__PURE__ */ new Date())
 }
 
 // src/usage/limits/adapters.ts
-var providerEntry = (provider, observedAt, limit) => ({ ...limit, provider, observedAt, source: "provider" });
-var percent = (used, limit) => limit > 0 ? Math.min(100, Math.max(0, used / limit * 100)) : null;
+var providerEntry = (provider, observedAt, limit2) => ({ ...limit2, provider, observedAt, source: "provider" });
+var percent = (used, limit2) => limit2 > 0 ? Math.min(100, Math.max(0, used / limit2 * 100)) : null;
 var OPENROUTER_ADAPTER = {
   id: "openrouter-key",
   providers: ["openrouter"],
@@ -23041,21 +23555,21 @@ var OPENROUTER_ADAPTER = {
     if (!data || typeof data !== "object") return { limits: [], reason: "OpenRouter returned no key details." };
     const observedAt = now2.toISOString();
     const limits = [];
-    const limit = typeof data.limit === "number" ? data.limit : null;
+    const limit2 = typeof data.limit === "number" ? data.limit : null;
     const remaining = typeof data.limit_remaining === "number" ? data.limit_remaining : null;
-    if (limit !== null && remaining !== null) {
-      const used = Math.max(0, limit - remaining);
+    if (limit2 !== null && remaining !== null) {
+      const used = Math.max(0, limit2 - remaining);
       limits.push(providerEntry(provider, observedAt, {
         id: `${provider}:key-credits`,
         label: "Key credits",
         kind: "credit",
         unit: "usd",
         used,
-        limit,
+        limit: limit2,
         remaining,
-        usedPercent: percent(used, limit),
-        remainingPercent: percent(remaining, limit),
-        status: remaining <= 0 ? "rejected" : percent(used, limit) >= 80 ? "warning" : "allowed"
+        usedPercent: percent(used, limit2),
+        remainingPercent: percent(remaining, limit2),
+        status: remaining <= 0 ? "rejected" : percent(used, limit2) >= 80 ? "warning" : "allowed"
       }));
     }
     const budgets = Array.isArray(data.budgets) ? data.budgets : [];
@@ -23427,10 +23941,10 @@ var UsageLimits = class {
       accounts: accounts.map((account) => {
         const known = /* @__PURE__ */ new Map();
         for (const entry2 of account.state.providerLimits ?? []) known.set(entry2.provider, entry2);
-        for (const limit of account.state.limits) {
-          const provider = limit.provider;
+        for (const limit2 of account.state.limits) {
+          const provider = limit2.provider;
           if (!provider || known.has(provider)) continue;
-          known.set(provider, { source: limit.source === "provider" ? "provider" : "headers", reason: null, observedAt: limit.observedAt ?? this.now().toISOString() });
+          known.set(provider, { source: limit2.source === "provider" ? "provider" : "headers", reason: null, observedAt: limit2.observedAt ?? this.now().toISOString() });
         }
         return {
           accountId: account.id,
@@ -23442,7 +23956,7 @@ var UsageLimits = class {
             source: entry2.source,
             reason: entry2.reason,
             observedAt: entry2.observedAt,
-            limits: account.state.limits.filter((limit) => limit.provider === provider && !(limit.resetsAt && Date.parse(limit.resetsAt) <= this.now().getTime()))
+            limits: account.state.limits.filter((limit2) => limit2.provider === provider && !(limit2.resetsAt && Date.parse(limit2.resetsAt) <= this.now().getTime()))
           })).sort((left, right) => left.provider.localeCompare(right.provider))
         };
       })
@@ -23506,7 +24020,7 @@ var UsageLimits = class {
       const reading = await adapter.read(context);
       this.options.accounts.applyLimits(account.id, [{
         provider,
-        limits: reading.limits.map((limit) => ({ ...limit, provider, observedAt, source: "provider" })),
+        limits: reading.limits.map((limit2) => ({ ...limit2, provider, observedAt, source: "provider" })),
         source: "provider",
         reason: reading.reason ? scrub(reading.reason) : null,
         observedAt,
@@ -23518,23 +24032,23 @@ var UsageLimits = class {
   }
   /** Limits known for one account and provider, for diagnostics. */
   limitsOf(accountId, provider) {
-    return this.options.accounts.overview().accounts.find((account) => account.id === accountId)?.state.limits.filter((limit) => limit.provider === provider) ?? [];
+    return this.options.accounts.overview().accounts.find((account) => account.id === accountId)?.state.limits.filter((limit2) => limit2.provider === provider) ?? [];
   }
 };
 
 // src/annotations/capture.ts
 import { spawn as spawn6 } from "node:child_process";
 import { randomUUID as randomUUID18 } from "node:crypto";
-import { existsSync as existsSync32, readdirSync as readdirSync27, statSync as statSync20 } from "node:fs";
+import { existsSync as existsSync32, readdirSync as readdirSync29, statSync as statSync22 } from "node:fs";
 import { createServer as createServer4 } from "node:net";
-import { basename as basename14, join as join67 } from "node:path";
+import { basename as basename14, join as join68 } from "node:path";
 
 // src/annotations/bridge.ts
 init_fs();
 import { randomBytes as randomBytes3 } from "node:crypto";
 import { chmodSync as chmodSync14, existsSync as existsSync31 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
-import { join as join66 } from "node:path";
+import { join as join67 } from "node:path";
 var POLL_MS = 2e4;
 var GONE_MS = 45e3;
 var CALL_MS = 1e4;
@@ -23587,7 +24101,7 @@ var NotesBridge = class {
   nextWindow = 1;
   nextCall = 1;
   settingsFile() {
-    return join66(this.options.stateDir, "notes-bridge.json");
+    return join67(this.options.stateDir, "notes-bridge.json");
   }
   /** Starts the bridge (once) on the port and token kept from last time, so the app's snippet stays valid. */
   start() {
@@ -23845,13 +24359,13 @@ var freePort = () => new Promise((resolve19, reject2) => {
 });
 function appExecutable(path4) {
   if (!/\.app\/?$/.test(path4)) return path4;
-  const folder2 = join67(path4, "Contents", "MacOS");
+  const folder2 = join68(path4, "Contents", "MacOS");
   if (!existsSync32(folder2)) throw new Error(`${path4} has no Contents/MacOS folder.`);
-  const programs = readdirSync27(folder2).filter((name) => !name.startsWith(".") && statSync20(join67(folder2, name)).isFile());
+  const programs = readdirSync29(folder2).filter((name) => !name.startsWith(".") && statSync22(join68(folder2, name)).isFile());
   const named2 = basename14(path4.replace(/\/$/, ""), ".app");
   const program = programs.find((name) => name === named2) ?? programs[0];
   if (!program) throw new Error(`${path4} has no program in Contents/MacOS.`);
-  return join67(folder2, program);
+  return join68(folder2, program);
 }
 function describeApp(port, version2, list7) {
   const agent = typeof version2["User-Agent"] === "string" ? version2["User-Agent"] : "";
@@ -23983,8 +24497,8 @@ var AnnotationCapture = class {
     if (existing instanceof WebTarget) return existing;
     const session = new BrowserSession({
       key: `notes-${key}`,
-      profileDir: join67(this.options.stateDir, "browser", "profiles", "person"),
-      downloadsDir: join67(this.options.stateDir, "browser", "downloads", fileName(`notes-${key}`)),
+      profileDir: join68(this.options.stateDir, "browser", "profiles", "person"),
+      downloadsDir: join68(this.options.stateDir, "browser", "downloads", fileName(`notes-${key}`)),
       // Always a window the person can see and select in.
       config: () => ({ ...readBrowserConfig(this.options.stateDir), headed: true }),
       network: this.network,
@@ -24419,7 +24933,7 @@ var Harness = class {
     this.browserEnabled = options2.browser !== false;
     this.stateDir = options2.stateDir;
     mkdirSync26(this.stateDir, { recursive: true });
-    isolateProcess(join68(this.stateDir, "accounts"));
+    isolateProcess(join69(this.stateDir, "accounts"));
     this.env = new Env(options2.dataRoot || null, options2.directory ?? EMPTY_DIRECTORY, options2.productName ?? DEFAULT_PRODUCT_NAME, this.bus);
     this.hub = new Hub(this, options2.hub);
     this.policy = options2.policy ?? {};
@@ -24427,8 +24941,8 @@ var Harness = class {
     configureBuiltins(options2.builtins ?? []);
     this.trust = new VariantTrust(this.stateDir);
     this.refineHost = options2.refineHost ?? null;
-    const secrets = options2.secrets ?? fileSecretStore(join68(this.stateDir, "secrets.json"));
-    this.accounts = new Accounts({ dir: join68(this.stateDir, "accounts"), secrets, bus: this.bus });
+    const secrets = options2.secrets ?? fileSecretStore(join69(this.stateDir, "secrets.json"));
+    this.accounts = new Accounts({ dir: join69(this.stateDir, "accounts"), secrets, bus: this.bus });
     this.approvals = new Approvals(this.stateDir, this.bus);
     this.usageLimits = new UsageLimits({ accounts: this.accounts, root: () => this.env.dataRoot });
     this.accounts.observeModels = (models, accountId) => this.usageLimits.observeModels(models, accountId);
@@ -24443,7 +24957,7 @@ var Harness = class {
       ended: (runId, sessionId) => this.apps.revokeRun(runId, sessionId)
     });
     this.apps = new ConnectedApps({ env: this.env, stateDir: this.stateDir, secrets, bus: this.bus, runs: this.runs, policy: this.policy, oauthClients: options2.oauthClients });
-    this.plugins = new Plugins({ stateDir: this.stateDir, bus: this.bus, resolver: options2.resolver, attachments: () => this.env.dataRoot ? load3(this.env.dataRoot) : null, packagesDir: () => this.env.dataRoot ? join68(this.env.dataRoot, "plugins") : null });
+    this.plugins = new Plugins({ stateDir: this.stateDir, bus: this.bus, resolver: options2.resolver, attachments: () => this.env.dataRoot ? load3(this.env.dataRoot) : null, packagesDir: () => this.env.dataRoot ? join69(this.env.dataRoot, "plugins") : null });
     this.hooks = new Hooks({
       stateDir: this.stateDir,
       bus: this.bus,
@@ -24451,9 +24965,9 @@ var Harness = class {
       // The shared folder stands in for an account: packages are the same for all of them.
       wanted: async () => {
         if (!this.env.dataRoot) return [];
-        const shared = ensureSharedDir(join68(this.stateDir, "accounts"));
-        const named2 = readJsonOr(join68(shared, "settings.json"), {}).packages;
-        if (!packageFolders(join68(this.env.dataRoot, "plugins")).length && !(Array.isArray(named2) && named2.length)) return [];
+        const shared = ensureSharedDir(join69(this.stateDir, "accounts"));
+        const named2 = readJsonOr(join69(shared, "settings.json"), {}).packages;
+        if (!packageFolders(join69(this.env.dataRoot, "plugins")).length && !(Array.isArray(named2) && named2.length)) return [];
         return (await this.plugins.loading({ cwd: this.stateDir, agentDir: shared, caller: {} })).hooks;
       },
       call: (connection, tool, args) => this.apps.callUnattended(connection, tool, args ?? {}),
@@ -24538,7 +25052,7 @@ var Harness = class {
     const root = dataRoot;
     this.hooks.watch(wikiDir(root));
     void this.hooks.reload();
-    for (const folder2 of ["registry/skills", "registry/prompts", "registry/rules", "config", "runs"]) mkdirSync26(join68(root, folder2), { recursive: true });
+    for (const folder2 of ["registry/skills", "registry/prompts", "registry/rules", "config", "runs"]) mkdirSync26(join69(root, folder2), { recursive: true });
     let migrationError = null;
     try {
       const moved = migrateVariantLayout(root);
@@ -24547,7 +25061,7 @@ var Harness = class {
       migrationError = error instanceof Error ? error.message : String(error);
       log("variant layout", migrationError);
     }
-    mkdirSync26(join68(root, "variants"), { recursive: true });
+    mkdirSync26(join69(root, "variants"), { recursive: true });
     let legacyWiki = null;
     try {
       legacyWiki = moveLegacy(root);
@@ -24644,7 +25158,7 @@ function createHarness(options2) {
 
 // src/plugins/cli.ts
 import { homedir as homedir6 } from "node:os";
-import { join as join69, resolve as resolve12 } from "node:path";
+import { join as join70, resolve as resolve12 } from "node:path";
 import { createInterface } from "node:readline/promises";
 var PLUGINS_USAGE = `Usage: xagent plugins <command> [options]
 
@@ -24710,8 +25224,8 @@ async function runPluginsCli(argv, dependencies = {}) {
     return command ? 0 : 2;
   }
   const base = dependencies.cwd ?? process.cwd();
-  const root = join69(dependencies.home ?? homedir6(), ".xingular-harness");
-  const options2 = { dataRoot: parsed.values.data ? resolve12(base, parsed.values.data) : join69(root, "data"), stateDir: parsed.values.state ? resolve12(base, parsed.values.state) : join69(root, "state"), productName: DEFAULT_PRODUCT_NAME };
+  const root = join70(dependencies.home ?? homedir6(), ".xingular-harness");
+  const options2 = { dataRoot: parsed.values.data ? resolve12(base, parsed.values.data) : join70(root, "data"), stateDir: parsed.values.state ? resolve12(base, parsed.values.state) : join70(root, "state"), productName: DEFAULT_PRODUCT_NAME };
   const harness = dependencies.createHarness ? dependencies.createHarness(options2) : new Harness(options2);
   const scope = { cwd: parsed.values.cwd ? resolve12(base, parsed.values.cwd) : null };
   const need = (what) => {
@@ -24824,7 +25338,7 @@ function terminalAsk() {
 
 // src/hub/cli.ts
 import { homedir as homedir7 } from "node:os";
-import { join as join70, resolve as resolve13 } from "node:path";
+import { join as join71, resolve as resolve13 } from "node:path";
 var HUB_USAGE = `Usage: xagent hub <list | show | install> [id@version] [options]
 
   list [--refresh]             Browse the curated catalog and locally installed versions
@@ -24866,8 +25380,8 @@ async function runHubCli(argv, dependencies = {}) {
     write4(HUB_USAGE);
     return 2;
   }
-  const root = join70(dependencies.home ?? homedir7(), ".xingular-harness");
-  const options2 = { dataRoot: values2.data ?? join70(root, "data"), stateDir: values2.state ?? join70(root, "state") };
+  const root = join71(dependencies.home ?? homedir7(), ".xingular-harness");
+  const options2 = { dataRoot: values2.data ?? join71(root, "data"), stateDir: values2.state ?? join71(root, "state") };
   const harness = dependencies.createHarness?.(options2) ?? new Harness(options2);
   try {
     const overview2 = await harness.hub.list(refresh);
@@ -24911,15 +25425,15 @@ Delivery: ${JSON.stringify(delivery)}
 
 // src/refine/cli.ts
 init_fs();
-import { mkdtempSync as mkdtempSync10, readFileSync as readFileSync33 } from "node:fs";
+import { mkdtempSync as mkdtempSync10, readFileSync as readFileSync34 } from "node:fs";
 import { homedir as homedir8, tmpdir as tmpdir11 } from "node:os";
-import { basename as basename15, join as join73, resolve as resolve14 } from "node:path";
+import { basename as basename15, join as join74, resolve as resolve14 } from "node:path";
 
 // src/refine/demo.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { cpSync as cpSync5, existsSync as existsSync33, mkdirSync as mkdirSync27, mkdtempSync as mkdtempSync9, readdirSync as readdirSync28, readFileSync as readFileSync31, writeFileSync as writeFileSync12 } from "node:fs";
+import { cpSync as cpSync5, existsSync as existsSync33, mkdirSync as mkdirSync27, mkdtempSync as mkdtempSync9, readdirSync as readdirSync30, readFileSync as readFileSync32, writeFileSync as writeFileSync12 } from "node:fs";
 import { tmpdir as tmpdir10 } from "node:os";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 var DEMO_SCRIPT = `import { readFileSync } from 'node:fs'
 
 const rows = readFileSync(process.argv[2], 'utf8').trim().split('\\n').slice(1)
@@ -24942,11 +25456,11 @@ var DEMO_LEDGERS = {
 };
 function demoTasks(root, scope = "demo") {
   return Object.entries(DEMO_LEDGERS).map(([id, amounts]) => {
-    const sourceDir = join71(root, "sources", id);
+    const sourceDir = join72(root, "sources", id);
     mkdirSync27(sourceDir, { recursive: true });
-    writeFileSync12(join71(sourceDir, "ledger.csv"), `amount
+    writeFileSync12(join72(sourceDir, "ledger.csv"), `amount
 ${amounts}`);
-    writeFileSync12(join71(sourceDir, "reference_answer.txt"), "never shown to a model");
+    writeFileSync12(join72(sourceDir, "reference_answer.txt"), "never shown to a model");
     return {
       id,
       scope,
@@ -24966,25 +25480,25 @@ var DemoExecutor = class {
   executions = 0;
   async execute(task, variantDir, label, runId) {
     this.executions++;
-    const dir2 = join71(this.root, "executions", runId);
+    const dir2 = join72(this.root, "executions", runId);
     mkdirSync27(dir2, { recursive: true });
-    const script = join71(variantDir ?? "", "scripts", "summarize.mjs");
-    const result = spawnSync3(process.execPath, [script, join71(task.sourceDir ?? "", "ledger.csv")], { encoding: "utf8", timeout: 1e4 });
+    const script = join72(variantDir ?? "", "scripts", "summarize.mjs");
+    const result = spawnSync3(process.execPath, [script, join72(task.sourceDir ?? "", "ledger.csv")], { encoding: "utf8", timeout: 1e4 });
     if (result.status !== 0) {
       return { label, runId, dir: dir2, ok: false, delivered: false, costUsd: 0, wallMs: 0, error: result.stderr || "script failed" };
     }
-    writeFileSync12(join71(dir2, "answer.txt"), result.stdout);
-    writeFileSync12(join71(dir2, "trajectory.md"), `[ACTION] Run scripts/summarize.mjs on ledger.csv
+    writeFileSync12(join72(dir2, "answer.txt"), result.stdout);
+    writeFileSync12(join72(dir2, "trajectory.md"), `[ACTION] Run scripts/summarize.mjs on ledger.csv
 [OBSERVATION]
 ${result.stdout}`);
     return { label, runId, dir: dir2, ok: true, delivered: true, costUsd: 0, wallMs: 0, error: "" };
   }
   trajectory(rollout) {
-    return readFileSync31(join71(rollout.dir, "trajectory.md"), "utf8");
+    return readFileSync32(join72(rollout.dir, "trajectory.md"), "utf8");
   }
   deliverableFiles(rollout) {
-    const path4 = join71(rollout.dir, "answer.txt");
-    return existsSync33(path4) ? { "answer.txt": readFileSync31(path4, "utf8") } : {};
+    const path4 = join72(rollout.dir, "answer.txt");
+    return existsSync33(path4) ? { "answer.txt": readFileSync32(path4, "utf8") } : {};
   }
   validateVariant(_task, variant) {
     if (!variant["scripts/summarize.mjs"]) throw new Error("The local executor requires scripts/summarize.mjs");
@@ -25002,15 +25516,15 @@ var DemoImprover = class {
     let workspace = null;
     let text10;
     if (input.label.startsWith("select.")) {
-      const expected = `Total: ${signedTotal(readFileSync31(join71(context, "source", "ledger.csv"), "utf8"))}`;
-      const ids2 = readdirSync28(join71(context, "candidates")).filter((name) => name.endsWith(".md")).sort();
-      const chosen = ids2.find((name) => readFileSync31(join71(context, "candidates", name), "utf8").includes(expected))?.replace(/\.md$/, "") ?? ids2[0].replace(/\.md$/, "");
+      const expected = `Total: ${signedTotal(readFileSync32(join72(context, "source", "ledger.csv"), "utf8"))}`;
+      const ids2 = readdirSync30(join72(context, "candidates")).filter((name) => name.endsWith(".md")).sort();
+      const chosen = ids2.find((name) => readFileSync32(join72(context, "candidates", name), "utf8").includes(expected))?.replace(/\.md$/, "") ?? ids2[0].replace(/\.md$/, "");
       text10 = `<why>The signed total matches the source ledger.</why>
 \`\`\`choice
 ${chosen}
 \`\`\``;
     } else if (input.label.startsWith("experience.")) {
-      const changed2 = readFileSync31(join71(context, "harness", "scripts", "summarize.mjs"), "utf8") !== readFileSync31(join71(context, "base_harness", "scripts", "summarize.mjs"), "utf8");
+      const changed2 = readFileSync32(join72(context, "harness", "scripts", "summarize.mjs"), "utf8") !== readFileSync32(join72(context, "base_harness", "scripts", "summarize.mjs"), "utf8");
       text10 = `<edits>
 component: scripts/summarize.mjs
 candidates: inv1
@@ -25021,10 +25535,10 @@ verdict: ${changed2 ? "helped" : "no observed effect"}
 
 ` + (changed2 ? "<experience>\ncue: When a ledger includes credits and debits\nlesson: Include both signs when summing in scripts/summarize.mjs.\nevidence: The scripts/summarize.mjs row -- removing the positive-only filter changed the probe total to include the credits omitted by the base trajectory.\nconfidence: high for this observed arithmetic contrast\n</experience>" : "NO_ENTRY");
     } else {
-      workspace = mkdtempSync9(join71(tmpdir10(), "harness-demo-"));
-      cpSync5(join71(context, "harness"), workspace, { recursive: true });
-      const script = join71(workspace, "scripts", "summarize.mjs");
-      writeFileSync12(script, readFileSync31(script, "utf8").replace(".filter((amount) => amount > 0)", ""));
+      workspace = mkdtempSync9(join72(tmpdir10(), "harness-demo-"));
+      cpSync5(join72(context, "harness"), workspace, { recursive: true });
+      const script = join72(workspace, "scripts", "summarize.mjs");
+      writeFileSync12(script, readFileSync32(script, "utf8").replace(".filter((amount) => amount > 0)", ""));
       text10 = "<notes>Keep signed amounts: the base total omitted credits in the source ledger.</notes>";
     }
     return { label: input.label, text: text10, costUsd: 0, attempts: 1, cached: false, workspace };
@@ -25034,11 +25548,11 @@ verdict: ${changed2 ? "helped" : "no observed effect"}
 // src/refine/suite.ts
 init_fs();
 import { createHash as createHash16 } from "node:crypto";
-import { existsSync as existsSync34, readFileSync as readFileSync32 } from "node:fs";
-import { dirname as dirname24, join as join72 } from "node:path";
+import { existsSync as existsSync34, readFileSync as readFileSync33 } from "node:fs";
+import { dirname as dirname24, join as join73 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function matrixDir(root, id) {
-  return join72(root, "refine", safeId(id));
+  return join73(root, "refine", safeId(id));
 }
 var packageVersionMemo = null;
 function packageVersion() {
@@ -25048,9 +25562,9 @@ function packageVersion() {
       let dir2 = fileURLToPath3(import.meta.url);
       for (let up = 0; up < 6; up++) {
         dir2 = dirname24(dir2);
-        const manifest = join72(dir2, "package.json");
+        const manifest = join73(dir2, "package.json");
         if (existsSync34(manifest)) {
-          const json2 = JSON.parse(readFileSync32(manifest, "utf8"));
+          const json2 = JSON.parse(readFileSync33(manifest, "utf8"));
           if (json2.version) packageVersionMemo = json2.version;
           break;
         }
@@ -25076,7 +25590,7 @@ function stage(input) {
   return input.versions.map((entry2) => {
     try {
       assertVariantHasNoGraderVerdicts(entry2.variant);
-      return { label: entry2.label, variant: entry2.variant, fingerprint: fingerprint(entry2.variant), dir: writeVariant(PI_SURFACE, entry2.variant, join72(matrixDir(input.root, input.id), "variants", entry2.label)), error: "" };
+      return { label: entry2.label, variant: entry2.variant, fingerprint: fingerprint(entry2.variant), dir: writeVariant(PI_SURFACE, entry2.variant, join73(matrixDir(input.root, input.id), "variants", entry2.label)), error: "" };
     } catch (error) {
       return { label: entry2.label, variant: entry2.variant, fingerprint: fingerprint(entry2.variant), dir: "", error: error instanceof Error ? error.message : String(error) };
     }
@@ -25103,10 +25617,10 @@ async function runMatrix(input) {
   };
   const save3 = () => {
     summary4.usd = Math.round(summary4.rows.reduce((sum, row) => sum + row.costUsd, 0) * 1e6) / 1e6;
-    writeJson(join72(matrixDir(root, id), "matrix.json"), summary4);
+    writeJson(join73(matrixDir(root, id), "matrix.json"), summary4);
     emit({ type: "summary", summary: structuredClone(summary4) });
   };
-  writeJson(join72(matrixDir(root, id), "suite.json"), { id, versions: staged.map(({ label, fingerprint: fingerprint2 }) => ({ label, fingerprint: fingerprint2 })), tasks });
+  writeJson(join73(matrixDir(root, id), "suite.json"), { id, versions: staged.map(({ label, fingerprint: fingerprint2 }) => ({ label, fingerprint: fingerprint2 })), tasks });
   save3();
   const pairs = staged.flatMap((version2) => tasks.map((task) => ({ version: version2, task })));
   await mapLimit(pairs, input.rolloutWidth ?? 4, async ({ version: version2, task }) => {
@@ -25130,7 +25644,7 @@ async function runMatrix(input) {
         try {
           rollout = await executor.execute(task, version2.dir, runId, runId);
         } catch (error) {
-          rollout = { label: runId, runId, dir: join72(matrixDir(root, id), "missing", version2.label, task.id), ok: false, delivered: false, costUsd: 0, wallMs: 0, error: error instanceof Error ? error.message : String(error) };
+          rollout = { label: runId, runId, dir: join73(matrixDir(root, id), "missing", version2.label, task.id), ok: false, delivered: false, costUsd: 0, wallMs: 0, error: error instanceof Error ? error.message : String(error) };
         }
         emit({ type: "execution.finished", version: version2.label, task: task.id, ok: rollout.ok, delivered: rollout.delivered, error: rollout.error });
         row = rowOf(version2, task, runId, executorName, rollout);
@@ -25232,7 +25746,7 @@ async function runRefineCli(argv, io = { write: (text10) => void process.stdout.
   const { command, values: values2 } = parse3(argv);
   try {
     if (command === "demo") {
-      const root = values2.out ? resolve14(values2.out) : mkdtempSync10(join73(tmpdir11(), "harness-refine-demo-"));
+      const root = values2.out ? resolve14(values2.out) : mkdtempSync10(join74(tmpdir11(), "harness-refine-demo-"));
       const k = Number(values2.k ?? 1);
       seed(root, "demo", demoBaseVariant(), "demo base harness");
       const executor = new DemoExecutor(root);
@@ -25242,7 +25756,7 @@ async function runRefineCli(argv, io = { write: (text10) => void process.stdout.
         describe3(summary4, io.write);
       }
       io.write(`library: ${new Library(root, "demo", "accounting").entries().join(", ") || "(empty)"}
-records: ${join73(root, "refine")}
+records: ${join74(root, "refine")}
 `);
       return 0;
     }
@@ -25251,13 +25765,13 @@ records: ${join73(root, "refine")}
         io.write(REFINE_USAGE);
         return 2;
       }
-      const base = join73(homedir8(), ".xingular-harness");
-      const harness = createHarness({ dataRoot: resolve14(values2.data ?? join73(base, "data")), stateDir: resolve14(values2.state ?? join73(base, "state")) });
+      const base = join74(homedir8(), ".xingular-harness");
+      const harness = createHarness({ dataRoot: resolve14(values2.data ?? join74(base, "data")), stateDir: resolve14(values2.state ?? join74(base, "state")) });
       try {
         const scope = values2.scope ?? basename15(resolve14(values2.variant)).replace(/[^A-Za-z0-9_-]/g, "-");
         const variant = readVariant(PI_SURFACE, resolve14(values2.variant));
         commit(harness.env.root, scope, variant, { kind: "import", note: `from ${values2.variant}` });
-        const prompt = readFileSync33(resolve14(values2.task), "utf8");
+        const prompt = readFileSync34(resolve14(values2.task), "utf8");
         const { id } = harness.refine.start({
           task: { id: basename15(values2.task).replace(/\.md$/, "").replace(/[^A-Za-z0-9_-]/g, "-"), prompt, scope, sourceDir: values2.source ? resolve14(values2.source) : null },
           k: Number(values2.k ?? 1),
@@ -25283,7 +25797,7 @@ records: ${join73(root, "refine")}
       }
     }
     if (command === "matrix") {
-      const root = resolve14(values2.data ?? join73(homedir8(), ".xingular-harness", "data"));
+      const root = resolve14(values2.data ?? join74(homedir8(), ".xingular-harness", "data"));
       let versions2 = [];
       let tasks;
       if (values2.demo) {
@@ -25295,7 +25809,7 @@ records: ${join73(root, "refine")}
           io.write(REFINE_USAGE);
           return 2;
         }
-        const suite = JSON.parse(readFileSync33(resolve14(values2.suite), "utf8"));
+        const suite = JSON.parse(readFileSync34(resolve14(values2.suite), "utf8"));
         if (suite.executor && suite.executor !== "demo") throw new Error(`Executor '${suite.executor}' needs a model; this command runs without one. Use 'demo'.`);
         for (const entry2 of suite.versions) {
           if (entry2.dir) versions2.push({ label: entry2.label, variant: readVariant(PI_SURFACE, resolve14(entry2.dir)) });
@@ -25324,7 +25838,7 @@ records: ${join73(root, "refine")}
 
 // src/world/cli.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join74, resolve as resolve15 } from "node:path";
+import { join as join75, resolve as resolve15 } from "node:path";
 var WEB_USAGE = `Usage: xagent web <status | key <provider> [--remove] | keyless on|off> [--state <dir>] [--data <dir>]
 
   status                 Which search services are ready
@@ -25350,8 +25864,8 @@ var BROWSER_USAGE = `Usage: xagent browser [status | set <options>] [--state <di
 `;
 function stateOf2(argv, home) {
   const args = [];
-  let stateDir = join74(home, ".xingular-harness", "state");
-  let dataRoot = join74(home, ".xingular-harness", "data");
+  let stateDir = join75(home, ".xingular-harness", "state");
+  let dataRoot = join75(home, ".xingular-harness", "data");
   for (let index = 0; index < argv.length; index += 1) {
     if (argv[index] === "--state") stateDir = resolve15(argv[++index] ?? stateDir);
     else if (argv[index] === "--data") dataRoot = resolve15(argv[++index] ?? dataRoot);
@@ -25369,7 +25883,7 @@ async function readStdin2() {
 async function runWebCli(argv, dependencies = {}) {
   const write4 = dependencies.write ?? ((text10) => void process.stdout.write(text10));
   const { args, stateDir, dataRoot } = stateOf2(argv, dependencies.home ?? homedir9());
-  const secrets = dependencies.secrets ?? fileSecretStore(join74(stateDir, "secrets.json"));
+  const secrets = dependencies.secrets ?? fileSecretStore(join75(stateDir, "secrets.json"));
   const [command, name] = args;
   if (!command || command === "help") {
     write4(WEB_USAGE);
@@ -25950,29 +26464,29 @@ function listCommands(plugins) {
 }
 
 // src/variant/seed.ts
-import { existsSync as existsSync36, readdirSync as readdirSync29, readFileSync as readFileSync34, statSync as statSync21 } from "node:fs";
-import { join as join75 } from "node:path";
+import { existsSync as existsSync36, readdirSync as readdirSync31, readFileSync as readFileSync35, statSync as statSync23 } from "node:fs";
+import { join as join76 } from "node:path";
 function body(text10) {
   return (parse(text10)?.body ?? text10).trim();
 }
 function read4(path4) {
   try {
-    return readFileSync34(path4, "utf8");
+    return readFileSync35(path4, "utf8");
   } catch {
     return null;
   }
 }
 function folders2(dir2) {
   try {
-    return readdirSync29(dir2).filter((name) => !name.startsWith(".")).sort();
+    return readdirSync31(dir2).filter((name) => !name.startsWith(".")).sort();
   } catch {
     return [];
   }
 }
 function blocksDir(root) {
-  if (existsSync36(join75(root, "wiki", "blocks"))) return join75(root, "wiki", "blocks");
-  const moved = folders2(join75(root, "legacy")).filter((name) => name.startsWith("wiki-")).reverse();
-  for (const name of moved) if (existsSync36(join75(root, "legacy", name, "blocks"))) return join75(root, "legacy", name, "blocks");
+  if (existsSync36(join76(root, "wiki", "blocks"))) return join76(root, "wiki", "blocks");
+  const moved = folders2(join76(root, "legacy")).filter((name) => name.startsWith("wiki-")).reverse();
+  for (const name of moved) if (existsSync36(join76(root, "legacy", name, "blocks"))) return join76(root, "legacy", name, "blocks");
   return null;
 }
 function skillName2(stem) {
@@ -25983,20 +26497,20 @@ function legacyPieces(root, input) {
   const scope = { agentId: input.agentId ?? null, projectId: input.projectId ?? null };
   const on = (id) => attached(choices, [id], scope, false);
   const rules = [];
-  const rulesDir = join75(root, "registry", "rules");
+  const rulesDir = join76(root, "registry", "rules");
   for (const name of folders2(rulesDir)) {
     const stem = name.replace(/\.md$/, "");
-    const path4 = name.endsWith(".md") ? join75(rulesDir, name) : join75(rulesDir, name, "SKILL.md");
+    const path4 = name.endsWith(".md") ? join76(rulesDir, name) : join76(rulesDir, name, "SKILL.md");
     const text10 = read4(path4);
     if (text10 && on(`rules/${stem}`)) rules.push(body(text10));
   }
   const skills = {};
-  const skillsDir = join75(root, "registry", "skills");
+  const skillsDir = join76(root, "registry", "skills");
   for (const name of folders2(skillsDir)) {
     const stem = name.replace(/\.md$/, "");
-    let path4 = join75(skillsDir, name);
+    let path4 = join76(skillsDir, name);
     try {
-      if (statSync21(path4).isDirectory()) path4 = join75(path4, "SKILL.md");
+      if (statSync23(path4).isDirectory()) path4 = join76(path4, "SKILL.md");
     } catch {
       continue;
     }
@@ -26015,13 +26529,13 @@ ${body(text10)}
   const memory = [];
   const blocks = blocksDir(root);
   if (blocks) {
-    const user = read4(join75(blocks, "shared", "user.md"));
+    const user = read4(join76(blocks, "shared", "user.md"));
     if (user && body(user)) memory.push(`## About the person
 
 ${body(user)}`);
     if (input.agentId && /^[A-Za-z0-9_-]+$/.test(input.agentId)) {
       for (const [file2, title2] of [["persona.md", "Persona"], ["notes.md", "Notes"]]) {
-        const text10 = read4(join75(blocks, "agents", input.agentId, file2));
+        const text10 = read4(join76(blocks, "agents", input.agentId, file2));
         if (text10 && body(text10)) memory.push(`## ${title2}
 
 ${body(text10)}`);
@@ -26219,6 +26733,8 @@ function methods(harness) {
       return params.render ? { pack, text: render(env, pack) } : pack;
     },
     "context.runPack": (params) => load2(root(), text7(params, "runId")),
+    // What the request was made of: one row per contributor, reconciled to the provider's figure.
+    "context.attribution": (params) => attribution(env, text7(params, "runId")),
     // ---- Plugins: everything that shapes a session, and the trust a working folder's code needs ---
     // A host that is not a Node program describes its own parts here instead of in the options.
     "plugins.describe": (params) => {
@@ -26354,12 +26870,12 @@ import { spawn as nodeSpawn } from "node:child_process";
 import { createHash as createHash17, randomUUID as randomUUID19 } from "node:crypto";
 import { appendFileSync as appendFileSync2 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { isAbsolute as isAbsolute13, join as join77, resolve as resolve16 } from "node:path";
+import { isAbsolute as isAbsolute13, join as join78, resolve as resolve16 } from "node:path";
 
 // src/core/interactiveProfile.ts
-import { closeSync as closeSync7, fsyncSync as fsyncSync3, linkSync as linkSync2, mkdirSync as mkdirSync29, openSync as openSync7, readFileSync as readFileSync35, rmSync as rmSync24, statSync as statSync22, writeFileSync as writeFileSync14 } from "node:fs";
+import { closeSync as closeSync7, fsyncSync as fsyncSync3, linkSync as linkSync2, mkdirSync as mkdirSync29, openSync as openSync7, readFileSync as readFileSync36, rmSync as rmSync24, statSync as statSync24, writeFileSync as writeFileSync14 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname26, isAbsolute as isAbsolute12, join as join76 } from "node:path";
+import { dirname as dirname26, isAbsolute as isAbsolute12, join as join77 } from "node:path";
 var fail2 = () => {
   throw new Error("Invalid interactive profile configuration.");
 };
@@ -26400,7 +26916,7 @@ function validateInteractiveProfile(value) {
   };
 }
 function interactiveProfilePath(home = homedir10()) {
-  return join76(absolute(home), ".xingular-harness", "profile.json");
+  return join77(absolute(home), ".xingular-harness", "profile.json");
 }
 function selectedConfigPath(location = {}) {
   return location.configPath === void 0 ? interactiveProfilePath(location.home) : absolute(location.configPath);
@@ -26408,9 +26924,9 @@ function selectedConfigPath(location = {}) {
 function readInteractiveProfile(location = {}) {
   const path4 = selectedConfigPath(location);
   try {
-    const info = statSync22(path4);
+    const info = statSync24(path4);
     if (!info.isFile() || info.size > 16384) return fail2();
-    return validateInteractiveProfile(JSON.parse(readFileSync35(path4, "utf8")));
+    return validateInteractiveProfile(JSON.parse(readFileSync36(path4, "utf8")));
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw new Error("Interactive profile could not be read or validated.");
@@ -26424,16 +26940,16 @@ function overrides(value) {
 }
 function resolveInteractiveProfile(options2 = {}) {
   const home = absolute(options2.home ?? homedir10());
-  const root = join76(home, ".xingular-harness");
+  const root = join77(home, ".xingular-harness");
   const selected = readInteractiveProfile(options2);
   const legacy = overrides(options2.legacyDefaults);
   const explicit = overrides(options2.overrides);
-  const dataRoot = explicit.dataRoot ?? selected?.dataRoot ?? legacy.dataRoot ?? join76(root, "data");
-  const stateDir = explicit.stateDir ?? selected?.stateDir ?? legacy.stateDir ?? join76(root, "state");
+  const dataRoot = explicit.dataRoot ?? selected?.dataRoot ?? legacy.dataRoot ?? join77(root, "data");
+  const stateDir = explicit.stateDir ?? selected?.stateDir ?? legacy.stateDir ?? join77(root, "state");
   const defaultVariantScope = explicit.defaultVariantScope ?? selected?.defaultVariantScope ?? legacy.defaultVariantScope ?? "default";
   const secretBackend = explicit.secretBackend ?? selected?.secretBackend ?? legacy.secretBackend ?? {
     kind: "file",
-    path: join76(stateDir, "secrets.json")
+    path: join77(stateDir, "secrets.json")
   };
   return validateInteractiveProfile({ version: 1, dataRoot, stateDir, defaultVariantScope, secretBackend });
 }
@@ -26487,19 +27003,19 @@ function resolveStandaloneOptions(argv, home = homedir11(), cwd = process.cwd())
   if (!isAbsolute13(home) && !(given.has("--data") && given.has("--state"))) {
     throw new Error(`The home folder "${home}" is not an absolute path, so the default data and state folders cannot be placed. Set HOME to your home folder, or pass --data and --state with absolute folders.`);
   }
-  const devRoot = isAbsolute13(home) ? join77(home, ".xingular-harness-dev") : null;
-  const devData = devRoot ? join77(devRoot, "data") : null;
-  const devState = devRoot ? join77(devRoot, "state") : null;
+  const devRoot = isAbsolute13(home) ? join78(home, ".xingular-harness-dev") : null;
+  const devData = devRoot ? join78(devRoot, "data") : null;
+  const devState = devRoot ? join78(devRoot, "state") : null;
   const development = !!devRoot && (overrides2.dataRoot === devData || overrides2.stateDir === devState);
   const resolvedProfile = isAbsolute13(home) ? resolveInteractiveProfile({
     home,
     ...development ? {
-      configPath: join77(devRoot, "profile.json"),
+      configPath: join78(devRoot, "profile.json"),
       legacyDefaults: {
         dataRoot: devData,
         stateDir: devState,
         defaultVariantScope: "default",
-        secretBackend: { kind: "file", path: join77(devState, "secrets.json") }
+        secretBackend: { kind: "file", path: join78(devState, "secrets.json") }
       }
     } : {},
     overrides: overrides2
@@ -26508,9 +27024,9 @@ function resolveStandaloneOptions(argv, home = homedir11(), cwd = process.cwd())
     dataRoot: overrides2.dataRoot,
     stateDir: overrides2.stateDir,
     defaultVariantScope: "default",
-    secretBackend: { kind: "file", path: join77(overrides2.stateDir, "secrets.json") }
+    secretBackend: { kind: "file", path: join78(overrides2.stateDir, "secrets.json") }
   };
-  const profile = development ? { ...resolvedProfile, secretBackend: { kind: "file", path: join77(resolvedProfile.stateDir, "secrets.json") } } : resolvedProfile;
+  const profile = development ? { ...resolvedProfile, secretBackend: { kind: "file", path: join78(resolvedProfile.stateDir, "secrets.json") } } : resolvedProfile;
   return {
     profile,
     paths: {
@@ -26597,7 +27113,7 @@ async function runStandaloneTerminal(argv, dependencies = {}) {
   const harness = makeHarness({ dataRoot: paths2.dataRoot, stateDir: paths2.stateDir, productName: DEFAULT_PRODUCT_NAME, secrets });
   const newSessionId = dependencies.createSessionId ?? randomUUID19;
   let current2 = { sessionId: newSessionId(), accountId: null, nativeSessionId: null };
-  const logFile = join77(paths2.stateDir, "harness.log");
+  const logFile = join78(paths2.stateDir, "harness.log");
   setLogSink((text10) => {
     try {
       appendFileSync2(logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${text10}
@@ -26619,7 +27135,7 @@ async function runStandaloneTerminal(argv, dependencies = {}) {
       worktreeId = worktree.id;
     }
     for (; ; ) {
-      const sessionFolder = join77(paths2.dataRoot, "sessions", "terminal", createHash17("sha256").update(cwd).digest("hex"));
+      const sessionFolder = join78(paths2.dataRoot, "sessions", "terminal", createHash17("sha256").update(cwd).digest("hex"));
       const launch = await harness.terminals.prepare({ ...current2, cwd, sessionFolder, variant: { scope: variantScope }, ...worktreeId ? { run: { worktreeId } } : {} });
       const code = await spawnFrontend(launch, cwd, dependencies.spawn);
       const next = harness.terminals.takeRelaunch(current2.sessionId);
@@ -26643,7 +27159,7 @@ async function runStandaloneTerminal(argv, dependencies = {}) {
 
 // src/worktrees/cli.ts
 import { homedir as homedir12 } from "node:os";
-import { join as join78, resolve as resolve17 } from "node:path";
+import { join as join79, resolve as resolve17 } from "node:path";
 var WORKTREE_USAGE = `Usage: xagent worktree <command> [--state <dir>]
 
   list                       Worktrees of the repository you are in
@@ -26680,7 +27196,7 @@ async function runWorktreeCli(argv, dependencies = {}) {
   const write4 = dependencies.write ?? ((text10) => void process.stdout.write(text10));
   const cwd = resolve17(dependencies.cwd ?? process.cwd());
   const args = [];
-  let stateDir = join78(dependencies.home ?? homedir12(), ".xingular-harness", "state");
+  let stateDir = join79(dependencies.home ?? homedir12(), ".xingular-harness", "state");
   for (let index = 0; index < argv.length; index += 1) {
     if (argv[index] === "--state") stateDir = resolve17(argv[++index] ?? stateDir);
     else args.push(argv[index]);