@event4u/agent-config 16.5.0 → 17.1.0

package/dist/cli-delegate/{chunk-T7XSJSUQ.js → chunk-VYZGJLCA.js}

@@ -2,58 +2,86 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   ZodFirstPartyTypeKind,
   settingsSchema
-} from "./chunk-6SRJTYJS.js";
+} from "./chunk-XIAPY44N.js";
 import {
   GLOBAL_DEPLOY_SOURCES,
-  RULE_SOURCE_REL
-} from "./chunk-WOKWX5PL.js";
+  RULE_SOURCE_REL,
+  dryRunTargetLines
+} from "./chunk-BKALSTBZ.js";
+import {
+  OBSERVATION_LOG,
+  catalogueLimitWarning,
+  knownHostLimits,
+  measureCatalogueVolume,
+  migrationEligibility,
+  migrationPromptLines,
+  readObservationLog
+} from "./chunk-NTM7G2V4.js";
+import {
+  EXIT_COMPLETED_WITH_CONFLICTS,
+  conflictSummaryMessage,
+  decideDeployWrite,
+  foreignSidecarMessage,
+  isLedgerMigration,
+  logProofApplies,
+  loggedWriteDigests,
+  migrationPreservedMessage,
+  onlyDeployed,
+  preservedFileMessage,
+  sidecarPathFor,
+  wroteTheseBytes
+} from "./chunk-3PK3VZHB.js";
 import {
   main
-} from "./chunk-G5VVIZRC.js";
+} from "./chunk-F7HLSW6P.js";
 import {
+  TIER_TO_CLAUDE_MODEL,
   absoluteBodyLinkPrefix,
   appendTxLog,
   build_thin,
+  read_model_tier,
+  render_native_model_md,
   ruleBody,
   splitFrontmatter,
   split_frontmatter
-} from "./chunk-6YQC2HLF.js";
+} from "./chunk-YHAPONWV.js";
 import {
   SCOPE_DETECT_AI_DIRS,
-  SCOPE_DETECT_MANIFESTS
-} from "./chunk-A4QJ6ENT.js";
+  SCOPE_DETECT_MANIFESTS,
+  getLogPath
+} from "./chunk-W5JXMF2T.js";
 import {
-  INVENTORY_BASENAME,
+  FINDER_NAME,
+  _read_settings,
+  _with_lock,
+  atomicWriteFile,
   build_claude_hook_matrix,
+  deployClaudeCarrier,
+  ensureCodexFinder,
   ensure_managed_hooks,
-  expected_deploy_files,
-  inventory_path,
-  is_ancestor,
-  load_inventory,
+  finderDescription,
+  installerThinsHost,
   printResiduals,
   probeHostCapabilities,
-  reap_stale,
-  reap_tagged_orphans,
-  record_deploy,
-  recorded_absolute_files,
-  recorded_rel_files,
-  save_inventory
-} from "./chunk-MDPPKQCQ.js";
+  removeCodexFinder
+} from "./chunk-QBHEI5N4.js";
 import {
   LEGACY_ALL,
   compute_active_pack_ids,
-  is_pruned_under_scoped,
   load_lab_pack_ids,
   load_packs_registry,
   parseFrontmatter,
   prune_lab_modules,
-  prune_modules_by,
+  prune_scoped_modules,
   ruleFileArrives,
   ruleScopeFromSettings
-} from "./chunk-DMSZHXZS.js";
+} from "./chunk-7DRWULEQ.js";
 import {
   write_managed_block
 } from "./chunk-ULQRUR23.js";
+import {
+  hostBindings
+} from "./chunk-PV7S5DPJ.js";
 import {
   check_version,
   classify_mismatch,
@@ -64,6 +92,10 @@ import {
   read_lockfile,
   write_lockfile
 } from "./chunk-LQOCRFWT.js";
+import {
+  find_project_root_with_anchor,
+  load_agent_settings
+} from "./chunk-XLY5G3CM.js";
 import {
   HOOK_SIGNATURES,
   deepMerge,
@@ -73,23 +105,34 @@ import {
   mergeHostConfig
 } from "./chunk-DEIV7XP7.js";
 import {
+  INVENTORY_BASENAME,
   NO_RECORDED_HASHES,
+  expected_deploy_files,
+  file_sha256,
+  inventory_path,
+  is_ancestor,
+  ledgerListedPaths,
+  load_inventory,
+  readRecordedHashes,
+  reap_stale,
+  reap_tagged_orphans,
+  record_deploy,
+  recordedHashesWithLedger,
+  recorded_absolute_files,
+  recorded_digests,
+  recorded_rel_files,
+  save_inventory
+} from "./chunk-J2SJZICO.js";
+import {
   ScopeMismatchError,
-  classifyOwnership,
   manifest_path,
-  readRecordedHashes,
   read_manifest,
-  recordedHashesForRoot,
   upsert_tool,
   write_manifest
-} from "./chunk-OKJUIAPS.js";
+} from "./chunk-4E2W63DA.js";
 import {
   require_dist
 } from "./chunk-OY53J6II.js";
-import {
-  find_project_root_with_anchor,
-  load_agent_settings
-} from "./chunk-H76PHZBI.js";
 import {
   DEFAULT_EVENT4U_ROOT_RELATIVE,
   event4u_root,
@@ -344,24 +387,490 @@ function subtract_pointers(doc, entries) {
   return [doc, warnings];
 }
 
+// src/scripts/_lib/codex_resident_set.ts
+import { createHash as createHash2 } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+var RECORD_DIRNAME = "codex-resident-set";
+var POLICY_REL = path.join("agents", "openai.yaml");
+var CODEX_BUDGET_CHARS = 8e3;
+var POLICY_BODY = "policy:\n  allow_implicit_invocation: false\n";
+var ASSUMPTIONS = [
+  {
+    id: "entry-cost-is-name-plus-description",
+    provenance: "upstream-prose",
+    why: 'The host reports a "skills context budget" in characters and does not publish the serialisation it bills. This model bills a name plus its description, which is what the injected list visibly carries.'
+  },
+  {
+    id: "per-entry-overhead",
+    provenance: "estimate",
+    why: "Each entry also costs separators and a newline. The host quantifies none of it, so the default here is 5 characters per entry and the resulting resident set is therefore an estimate of what fits, never a guarantee \u2014 too small, never too large."
+  },
+  {
+    id: "fill-order-alphabetical",
+    provenance: "first-party-observation",
+    why: "The 0.3 probe observed the host itself dropping from the alphabetical tail of the user scope. With no usage ledger to order by, filling alphabetically makes the package pick the SAME set the host would have picked, so the resident set is the host's own survivors made explicit rather than a second, conflicting order."
+  }
+];
+var DEFAULT_PER_ENTRY_OVERHEAD_CHARS = 5;
+function computeCodexResidentSet(catalogue, opts) {
+  const budgetChars = opts?.budgetChars ?? CODEX_BUDGET_CHARS;
+  const overhead = opts?.perEntryOverheadChars ?? DEFAULT_PER_ENTRY_OVERHEAD_CHARS;
+  const ordered = catalogue.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const resident = [];
+  const nonResident = [];
+  let listingChars = 0;
+  let overflowed = false;
+  for (const e of ordered) {
+    const cost = e.name.length + e.descriptionChars + overhead;
+    if (overflowed || listingChars + cost > budgetChars) {
+      overflowed = true;
+      nonResident.push(e.name);
+      continue;
+    }
+    resident.push(e.name);
+    listingChars += cost;
+  }
+  return { budgetChars, resident, nonResident, listingChars, assumptions: ASSUMPTIONS };
+}
+function recordPath(anchor, env) {
+  const key = createHash2("sha256").update(path.resolve(anchor)).digest("hex").slice(0, 16);
+  return path.join(write_target(RECORD_DIRNAME, { env: env ?? null }), `${key}.json`);
+}
+function finderRecordPath(anchor, env) {
+  return recordPath(anchor, env).replace(/\.json$/, ".finder.json");
+}
+function codexSkillRoots(home) {
+  return [path.join(home, ".codex"), path.join(home, ".agents")].filter(
+    (a) => fs.existsSync(path.join(a, "skills"))
+  );
+}
+function ownedCatalogue(skillsDir, owned) {
+  const out = [];
+  for (const name of owned) {
+    let raw;
+    try {
+      raw = fs.readFileSync(path.join(skillsDir, name, "SKILL.md"), "utf8");
+    } catch {
+      continue;
+    }
+    const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+    const line = fm ? /^description:[ \t]*(.*)$/m.exec(fm[1]) : null;
+    out.push({ name, descriptionChars: line ? line[1].replace(/^["']|["']$/g, "").length : 0 });
+  }
+  return out;
+}
+function loadRecord(file, anchor) {
+  const empty = { schema_version: 1, anchor, written: [] };
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return empty;
+  }
+  const r = data;
+  if (!r || typeof r !== "object" || !Array.isArray(r.written)) return empty;
+  if (path.resolve(String(r.anchor)) !== path.resolve(anchor)) return empty;
+  return { schema_version: 1, anchor, written: r.written.filter((x) => typeof x === "string") };
+}
+function saveRecord(file, rec) {
+  if (rec.written.length === 0) {
+    fs.rmSync(file, { force: true });
+    return;
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const sorted = { ...rec, written: [...rec.written].sort() };
+  atomicWriteFile(file, `${JSON.stringify(sorted, null, 2)}
+`);
+}
+function dropPolicy(abs) {
+  fs.rmSync(abs, { force: true });
+  const dir = path.dirname(abs);
+  try {
+    if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+  } catch {
+  }
+}
+function ensureCodexResidentSet(anchor, recordFile, nonResident) {
+  const skillsDir = path.join(anchor, "skills");
+  const rec = loadRecord(recordFile, anchor);
+  const result = { changed: false, disabled: [], reenabled: [], skipped_foreign: [] };
+  const want = new Set(nonResident);
+  const ours = new Set(rec.written);
+  const next = [];
+  for (const rel of rec.written) {
+    const abs = path.join(anchor, rel);
+    const name = rel.split(path.sep)[1] ?? "";
+    if (!fs.existsSync(abs)) continue;
+    if (fs.readFileSync(abs, "utf-8") !== POLICY_BODY) continue;
+    if (want.has(name)) {
+      next.push(rel);
+      continue;
+    }
+    dropPolicy(abs);
+    result.reenabled.push(name);
+  }
+  for (const name of [...want].sort()) {
+    const rel = path.join("skills", name, POLICY_REL);
+    if (ours.has(rel) && next.includes(rel)) continue;
+    const dir = path.join(skillsDir, name);
+    if (!fs.existsSync(dir)) continue;
+    const abs = path.join(anchor, rel);
+    if (fs.existsSync(abs) && fs.readFileSync(abs, "utf-8") !== POLICY_BODY) {
+      result.skipped_foreign.push(name);
+      continue;
+    }
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    atomicWriteFile(abs, POLICY_BODY);
+    next.push(rel);
+    result.disabled.push(name);
+  }
+  result.changed = result.disabled.length > 0 || result.reenabled.length > 0;
+  saveRecord(recordFile, { schema_version: 1, anchor, written: next });
+  result.disabled.sort();
+  result.reenabled.sort();
+  result.skipped_foreign.sort();
+  return result;
+}
+function removeCodexResidentSet(anchor, recordFile) {
+  const finder = removeCodexFinder(anchor, recordFile.replace(/\.json$/, ".finder.json"));
+  const result = { changed: finder === "removed", removed: [], kept_user: [], finder };
+  if (!fs.existsSync(recordFile)) return result;
+  const rec = loadRecord(recordFile, anchor);
+  for (const rel of rec.written) {
+    const abs = path.join(anchor, rel);
+    if (!fs.existsSync(abs)) continue;
+    if (fs.readFileSync(abs, "utf-8") !== POLICY_BODY) {
+      result.kept_user.push(rel);
+      continue;
+    }
+    dropPolicy(abs);
+    result.removed.push(rel);
+  }
+  fs.rmSync(recordFile, { force: true });
+  result.changed = result.changed || result.removed.length > 0;
+  result.removed.sort();
+  result.kept_user.sort();
+  return result;
+}
+function applyCodexResidentSet(home, report) {
+  try {
+    const roots = codexSkillRoots(home);
+    if (roots.length === 0) return;
+    const firstRootOf = /* @__PURE__ */ new Map();
+    const catalogue = [];
+    for (const anchor of roots) {
+      const skillsDir = path.join(anchor, "skills");
+      const owned = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== FINDER_NAME && fs.existsSync(path.join(skillsDir, d.name, "SKILL.md"))).map((d) => d.name);
+      for (const e of ownedCatalogue(skillsDir, owned)) {
+        if (firstRootOf.has(e.name)) continue;
+        firstRootOf.set(e.name, anchor);
+        catalogue.push(e);
+      }
+    }
+    const finderCost = FINDER_NAME.length + finderDescription(catalogue.length).length + DEFAULT_PER_ENTRY_OVERHEAD_CHARS;
+    let split = computeCodexResidentSet(catalogue);
+    if (split.nonResident.length > 0) {
+      split = computeCodexResidentSet(catalogue, { budgetChars: CODEX_BUDGET_CHARS - finderCost });
+    }
+    const resident = new Set(split.resident);
+    const finder = ensureCodexFinder(
+      roots[0],
+      finderRecordPath(roots[0]),
+      split.nonResident.map((name) => ({ name, skillsDir: path.join(firstRootOf.get(name), "skills") }))
+    );
+    const unlistAllowed = finder !== "foreign";
+    let disabled = 0;
+    let reenabled = 0;
+    let foreign = 0;
+    for (const anchor of roots) {
+      const skillsDir = path.join(anchor, "skills");
+      const here = fs.readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== FINDER_NAME && fs.existsSync(path.join(skillsDir, d.name, "SKILL.md"))).map((d) => d.name);
+      const nonResident = unlistAllowed ? here.filter((n) => !resident.has(n) || firstRootOf.get(n) !== anchor) : [];
+      const res = ensureCodexResidentSet(anchor, recordPath(anchor), nonResident);
+      disabled += res.disabled.length;
+      reenabled += res.reenabled.length;
+      foreign += res.skipped_foreign.length;
+    }
+    report(
+      `codex: resident set across ${roots.length} root(s) \u2014 ${split.resident.length} listed (${split.listingChars} of ${split.budgetChars} chars), ${disabled} newly unlisted, ${reenabled} relisted` + (foreign > 0 ? `, ${foreign} existing policy file(s) untouched` : "") + `, finder ${finder}` + (unlistAllowed ? "" : " \u2014 nothing unlisted, because no finder could route to it")
+    );
+  } catch (e) {
+    report(`codex: resident set skipped \u2014 ${String(e)}`);
+  }
+}
+
+// src/scripts/_lib/skill_listing_overrides.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/scripts/_lib/host_listing_model.ts
+var CLAUDE_CODE_LISTING_DEFAULTS = {
+  fraction: 0.01,
+  perEntryCapChars: 1536,
+  charsPerToken: 4,
+  perEntryOverheadChars: 0
+};
+var ASSUMPTIONS2 = [
+  {
+    id: "budget-unit-is-chars",
+    provenance: "upstream-prose",
+    why: 'The docs give the budget as a fraction of the context window (tokens); the 2026-08-22 read illustrated it as "\u22488,000 characters on 200k" (gone by 2026-10-14), which only reconciles at 4 chars per token. That ratio is inferred, never stated.'
+  },
+  {
+    id: "fill-order-is-invocation-frequency",
+    provenance: "upstream-prose",
+    why: "Upstream says the budget fills by invocation frequency, but does not say what orders entries when no invocation history exists. This model falls back to alphabetical, which is this repo's choice and not upstream behaviour."
+  },
+  {
+    id: "names-are-never-dropped",
+    provenance: "upstream-prose",
+    why: "Claude Code lists every name and budgets only descriptions. Another host (codex) drops whole entries instead, so this is a per-host property and is not transferable to a second host without its own model."
+  },
+  {
+    id: "stop-at-first-overflow",
+    provenance: "upstream-prose",
+    why: "The docs describe filling a budget, not packing one. A shorter later entry might in principle still fit after a longer one has overflowed; this model stops at the first entry that does not fit rather than skipping past it."
+  },
+  {
+    id: "wrapper-overhead-unmodelled",
+    provenance: "upstream-prose",
+    why: "Each delivered entry also costs its name, separators and newlines. Upstream quantifies none of that, so the default overhead here is 0 and the budget is therefore an upper bound on how many descriptions survive."
+  }
+];
+function modelListingBudget(catalogue, input) {
+  const fraction = input.fraction ?? CLAUDE_CODE_LISTING_DEFAULTS.fraction;
+  const perEntryCap = input.perEntryCapChars ?? CLAUDE_CODE_LISTING_DEFAULTS.perEntryCapChars;
+  const charsPerToken = input.charsPerToken ?? CLAUDE_CODE_LISTING_DEFAULTS.charsPerToken;
+  const overhead = input.perEntryOverheadChars ?? CLAUDE_CODE_LISTING_DEFAULTS.perEntryOverheadChars;
+  const usageOrder = input.usageOrder ?? [];
+  const budgetChars = Math.floor(input.contextWindowTokens * fraction * charsPerToken);
+  const fillOrder = usageOrder.length > 0 ? "usage" : "alphabetical-fallback";
+  const byName = new Map(catalogue.map((e) => [e.name, e]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of usageOrder) {
+    const e = byName.get(name);
+    if (e && !seen.has(name)) {
+      ordered.push(e);
+      seen.add(name);
+    }
+  }
+  const rest = catalogue.filter((e) => !seen.has(e.name)).slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  ordered.push(...rest);
+  const surviving = [];
+  const bare = [];
+  let spentChars = 0;
+  let overflowed = false;
+  for (const e of ordered) {
+    if (overflowed) {
+      bare.push(e.name);
+      continue;
+    }
+    const cost = Math.min(e.descriptionChars, perEntryCap) + overhead;
+    if (spentChars + cost <= budgetChars) {
+      surviving.push(e.name);
+      spentChars += cost;
+    } else {
+      overflowed = true;
+      bare.push(e.name);
+    }
+  }
+  return { budgetChars, fillOrder, surviving, bare, spentChars, assumptions: ASSUMPTIONS2 };
+}
+
+// src/scripts/_lib/skill_listing_overrides.ts
+var OVERRIDE_KEY = "skillOverrides";
+var NAME_ONLY = "name-only";
+var RECORD_BASENAME = "skill-overrides.json";
+function recordPath2(env) {
+  return write_target(RECORD_BASENAME, { env: env ?? null });
+}
+function ownedSkillNames(currentFiles) {
+  const out = /* @__PURE__ */ new Set();
+  for (const rel of currentFiles) {
+    const m = /^skills\/([^/]+)\/SKILL\.md$/.exec(rel.split(path2.sep).join("/"));
+    if (m) out.add(m[1]);
+  }
+  return [...out].sort();
+}
+function ownedCatalogue2(skillsDir, owned) {
+  const out = [];
+  for (const name of owned) {
+    let raw;
+    try {
+      raw = fs2.readFileSync(path2.join(skillsDir, name, "SKILL.md"), "utf8");
+    } catch {
+      continue;
+    }
+    const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+    const line = fm ? /^description:[ \t]*(.*)$/m.exec(fm[1]) : null;
+    out.push({ name, descriptionChars: line ? line[1].replace(/^["']|["']$/g, "").length : 0 });
+  }
+  return out;
+}
+function computeOverrides(skillsDir, owned) {
+  const catalogue = ownedCatalogue2(skillsDir, owned);
+  const { bare } = modelListingBudget(catalogue, { contextWindowTokens: 2e5 });
+  const out = {};
+  for (const name of bare) out[name] = NAME_ONLY;
+  return out;
+}
+function loadRecord2(file, settingsPath) {
+  const empty = { schema_version: 1, settings_path: settingsPath, created_key: false, entries: {} };
+  let data;
+  try {
+    data = JSON.parse(fs2.readFileSync(file, "utf-8"));
+  } catch {
+    return empty;
+  }
+  const r = data;
+  if (!r || typeof r !== "object" || typeof r.entries !== "object" || r.entries === null) return empty;
+  if (path2.resolve(String(r.settings_path)) !== path2.resolve(settingsPath)) return empty;
+  const entries = {};
+  for (const [k, v] of Object.entries(r.entries)) if (typeof v === "string") entries[k] = v;
+  return { schema_version: 1, settings_path: settingsPath, created_key: r.created_key === true, entries };
+}
+function saveRecord2(file, rec) {
+  if (Object.keys(rec.entries).length === 0) {
+    fs2.rmSync(file, { force: true });
+    return;
+  }
+  fs2.mkdirSync(path2.dirname(file), { recursive: true });
+  atomicWriteFile(file, `${JSON.stringify({ ...rec, entries: sortKeys(rec.entries) }, null, 2)}
+`);
+}
+function sortKeys(o) {
+  return Object.fromEntries(Object.keys(o).sort().map((k) => [k, o[k]]));
+}
+function overridesOf(settings) {
+  const raw = settings[OVERRIDE_KEY];
+  if (raw === void 0) return void 0;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  return raw;
+}
+function ensureListingOverrides(settingsPath, recordFile, wanted) {
+  return _with_lock(settingsPath, () => {
+    const settings = _read_settings(settingsPath);
+    const rec = loadRecord2(recordFile, settingsPath);
+    const existing = overridesOf(settings);
+    const result = { changed: false, written: [], removed: [], skipped_user: [] };
+    if (existing === null) {
+      result.skipped_user.push(...Object.keys(wanted).sort());
+      return result;
+    }
+    const overrides = { ...existing ?? {} };
+    const next = {};
+    for (const [name, value] of Object.entries(rec.entries)) {
+      if (overrides[name] !== value) continue;
+      const want = wanted[name];
+      if (want === void 0) {
+        delete overrides[name];
+        result.removed.push(name);
+      } else {
+        if (want !== value) {
+          overrides[name] = want;
+          result.written.push(name);
+        }
+        next[name] = want;
+      }
+    }
+    for (const [name, value] of Object.entries(wanted)) {
+      if (name in next) continue;
+      if (name in overrides) {
+        result.skipped_user.push(name);
+        continue;
+      }
+      overrides[name] = value;
+      next[name] = value;
+      result.written.push(name);
+    }
+    const createdKey = rec.created_key || existing === void 0 && Object.keys(next).length > 0;
+    if (Object.keys(overrides).length === 0 && createdKey) delete settings[OVERRIDE_KEY];
+    else if (existing !== void 0 || Object.keys(overrides).length > 0) settings[OVERRIDE_KEY] = overrides;
+    result.changed = result.written.length + result.removed.length > 0;
+    if (result.changed) atomicWriteFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+    saveRecord2(recordFile, { schema_version: 1, settings_path: settingsPath, created_key: createdKey, entries: next });
+    result.written.sort();
+    result.removed.sort();
+    result.skipped_user.sort();
+    return result;
+  });
+}
+function removeListingOverrides(settingsPath, recordFile) {
+  const result = { changed: false, removed: [], kept_user: [] };
+  if (!fs2.existsSync(recordFile)) return result;
+  if (!fs2.existsSync(settingsPath)) {
+    fs2.rmSync(recordFile, { force: true });
+    return result;
+  }
+  return _with_lock(settingsPath, () => {
+    const settings = _read_settings(settingsPath);
+    const rec = loadRecord2(recordFile, settingsPath);
+    const existing = overridesOf(settings);
+    if (existing) {
+      for (const [name, value] of Object.entries(rec.entries)) {
+        if (existing[name] === value) {
+          delete existing[name];
+          result.removed.push(name);
+        } else if (name in existing) {
+          result.kept_user.push(name);
+        }
+      }
+      if (rec.created_key && Object.keys(existing).length === 0) delete settings[OVERRIDE_KEY];
+    }
+    result.changed = result.removed.length > 0;
+    if (result.changed) atomicWriteFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+    fs2.rmSync(recordFile, { force: true });
+    result.removed.sort();
+    result.kept_user.sort();
+    return result;
+  });
+}
+function applyListingOverrides(anchor, report) {
+  try {
+    const owned = ownedSkillNames(recorded_rel_files("claude-code", anchor));
+    const wanted = computeOverrides(path2.join(anchor, "skills"), owned);
+    const res = ensureListingOverrides(path2.join(anchor, "settings.json"), recordPath2(), wanted);
+    if (res.changed) {
+      report(
+        `claude-code: listing override in ~/.claude/settings.json \u2014 ${res.written.length} set name-only, ${res.removed.length} removed`
+      );
+    }
+    if (res.skipped_user.length > 0) {
+      report(
+        `claude-code: listing override left ${res.skipped_user.length} user value(s) untouched (${res.skipped_user.slice(0, 5).join(", ")}${res.skipped_user.length > 5 ? ", \u2026" : ""})`
+      );
+    }
+  } catch (e) {
+    report(`claude-code: listing override skipped \u2014 ${String(e)}`);
+  }
+}
+function applyHostListingPolicies(deployed, home, claudeAnchor, report) {
+  if (deployed.claudeCode) applyListingOverrides(claudeAnchor, report);
+  if (deployed.codex) applyCodexResidentSet(home, report);
+}
+
 // src/scripts/install.ts
 import { spawn, spawnSync } from "node:child_process";
 import * as crypto5 from "node:crypto";
 import * as fs18 from "node:fs";
-import * as os7 from "node:os";
+import * as os8 from "node:os";
 import * as path18 from "node:path";
 import process2 from "node:process";
-import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 
 // src/scripts/_lib/reserved_name_sweep.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 function sweepReservedNames(commandsDir, currentFiles, isBuiltinName, recordedFiles) {
   const reserved = [];
   const foreign = [];
   let entries = [];
   try {
-    entries = fs.readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
+    entries = fs3.readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
   } catch {
     return { reserved, foreign };
   }
@@ -374,7 +883,7 @@ function sweepReservedNames(commandsDir, currentFiles, isBuiltinName, recordedFi
       foreign.push(slug);
       continue;
     }
-    fs.rmSync(path.join(commandsDir, fname), { force: true });
+    fs3.rmSync(path3.join(commandsDir, fname), { force: true });
     currentFiles.delete(rel);
     reserved.push(slug);
   }
@@ -383,11 +892,13 @@ function sweepReservedNames(commandsDir, currentFiles, isBuiltinName, recordedFi
 
 // src/scripts/_lib/host_env_write.ts
 var YAML = __toESM(require_dist(), 1);
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+var MAX_CONCURRENT_SUBAGENTS = 64;
 var WRITABLE_HOST_ENV = [
-  { variable: "BASH_MAX_OUTPUT_LENGTH", settingsKey: "bash_max_output_length" },
-  { variable: "MAX_MCP_OUTPUT_TOKENS", settingsKey: "max_mcp_output_tokens" }
+  { variable: "BASH_MAX_OUTPUT_LENGTH", settingsKey: "host_environment.request_size_caps.bash_max_output_length" },
+  { variable: "MAX_MCP_OUTPUT_TOKENS", settingsKey: "host_environment.request_size_caps.max_mcp_output_tokens" },
+  { variable: "CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS", settingsKey: "subagents.max_parallel", max: MAX_CONCURRENT_SUBAGENTS }
 ];
 var SETTINGS_CANDIDATES = [
   ["agents", "settings", ".agent-settings.yml"],
@@ -395,10 +906,10 @@ var SETTINGS_CANDIDATES = [
 ];
 function readSettingsDoc(projectRoot) {
   for (const parts of SETTINGS_CANDIDATES) {
-    const p = path2.join(projectRoot, ...parts);
+    const p = path4.join(projectRoot, ...parts);
     let text;
     try {
-      text = fs2.readFileSync(p, "utf-8");
+      text = fs4.readFileSync(p, "utf-8");
     } catch {
       continue;
     }
@@ -413,21 +924,22 @@ function readSettingsDoc(projectRoot) {
   return null;
 }
 function hostEnvBlock(settings) {
-  const root = settings;
-  const he = root?.["host_environment"];
-  const caps = he?.["request_size_caps"];
-  if (caps === void 0) return null;
   const out = {};
-  for (const { variable, settingsKey } of WRITABLE_HOST_ENV) {
-    const v = caps[settingsKey];
-    if (typeof v === "number" && Number.isInteger(v) && v > 0) out[variable] = String(v);
+  for (const { variable, settingsKey, max } of WRITABLE_HOST_ENV) {
+    let v = settings;
+    for (const part of settingsKey.split(".")) {
+      v = v !== null && typeof v === "object" ? v[part] : void 0;
+    }
+    if (typeof v !== "number" || !Number.isSafeInteger(v) || v <= 0) continue;
+    if (max !== void 0 && v > max) continue;
+    out[variable] = String(v);
   }
   return Object.keys(out).length === 0 ? null : out;
 }
 function withHostEnv(bridge, projectRoot, announce) {
   const env = hostEnvBlock(readSettingsDoc(projectRoot));
   if (env === null) return bridge;
-  announce(`.claude/settings.json: wrote ${Object.keys(env).join(", ")} (request-size caps)`);
+  announce(`.claude/settings.json: wrote ${Object.keys(env).join(", ")} (request-size and concurrency caps)`);
   return { ...bridge, env };
 }
 
@@ -546,7 +1058,10 @@ var _CURRENT = [
   "dataviz",
   "debug",
   "deep-research",
+  "design",
+  "design-consent",
   "design-login",
+  "design-revoke",
   "design-sync",
   "desktop",
   "diff",
@@ -639,25 +1154,25 @@ function is_claude_builtin_name(slug) {
 }
 
 // src/scripts/_lib/mcp_bridge.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 var MCP_SERVER_KEY = "agent-config";
 var MCP_PACKAGE_NAME = "@event4u/agent-config";
 function mcpBridgeEntry(packageRoot) {
   const version = readPackageVersion(packageRoot);
-  const spec = version === null ? MCP_PACKAGE_NAME : `${MCP_PACKAGE_NAME}@${version}`;
+  const args = version === null ? ["-y", MCP_PACKAGE_NAME, "mcp-server"] : ["--prefer-offline", "-y", `${MCP_PACKAGE_NAME}@${version}`, "mcp-server"];
   return {
     mcpServers: {
       [MCP_SERVER_KEY]: {
         command: "npx",
-        args: ["-y", spec, "mcp-server"]
+        args
       }
     }
   };
 }
 function readPackageVersion(packageRoot) {
   try {
-    const raw = fs3.readFileSync(path3.join(packageRoot, "package.json"), "utf-8");
+    const raw = fs5.readFileSync(path5.join(packageRoot, "package.json"), "utf-8");
     const v = JSON.parse(raw).version;
     return typeof v === "string" && v.trim() !== "" ? v : null;
   } catch {
@@ -666,7 +1181,7 @@ function readPackageVersion(packageRoot) {
 }
 function makeEnsureMcpBridge(mergeJsonFile) {
   return (projectRoot, force, packageRoot = projectRoot) => mergeJsonFile(
-    path3.join(projectRoot, ".mcp.json"),
+    path5.join(projectRoot, ".mcp.json"),
     mcpBridgeEntry(packageRoot),
     force,
     ".mcp.json"
@@ -692,7 +1207,7 @@ function makeEnsureMcpRegistrations(mergeJsonFile) {
     const merged = {};
     for (const t of targets) {
       merged[t.toolId] = mergeJsonFile(
-        path3.join(projectRoot, ...t.relPath.split("/")),
+        path5.join(projectRoot, ...t.relPath.split("/")),
         mcpBridgeEntry(packageRoot),
         force,
         t.relPath
@@ -720,132 +1235,121 @@ function registerMcpHosts(mergeJsonFile, projectRoot, force, packageRoot, tools,
   }
 }
 function projectionModeOf(raw) {
-  return raw === "scoped" ? "scoped" : raw === "tiered" ? "tiered" : "legacy-all";
+  return raw === "scoped" ? "scoped" : "legacy-all";
 }
 function resolveTierB(packageRoot) {
-  const p = path3.join(packageRoot, "agents", "runtime", "state", "skill-tiers.json");
-  if (!fs3.existsSync(p)) return null;
+  const p = path5.join(packageRoot, "agents", "runtime", "state", "skill-tiers.json");
+  if (!fs5.existsSync(p)) return null;
   try {
-    const parsed = JSON.parse(fs3.readFileSync(p, "utf-8"));
+    const parsed = JSON.parse(fs5.readFileSync(p, "utf-8"));
     if (!Array.isArray(parsed.tier_b)) return null;
     return new Set(parsed.tier_b.filter((n) => typeof n === "string"));
   } catch {
     return null;
   }
 }
-function tierBPrunePredicate(tierB) {
-  return (mdPath) => tierB.has(path3.basename(path3.dirname(mdPath)));
-}
 function tierBAdvisory(packageRoot) {
   const tierB = resolveTierB(packageRoot);
   if (tierB === null || tierB.size === 0) return null;
   return `\u2139\uFE0F  ${tierB.size} skill(s) are predicted to reach the model WITHOUT their description on a default 200k window.
    Two levers, neither applied for you:
    \u2022 raise \`skillListingBudgetFraction\` in your Claude Code settings \u2014 restores descriptions at a token cost (100% delivery of this catalogue measures ~13,003 tok)
-   \u2022 or set \`projection.mode: tiered\` to withhold them from the catalogue and reach them via the MCP server instead (opt-in, still unproven \u2014 see docs/mcp-server.md)`;
-}
-function applyTieredPrune(deployResults, packageRoot, pruneBy) {
-  const tierB = resolveTierB(packageRoot);
-  if (tierB === null || tierB.size === 0) {
-    return {
-      deployResults,
-      level: "warn",
-      message: "projection.mode: tiered but no skill-tier split exists (agents/runtime/state/skill-tiers.json) \u2014 shipping the full surface. Compute one with `./scripts-run src/scripts/compute_skill_tiers` first."
-    };
-  }
-  const [pruned, adjusted] = pruneBy(deployResults, tierBPrunePredicate(tierB));
-  return {
-    deployResults: adjusted,
-    level: "info",
-    message: `\u{1F9F9} Tiered install: pruned ${pruned} Tier-B skill artefact(s) \u2014 still reachable via the MCP server's suggest_skill_for_task / read_skill. Set projection.mode: legacy-all to restore the full surface.`
-  };
+   \u2022 or reach them through the MCP server, which serves every skill by name regardless of what the host catalogue carries (docs/mcp-server.md)`;
 }
 
 // src/install/conflictTracker.ts
 import * as crypto2 from "node:crypto";
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs7 from "node:fs";
+import * as os from "node:os";
+import * as path7 from "node:path";
 
 // src/install/fsPrimitives.ts
 import * as crypto from "node:crypto";
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 function resolvePath(p) {
   try {
-    return fs4.realpathSync(path4.resolve(p));
+    return fs6.realpathSync(path6.resolve(p));
   } catch {
-    return path4.resolve(p);
+    return path6.resolve(p);
   }
 }
 function pathExists(p) {
   try {
-    fs4.statSync(p);
+    fs6.statSync(p);
     return true;
   } catch {
     return false;
   }
 }
 function mkdirp(p) {
-  fs4.mkdirSync(p, { recursive: true });
+  fs6.mkdirSync(p, { recursive: true });
 }
 function sha256OfFile(p) {
   let data;
   try {
-    data = fs4.readFileSync(p);
+    data = fs6.readFileSync(p);
   } catch {
     return null;
   }
   return crypto.createHash("sha256").update(data).digest("hex");
 }
 
-// src/install/preserve.ts
-var SIDECAR_SUFFIX = ".agent-config.new";
-var EXIT_COMPLETED_WITH_CONFLICTS = 3;
-function decideDeployWrite(inputs) {
-  if (!inputs.exists) return "write";
-  if (inputs.force) return "write";
-  const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
-  return ownership === "recorded-modified" ? "preserve" : "write";
-}
-function sidecarPathFor(target) {
-  return `${target}${SIDECAR_SUFFIX}`;
-}
-function preservedFileMessage(target, sidecar) {
-  return `Preserved user-modified ${target}. Package content was written to ${sidecar}; the active installation is not current. Review and merge it, or rerun with --force to replace the managed file.`;
-}
-function conflictSummaryMessage(count) {
-  const noun = count === 1 ? "file" : "files";
-  return `Completed with conflicts: ${count} user-modified ${noun} preserved. Package content is staged alongside as *${SIDECAR_SUFFIX}; the active installation is not current until you merge it, or rerun with --force to replace the managed ${noun}.`;
-}
-function foreignSidecarMessage(target, sidecar) {
-  return `Refusing to replace ${sidecar}: it already exists with different content and this install cannot show it wrote it. Package content for ${target} was NOT staged. Move or delete that file and re-run, or rerun with --force to replace the managed file instead.`;
-}
-
 // src/install/conflictTracker.ts
 function createConflictTracker(host) {
   const conflictState = {
     root: null,
     recorded: null,
+    ledgerFiles: null,
+    logged: null,
     preserved: [],
+    migrated: /* @__PURE__ */ new Set(),
     staged: /* @__PURE__ */ new Map()
   };
   function recordedHashFor(target) {
     if (conflictState.root === null) return void 0;
-    conflictState.recorded ??= recordedHashesForRoot(conflictState.root);
-    const plain = path5.resolve(target);
+    conflictState.recorded ??= recordedHashesWithLedger(conflictState.root);
+    const plain = path7.resolve(target);
     if (conflictState.recorded.has(plain)) return conflictState.recorded.get(plain);
     const real = resolvePath(target);
     return real === plain ? void 0 : conflictState.recorded.get(real);
   }
+  function ledgerLists(target) {
+    conflictState.ledgerFiles ??= ledgerListedPaths();
+    const files = conflictState.ledgerFiles;
+    return files.has(path7.resolve(target)) || files.has(resolvePath(target));
+  }
+  function wouldWriteDigest(target, would) {
+    const tmp = path7.join(
+      os.tmpdir(),
+      `agent-config-would.${process.pid}.${crypto2.randomBytes(6).toString("hex")}${path7.extname(target)}`
+    );
+    try {
+      if ("content" in would) {
+        fs7.writeFileSync(tmp, would.content, "utf-8");
+      } else {
+        fs7.copyFileSync(would.from, tmp);
+        host.tagDeployed(tmp, would.from, would.packageRoot);
+      }
+      return sha256OfFile(tmp);
+    } catch {
+      return null;
+    } finally {
+      try {
+        fs7.unlinkSync(tmp);
+      } catch {
+      }
+    }
+  }
   function stageInto(target, sidecar, produce) {
-    mkdirp(path5.dirname(sidecar));
-    const tmp = path5.join(
-      path5.dirname(sidecar),
-      `.${path5.basename(sidecar)}.${process.pid}.${crypto2.randomBytes(6).toString("hex")}${path5.extname(target)}`
+    mkdirp(path7.dirname(sidecar));
+    const tmp = path7.join(
+      path7.dirname(sidecar),
+      `.${path7.basename(sidecar)}.${process.pid}.${crypto2.randomBytes(6).toString("hex")}${path7.extname(target)}`
     );
     const discard = () => {
       try {
-        fs5.unlinkSync(tmp);
+        fs7.unlinkSync(tmp);
       } catch {
       }
     };
@@ -872,7 +1376,7 @@ function createConflictTracker(host) {
       }
     }
     try {
-      fs5.renameSync(tmp, sidecar);
+      fs7.renameSync(tmp, sidecar);
     } catch (exc) {
       discard();
       host.fail(
@@ -885,14 +1389,20 @@ function createConflictTracker(host) {
   function record(target, sidecar) {
     if (conflictState.preserved.includes(target)) return;
     conflictState.preserved.push(target);
-    host.warn(preservedFileMessage(target, sidecar));
+    host.warn(
+      conflictState.migrated.has(path7.resolve(target)) ? migrationPreservedMessage(target, sidecar) : preservedFileMessage(target, sidecar)
+    );
   }
   return {
     conflictState,
+    recordedDigest: recordedHashFor,
     begin(root) {
       conflictState.root = root;
       conflictState.recorded = null;
+      conflictState.ledgerFiles = null;
+      conflictState.logged = null;
       conflictState.preserved = [];
+      conflictState.migrated = /* @__PURE__ */ new Set();
       conflictState.staged = /* @__PURE__ */ new Map();
     },
     /**
@@ -901,14 +1411,27 @@ function createConflictTracker(host) {
      * so a file edited between planning and writing is still classified
      * from the bytes that are actually about to be destroyed.
      */
-    resolve(target, force) {
+    resolve(target, force, would) {
       const exists = pathExists(target);
-      return decideDeployWrite({
+      const recordedSha256 = exists ? recordedHashFor(target) : void 0;
+      const unproven = {
         exists,
-        recordedSha256: exists ? recordedHashFor(target) : void 0,
+        recordedSha256,
         onDiskSha256: exists ? sha256OfFile(target) : null,
-        force
-      });
+        force,
+        ledgerListed: exists && ledgerLists(target),
+        recordedIsStaged: typeof recordedSha256 === "string" && recordedSha256 === recordedHashFor(sidecarPathFor(target))
+      };
+      const loggedWrite = logProofApplies(unproven) && wroteTheseBytes(target, unproven.onDiskSha256, conflictState.logged ??= loggedWriteDigests());
+      const base = { ...unproven, loggedWrite };
+      const migrating = isLedgerMigration(base);
+      const decision = decideDeployWrite(
+        migrating ? { ...base, packagedSha256: wouldWriteDigest(target, would) } : base
+      );
+      if (decision === "preserve" && migrating) {
+        conflictState.migrated.add(path7.resolve(target));
+      }
+      return decision;
     },
     /**
      * Stage the package content beside a preserved target.
@@ -921,7 +1444,7 @@ function createConflictTracker(host) {
     preserve(target, source, packageRoot) {
       const sidecar = sidecarPathFor(target);
       stageInto(target, sidecar, (tmp) => {
-        fs5.copyFileSync(source, tmp);
+        fs7.copyFileSync(source, tmp);
         host.tagDeployed(tmp, source, packageRoot);
       });
       record(target, sidecar);
@@ -937,7 +1460,7 @@ function createConflictTracker(host) {
      */
     preserveContent(target, content) {
       const sidecar = sidecarPathFor(target);
-      stageInto(target, sidecar, (tmp) => fs5.writeFileSync(tmp, content, "utf-8"));
+      stageInto(target, sidecar, (tmp) => fs7.writeFileSync(tmp, content, "utf-8"));
       record(target, sidecar);
     },
     /**
@@ -957,9 +1480,9 @@ function createConflictTracker(host) {
 
 // src/install/manifestFiles.ts
 var YAML2 = __toESM(require_dist(), 1);
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join as join5, resolve as resolve3 } from "node:path";
+import { isAbsolute, join as join7, resolve as resolve5 } from "node:path";
 function fileEntry(p, kind, hashContent) {
   return { path: p, kind, sha256: hashContent ? sha256OfFile(p) : null };
 }
@@ -982,7 +1505,7 @@ function filesByToolFromBridges(tools, projectRoot, scope, bridgeMarker) {
   for (const toolId of [...tools].sort()) {
     const marker = bridgeMarker(toolId, scope);
     if (!marker) continue;
-    const markerPath = isAbsolute(marker) ? marker : join5(projectRoot, marker);
+    const markerPath = isAbsolute(marker) ? marker : join7(projectRoot, marker);
     out[toolId] = [fileEntry(markerPath, "bridge", false)];
   }
   return out;
@@ -990,20 +1513,20 @@ function filesByToolFromBridges(tools, projectRoot, scope, bridgeMarker) {
 function expanduser(p) {
   if (p === "~") return homedir();
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return join5(homedir(), p.slice(2));
+    return join7(homedir(), p.slice(2));
   }
   return p;
 }
 function resolveRecorded(raw, projectRoot) {
   const expanded = expanduser(raw);
-  return isAbsolute(expanded) ? resolve3(expanded) : resolve3(projectRoot, expanded);
+  return isAbsolute(expanded) ? resolve5(expanded) : resolve5(projectRoot, expanded);
 }
 function readRecordedByTool(manifestPath, projectRoot) {
   const out = /* @__PURE__ */ new Map();
-  if (!existsSync2(manifestPath)) return out;
+  if (!existsSync4(manifestPath)) return out;
   let doc;
   try {
-    doc = YAML2.parse(readFileSync4(manifestPath, "utf8"));
+    doc = YAML2.parse(readFileSync6(manifestPath, "utf8"));
   } catch {
     return out;
   }
@@ -1057,7 +1580,7 @@ function reconcileToolFiles(fresh, prior, preserved) {
   const seen = /* @__PURE__ */ new Set();
   for (const entry of fresh) {
     const raw = entry["path"];
-    if (typeof raw === "string") seen.add(resolve3(expanduser(raw)));
+    if (typeof raw === "string") seen.add(resolve5(expanduser(raw)));
   }
   const out = [...fresh];
   for (const file of prior.files) {
@@ -1073,18 +1596,106 @@ function preservedIndex(preservedTargets, staged) {
   for (const target of preservedTargets) {
     const sidecar = sidecarPathFor(target);
     const sha = staged.get(sidecar) ?? null;
-    out.set(resolve3(target), {
+    out.set(resolve5(target), {
       sha256: sha,
       sidecar: sha === null ? null : { path: sidecar, kind: "sidecar", sha256: sha }
     });
   }
   return out;
 }
+function dropGlobalScopeFiles(entries, deployed) {
+  for (const entry of entries) {
+    if (entry["scope"] === "global" && deployed.has(String(entry["name"]))) entry["files"] = [];
+  }
+  return entries;
+}
+
+// src/install/ownershipLedger.ts
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
+function relUnder(anchor, abs) {
+  let real = anchor;
+  try {
+    real = fs8.realpathSync(anchor);
+  } catch {
+  }
+  for (const base of [anchor, real]) {
+    const rel = path8.relative(path8.resolve(base), path8.resolve(abs));
+    if (rel !== "" && !rel.startsWith("..") && !path8.isAbsolute(rel)) {
+      return rel.split(path8.sep).join("/");
+    }
+  }
+  return null;
+}
+function recordGlobalDeploy(r) {
+  const inventory = load_inventory(r.inventoryPath ?? null);
+  const previous = recorded_digests(r.toolId, r.anchor, inventory);
+  const sidecars = /* @__PURE__ */ new Map();
+  for (const [abs, digest] of r.staged) {
+    const rel = relUnder(r.anchor, abs);
+    if (rel !== null && digest !== null) sidecars.set(rel, digest);
+  }
+  const keep = /* @__PURE__ */ new Set([...r.currentFiles, ...sidecars.keys()]);
+  const retainedAbs = [];
+  let reaped = [];
+  const tools = inventory["tools"] ?? {};
+  if (r.toolId in tools) {
+    reaped = reaped.concat(
+      reap_stale(r.toolId, r.anchor, keep, inventory, false, retainedAbs)
+    );
+  }
+  reaped = reaped.concat(
+    reap_tagged_orphans(
+      r.anchor,
+      [...r.destSubs],
+      keep,
+      r.packageTag,
+      false,
+      previous,
+      retainedAbs
+    )
+  );
+  const preservedRel = /* @__PURE__ */ new Set();
+  for (const abs of r.preserved) {
+    const rel = relUnder(r.anchor, abs);
+    if (rel !== null) preservedRel.add(rel);
+  }
+  const digests = /* @__PURE__ */ new Map();
+  for (const rel of r.currentFiles) {
+    const abs = path8.join(r.anchor, rel);
+    if (preservedRel.has(rel)) {
+      const staged = r.staged.get(sidecarPathFor(abs)) ?? null;
+      const installed = staged ?? previous.get(rel)?.installed_sha256 ?? r.recordedFor(abs);
+      if (typeof installed !== "string" || installed === "") continue;
+      digests.set(rel, { installed_sha256: installed, packaged_sha256: staged ?? installed });
+      continue;
+    }
+    const onDisk = file_sha256(abs);
+    if (onDisk === null) continue;
+    digests.set(rel, { installed_sha256: onDisk, packaged_sha256: onDisk });
+  }
+  for (const [rel, digest] of sidecars) {
+    digests.set(rel, { installed_sha256: digest, packaged_sha256: digest, kind: "sidecar" });
+  }
+  const retained = [...new Set(retainedAbs)].sort();
+  for (const abs of retained) {
+    const rel = relUnder(r.anchor, abs);
+    const prior = rel === null ? void 0 : previous.get(rel);
+    if (rel === null || prior === void 0) continue;
+    digests.set(rel, { installed_sha256: prior.installed_sha256, packaged_sha256: null });
+  }
+  record_deploy(r.toolId, r.anchorRaw, new Set(r.currentFiles), inventory, digests);
+  save_inventory(inventory, r.inventoryPath ?? null);
+  return { reaped: [...new Set(reaped)].sort(), retained };
+}
+function retainedFileMessage(target) {
+  return `Kept ${target}: the package no longer ships this file, but it was edited after it was installed, so it was not deleted. It is no longer updated by agent-config; delete it yourself when you no longer need it.`;
+}
 
 // src/scripts/_lib/rule_layer_overlap.ts
-import * as fs6 from "node:fs";
-import * as os from "node:os";
-import * as path6 from "node:path";
+import * as fs9 from "node:fs";
+import * as os2 from "node:os";
+import * as path9 from "node:path";
 var INSTALLER_PROVENANCE_KEYS = ["package", "source_path"];
 function stripProvenance(text) {
   const lines = text.split("\n");
@@ -1137,21 +1748,21 @@ function compareLayers(global_layer, project_layer) {
 }
 function hostRuleLayerDirs(projectRoot) {
   return [
-    path6.join(os.homedir(), ".claude", "rules"),
-    path6.join(projectRoot, ".claude", "rules")
+    path9.join(os2.homedir(), ".claude", "rules"),
+    path9.join(projectRoot, ".claude", "rules")
   ];
 }
 function readRuleLayer(dir) {
   let names;
   try {
-    names = fs6.readdirSync(dir);
+    names = fs9.readdirSync(dir);
   } catch {
     return null;
   }
   const files = /* @__PURE__ */ new Map();
   for (const name of names.filter((n) => n.endsWith(".md")).sort()) {
     try {
-      files.set(name, fs6.readFileSync(path6.join(dir, name), "utf-8"));
+      files.set(name, fs9.readFileSync(path9.join(dir, name), "utf-8"));
     } catch {
       continue;
     }
@@ -1159,7 +1770,7 @@ function readRuleLayer(dir) {
   return { dir, files };
 }
 function claudeMdExcludesGlob(dir) {
-  return `${path6.resolve(dir).replace(/\/+$/, "")}/**`;
+  return `${path9.resolve(dir).replace(/\/+$/, "")}/**`;
 }
 function mergeClaudeMdExcludes(existing, entry) {
   if (!Array.isArray(existing)) return [entry];
@@ -1190,25 +1801,25 @@ function decideLayerAction(report, choice, global_dir, project_dir) {
 // src/scripts/_lib/install_drift.ts
 var import_yaml = __toESM(require_dist(), 1);
 import * as crypto3 from "node:crypto";
-import * as fs7 from "node:fs";
-import * as os2 from "node:os";
-import * as path7 from "node:path";
+import * as fs10 from "node:fs";
+import * as os3 from "node:os";
+import * as path10 from "node:path";
 function expanduser2(p) {
   if (p === "~") {
-    return os2.homedir();
+    return os3.homedir();
   }
   if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
-    return path7.join(os2.homedir(), p.slice(2));
+    return path10.join(os3.homedir(), p.slice(2));
   }
   return p;
 }
 function resolve_entry_path(project_root, raw) {
   const p = expanduser2(raw);
-  return path7.isAbsolute(p) ? p : path7.join(project_root, p);
+  return path10.isAbsolute(p) ? p : path10.join(project_root, p);
 }
 function sha256_of_file(p) {
   try {
-    return crypto3.createHash("sha256").update(fs7.readFileSync(p)).digest("hex");
+    return crypto3.createHash("sha256").update(fs10.readFileSync(p)).digest("hex");
   } catch {
     return null;
   }
@@ -1217,7 +1828,7 @@ function collect_drift(project_root, env) {
   const target = manifest_path(project_root, env);
   let text;
   try {
-    text = fs7.readFileSync(target, "utf-8");
+    text = fs10.readFileSync(target, "utf-8");
   } catch {
     return null;
   }
@@ -1262,7 +1873,7 @@ function collect_drift(project_root, env) {
         continue;
       }
       const resolved = resolve_entry_path(project_root, raw_path);
-      if (!fs7.existsSync(resolved)) {
+      if (!fs10.existsSync(resolved)) {
         out.push({
           tool_id,
           path: resolved,
@@ -1314,185 +1925,6 @@ function format_drift_report(entries) {
   return lines.join("\n") + "\n";
 }
 
-// src/scripts/_lib/skill_catalogue.ts
-import * as fs8 from "node:fs";
-import * as path8 from "node:path";
-var PROJECT_CATALOGUE_ROOTS = ["src/skills", ".claude/skills"];
-var HOST_CATALOGUE_ROOT = ".claude/skills";
-var DEFAULT_CATALOGUE_ROOTS = [
-  ...PROJECT_CATALOGUE_ROOTS,
-  `~/${HOST_CATALOGUE_ROOT}`
-];
-var OBSERVATION_LOG = path8.join(
-  "agents",
-  "evidence",
-  "metrics",
-  "skill-catalogue.jsonl"
-);
-function frontmatterOf(content) {
-  if (!content.startsWith("---")) return "";
-  const end = content.indexOf("\n---", 3);
-  if (end === -1) return "";
-  return content.slice(3, end);
-}
-function topLevelKeys(frontmatter) {
-  const keys = [];
-  for (const line of frontmatter.split("\n")) {
-    const match = /^([A-Za-z_][A-Za-z0-9_-]*):/.exec(line);
-    if (match) keys.push(match[1]);
-  }
-  return keys;
-}
-function descriptionOf(frontmatter) {
-  const lines = frontmatter.split("\n");
-  for (let i = 0; i < lines.length; i += 1) {
-    const match = /^description:\s*(.*)$/.exec(lines[i]);
-    if (!match) continue;
-    const rest = match[1].trim();
-    if (/^[|>][-+]?\d*$/.test(rest)) {
-      const body = [];
-      for (let j = i + 1; j < lines.length; j += 1) {
-        const line = lines[j];
-        if (line.trim() === "") {
-          body.push("");
-          continue;
-        }
-        if (!/^\s/.test(line)) break;
-        body.push(line.trim());
-      }
-      return body.join(" ").trim();
-    }
-    return rest.replace(/^["']|["']$/g, "");
-  }
-  return "";
-}
-function readProjectedCatalogue(root) {
-  const names = fs8.readdirSync(root).filter((n) => fs8.existsSync(path8.join(root, n, "SKILL.md"))).sort();
-  return names.map((name, index) => {
-    const content = fs8.readFileSync(path8.join(root, name, "SKILL.md"), "utf-8");
-    const frontmatter = frontmatterOf(content);
-    const description = descriptionOf(frontmatter);
-    return {
-      name,
-      position: index + 1,
-      hasDescription: description.length > 0,
-      descriptionLength: description.length,
-      description,
-      frontmatterKeys: topLevelKeys(frontmatter)
-    };
-  });
-}
-function truncationModeOf(record) {
-  return record.truncation_mode ?? "per-entry";
-}
-function markdownFilesUnder(root) {
-  if (!fs8.existsSync(root)) return [];
-  const out = [];
-  const walk = (dir) => {
-    for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
-      const full = path8.join(dir, entry.name);
-      if (fs8.statSync(full).isDirectory()) walk(full);
-      else if (entry.name.endsWith(".md")) out.push(full);
-    }
-  };
-  walk(root);
-  return out;
-}
-function measureCatalogueVolume(host, root) {
-  const skillsRoot = path8.join(root, "skills");
-  const skills = fs8.existsSync(skillsRoot) ? readProjectedCatalogue(skillsRoot) : [];
-  const commandEntries = markdownFilesUnder(path8.join(root, "commands")).length;
-  return {
-    host,
-    root,
-    skillEntries: skills.length,
-    commandEntries,
-    artefacts: skills.length + commandEntries,
-    descriptionBytes: skills.reduce((sum, e) => sum + Buffer.byteLength(e.description), 0)
-  };
-}
-function _supersedes(candidate, incumbent) {
-  if (candidate.observed_at !== incumbent.observed_at) {
-    return candidate.observed_at > incumbent.observed_at;
-  }
-  return (candidate.dropped_count ?? 0) > (incumbent.dropped_count ?? 0);
-}
-function knownHostLimits(records) {
-  const out = /* @__PURE__ */ new Map();
-  const chosen = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    if (truncationModeOf(record) !== "budget-strip-and-drop") continue;
-    if (typeof record.dropped_count !== "number") continue;
-    if (record.dropped_count <= 0) continue;
-    const previous = chosen.get(record.host);
-    if (previous !== void 0 && !_supersedes(record, previous)) continue;
-    chosen.set(record.host, record);
-    out.set(record.host, {
-      host: record.host,
-      droppedEntries: record.dropped_count,
-      projectedVolume: record.entries_total,
-      projectedSkills: record.projected_skill_count ?? null,
-      observedAt: record.observed_at
-    });
-  }
-  return out;
-}
-function catalogueLimitWarning(volume, limit) {
-  if (limit === void 0) return null;
-  if (limit.projectedSkills === null) return null;
-  if (volume.skillEntries < limit.projectedSkills) return null;
-  return `${volume.host}: deploying ${volume.skillEntries} skills. This host reported dropping ${limit.droppedEntries} entries from the model-visible list when last measured (${limit.observedAt}, at ${limit.projectedSkills} skills) \u2014 that much never reaches the model. Explain: \`agent-config exec capture_skill_catalogue --limits\``;
-}
-function migrationEligibility(host, resolvedMode, currentSkillCount, limits) {
-  if (resolvedMode === "scoped") return { eligible: false, reason: "already-scoped" };
-  if (resolvedMode === "tiered") return { eligible: false, reason: "already-tiered" };
-  const limit = limits.get(host);
-  if (limit === void 0) return { eligible: false, reason: "no-observation-for-host" };
-  if (limit.projectedSkills === null) return { eligible: false, reason: "observation-not-comparable" };
-  if (limit.droppedEntries <= 0) return { eligible: false, reason: "no-truncation-observed" };
-  if (currentSkillCount < limit.projectedSkills) {
-    return { eligible: false, reason: "below-observed-skill-volume" };
-  }
-  return {
-    eligible: true,
-    reason: "eligible",
-    droppedEntries: limit.droppedEntries,
-    observedAt: limit.observedAt
-  };
-}
-function migrationPromptLines(host, eligibility, settingsPath) {
-  return [
-    `${host}: ${eligibility.droppedEntries} catalogue entries never reach the model.`,
-    `Measured on this machine (${eligibility.observedAt}). This install is on \`legacy-all\`,`,
-    "which ships everything and lets the host drop what does not fit \u2014 silently.",
-    "",
-    "Scoping the projection to your active packs is the alternative. Nothing here",
-    "changes it for you: `projection.mode` is yours to set, by hand or in the GUI.",
-    "",
-    `  edit  ${settingsPath}`,
-    "        projection:",
-    "          mode: scoped",
-    "",
-    "  or    agent-config config      (Settings \u2192 projection)",
-    "",
-    "Keeping `legacy-all` is a legitimate choice \u2014 this is a notification, not a gate."
-  ];
-}
-function readObservationLog(logPath) {
-  if (!fs8.existsSync(logPath)) return [];
-  const out = [];
-  for (const line of fs8.readFileSync(logPath, "utf-8").split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) continue;
-    try {
-      out.push(JSON.parse(trimmed));
-    } catch {
-      continue;
-    }
-  }
-  return out;
-}
-
 // src/shared/interactiveContext.ts
 var CI_ENV_KEYS = ["CI", "GITHUB_ACTIONS", "AGENT_CONFIG_CI"];
 function _flagSet(env, key) {
@@ -1522,8 +1954,8 @@ function isInteractiveSession(probe) {
 
 // src/scripts/_lib/claude_desktop_bundler.ts
 import * as crypto4 from "node:crypto";
-import * as fs9 from "node:fs";
-import * as path9 from "node:path";
+import * as fs11 from "node:fs";
+import * as path11 from "node:path";
 
 // src/scripts/_lib/zip_min.ts
 import * as zlib from "node:zlib";
@@ -1630,7 +2062,7 @@ function _is_excluded(rel_parts) {
 }
 function _is_dir(p) {
   try {
-    return fs9.statSync(p).isDirectory();
+    return fs11.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -1642,12 +2074,12 @@ function _compare_rel_parts(a, b) {
 }
 function _walk_skill_files(skill_dir) {
   const out = [];
-  const resolved = fs9.realpathSync(skill_dir);
+  const resolved = fs11.realpathSync(skill_dir);
   const walk = (root, relRoot) => {
     const dirNames = [];
     const fileNames = [];
-    for (const dirent of fs9.readdirSync(root, { withFileTypes: true })) {
-      const full = path9.join(root, dirent.name);
+    for (const dirent of fs11.readdirSync(root, { withFileTypes: true })) {
+      const full = path11.join(root, dirent.name);
       const isDir2 = dirent.isDirectory() || dirent.isSymbolicLink() && _is_dir(full);
       if (isDir2) {
         dirNames.push(dirent.name);
@@ -1660,13 +2092,13 @@ function _walk_skill_files(skill_dir) {
       if (_is_excluded(rel_parts)) {
         continue;
       }
-      out.push([path9.join(root, fname), rel_parts]);
+      out.push([path11.join(root, fname), rel_parts]);
     }
     for (const dname of dirNames) {
       if (_is_excluded([dname])) {
         continue;
       }
-      walk(path9.join(root, dname), [...relRoot, dname]);
+      walk(path11.join(root, dname), [...relRoot, dname]);
     }
   };
   walk(resolved, []);
@@ -1679,53 +2111,53 @@ function _manifest_digest(files) {
     const rel = rel_parts.join("/");
     h.update(Buffer.from(rel, "utf-8"));
     h.update(Buffer.from([0]));
-    h.update(crypto4.createHash("sha256").update(fs9.readFileSync(abs_path)).digest());
+    h.update(crypto4.createHash("sha256").update(fs11.readFileSync(abs_path)).digest());
     h.update(Buffer.from([0]));
   }
   return h.digest("hex");
 }
 function _atomic_write_zip(zip_path, files) {
-  fs9.mkdirSync(path9.dirname(zip_path), { recursive: true });
-  const stem = path9.basename(zip_path, path9.extname(zip_path));
-  const tmp_path = path9.join(
-    path9.dirname(zip_path),
+  fs11.mkdirSync(path11.dirname(zip_path), { recursive: true });
+  const stem = path11.basename(zip_path, path11.extname(zip_path));
+  const tmp_path = path11.join(
+    path11.dirname(zip_path),
     `.${stem}.${crypto4.randomBytes(6).toString("hex")}.zip.tmp`
   );
   try {
     const entries = files.map(([abs_path, rel_parts]) => ({
       name: rel_parts.join("/"),
-      data: fs9.readFileSync(abs_path)
+      data: fs11.readFileSync(abs_path)
     }));
-    fs9.writeFileSync(tmp_path, zip_write_sync(entries));
-    fs9.renameSync(tmp_path, zip_path);
+    fs11.writeFileSync(tmp_path, zip_write_sync(entries));
+    fs11.renameSync(tmp_path, zip_path);
   } finally {
-    if (fs9.existsSync(tmp_path)) {
-      fs9.unlinkSync(tmp_path);
+    if (fs11.existsSync(tmp_path)) {
+      fs11.unlinkSync(tmp_path);
     }
   }
 }
 function _write_if_changed(dest_dir, slug, files, force, written) {
   const digest = _manifest_digest(files);
-  const zip_path = path9.join(dest_dir, `${slug}.zip`);
-  const digest_path = path9.join(dest_dir, `${slug}.sha256`);
-  const recorded = fs9.existsSync(digest_path) ? fs9.readFileSync(digest_path, "utf-8").trim() : "";
-  if (!force && recorded === digest && fs9.existsSync(zip_path)) {
+  const zip_path = path11.join(dest_dir, `${slug}.zip`);
+  const digest_path = path11.join(dest_dir, `${slug}.sha256`);
+  const recorded = fs11.existsSync(digest_path) ? fs11.readFileSync(digest_path, "utf-8").trim() : "";
+  if (!force && recorded === digest && fs11.existsSync(zip_path)) {
     return;
   }
   _atomic_write_zip(zip_path, files);
-  fs9.writeFileSync(digest_path, digest + "\n", "utf-8");
+  fs11.writeFileSync(digest_path, digest + "\n", "utf-8");
   written.push(zip_path);
 }
 function build_skill_bundles(package_root, dest_dir, force = false, curation = null) {
-  const skills_root = path9.join(package_root, "dist/agent-src", "skills");
+  const skills_root = path11.join(package_root, "dist/agent-src", "skills");
   if (!_is_dir(skills_root)) {
     return [];
   }
-  fs9.mkdirSync(dest_dir, { recursive: true });
+  fs11.mkdirSync(dest_dir, { recursive: true });
   const written = [];
-  for (const name of fs9.readdirSync(skills_root).sort()) {
-    const entry = path9.join(skills_root, name);
-    const isSymlink2 = fs9.lstatSync(entry).isSymbolicLink();
+  for (const name of fs11.readdirSync(skills_root).sort()) {
+    const entry = path11.join(skills_root, name);
+    const isSymlink2 = fs11.lstatSync(entry).isSymbolicLink();
     if (!(_is_dir(entry) || isSymlink2)) {
       continue;
     }
@@ -1733,8 +2165,8 @@ function build_skill_bundles(package_root, dest_dir, force = false, curation = n
     if (curation !== null && !curation.includes(skill_name)) {
       continue;
     }
-    const skill_md = path9.join(entry, "SKILL.md");
-    if (!fs9.existsSync(skill_md)) {
+    const skill_md = path11.join(entry, "SKILL.md");
+    if (!fs11.existsSync(skill_md)) {
       continue;
     }
     const files = _walk_skill_files(entry);
@@ -1746,15 +2178,15 @@ function build_skill_bundles(package_root, dest_dir, force = false, curation = n
   return written;
 }
 function _command_slug(source_file, commands_root) {
-  const rel = path9.relative(commands_root, source_file);
-  const noExt = rel.slice(0, rel.length - path9.extname(rel).length);
-  return noExt.split(path9.sep).join("-");
+  const rel = path11.relative(commands_root, source_file);
+  const noExt = rel.slice(0, rel.length - path11.extname(rel).length);
+  return noExt.split(path11.sep).join("-");
 }
 function _iter_command_files(commands_root) {
   const found = [];
   const walk = (dir) => {
-    for (const dirent of fs9.readdirSync(dir, { withFileTypes: true })) {
-      const full = path9.join(dir, dirent.name);
+    for (const dirent of fs11.readdirSync(dir, { withFileTypes: true })) {
+      const full = path11.join(dir, dirent.name);
       if (dirent.isDirectory() || dirent.isSymbolicLink() && _is_dir(full)) {
         walk(full);
       } else if (dirent.name.endsWith(".md")) {
@@ -1764,21 +2196,21 @@ function _iter_command_files(commands_root) {
   };
   walk(commands_root);
   found.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  return found.filter((source_file) => path9.basename(source_file) !== "AGENTS.md");
+  return found.filter((source_file) => path11.basename(source_file) !== "AGENTS.md");
 }
 function build_command_bundles(package_root, dest_dir, force = false, curation = null) {
-  const commands_root = path9.join(package_root, "dist/agent-src", "commands");
+  const commands_root = path11.join(package_root, "dist/agent-src", "commands");
   if (!_is_dir(commands_root)) {
     return [];
   }
-  const skills_root = path9.join(package_root, "dist/agent-src", "skills");
+  const skills_root = path11.join(package_root, "dist/agent-src", "skills");
   let skill_names = /* @__PURE__ */ new Set();
   if (_is_dir(skills_root)) {
     skill_names = new Set(
-      fs9.readdirSync(skills_root).filter((name) => _is_dir(path9.join(skills_root, name)))
+      fs11.readdirSync(skills_root).filter((name) => _is_dir(path11.join(skills_root, name)))
     );
   }
-  fs9.mkdirSync(dest_dir, { recursive: true });
+  fs11.mkdirSync(dest_dir, { recursive: true });
   const written = [];
   for (const source_file of _iter_command_files(commands_root)) {
     const slug = _command_slug(source_file, commands_root);
@@ -1788,180 +2220,73 @@ function build_command_bundles(package_root, dest_dir, force = false, curation =
     if (curation !== null && !curation.includes(slug)) {
       continue;
     }
-    const files = [[fs9.realpathSync(source_file), ["SKILL.md"]]];
+    const files = [[fs11.realpathSync(source_file), ["SKILL.md"]]];
     _write_if_changed(dest_dir, slug, files, force, written);
   }
   return written;
 }
 
-// src/scripts/hooks/host_lowering.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import * as fs10 from "node:fs";
-import * as path10 from "node:path";
-import { fileURLToPath } from "node:url";
-
-// src/scripts/hooks/table_fingerprint.ts
-import { createHash as createHash5 } from "node:crypto";
-function tableFingerprint(text) {
-  const digest = createHash5("sha256").update(text, "utf-8").digest("hex");
-  return `${digest}:${String(text.length)}`;
-}
-
-// src/scripts/hooks/host_lowering.ts
-var _IN_BUNDLE = true;
-var _REPO_ROOT = path10.resolve(
-  path10.dirname(fileURLToPath(import.meta.url)),
-  ..._IN_BUNDLE ? ["..", ".."] : ["..", "..", ".."]
-);
-var HOST_LOWERING_PATH = path10.join(_REPO_ROOT, "src", "scripts", "hooks", "host_lowering.yaml");
-var HOST_LOWERING_JSON_PATH = path10.join(_REPO_ROOT, "src", "scripts", "hooks", "host_lowering.json");
-var DEFAULT_SURFACE = "any";
-function _asString(v) {
-  if (v === null || v === void 0) return null;
-  if (v instanceof Date) return v.toISOString().slice(0, 10);
-  return String(v);
-}
-function _parse(text) {
-  return _structure((0, import_yaml2.parse)(text));
-}
-function _structure(raw) {
-  const hostsRaw = raw?.["hosts"];
-  if (typeof hostsRaw !== "object" || hostsRaw === null) {
-    throw new Error("host_lowering.yaml: missing `hosts:` map");
-  }
-  const out = /* @__PURE__ */ new Map();
-  for (const [host, hv] of Object.entries(hostsRaw)) {
-    const surfacesRaw = hv?.["surfaces"];
-    if (typeof surfacesRaw !== "object" || surfacesRaw === null) {
-      throw new Error(`host_lowering.yaml: ${host} has no \`surfaces:\` map`);
-    }
-    const surfaces = /* @__PURE__ */ new Map();
-    for (const [surface, sv] of Object.entries(surfacesRaw)) {
-      const s = sv;
-      const verifiedRaw = s["verified"];
-      let verified = null;
-      if (verifiedRaw) {
-        const expires = _asString(verifiedRaw["expires"]);
-        if (!expires) {
-          throw new Error(`host_lowering.yaml: ${host}/${surface} verified block has no \`expires\``);
-        }
-        verified = {
-          docs_at: _asString(verifiedRaw["docs_at"]),
-          docs_url: _asString(verifiedRaw["docs_url"]),
-          docs_digest: _asString(verifiedRaw["docs_digest"]),
-          probe_at: _asString(verifiedRaw["probe_at"]),
-          host_version: _asString(verifiedRaw["host_version"]),
-          expires
-        };
-      }
-      const slots = /* @__PURE__ */ new Map();
-      for (const [slot, rvRaw] of Object.entries(s["slots"] ?? {})) {
-        const rv = rvRaw;
-        const nativeRaw = rv["native"];
-        const native = Array.isArray(nativeRaw) ? nativeRaw.map(String) : [String(nativeRaw)];
-        const be = rv["block_exit"];
-        const row = {
-          native,
-          block_exit: typeof be === "number" ? be : null,
-          answered_at: _asString(rv["answered_at"]),
-          docs_url: _asString(rv["docs_url"])
-        };
-        if (typeof rv["matcher"] === "string") row.matcher = rv["matcher"];
-        slots.set(slot, row);
-      }
-      surfaces.set(surface, {
-        entry_shape: String(s["entry_shape"] ?? "none"),
-        json_shape: String(s["json_shape"] ?? "none"),
-        fail_policy: String(s["fail_policy"] ?? "discard"),
-        timeout_unit: String(s["timeout_unit"] ?? "unknown"),
-        timeout_default: typeof s["timeout_default"] === "number" ? s["timeout_default"] : null,
-        verified,
-        slots
-      });
-    }
-    out.set(host, surfaces);
-  }
-  return out;
-}
-var _cache = null;
-function loadHostLowering() {
-  if (_cache !== null) return _cache;
-  const text = fs10.readFileSync(HOST_LOWERING_PATH, "utf-8");
-  let compiled;
-  try {
-    compiled = fs10.readFileSync(HOST_LOWERING_JSON_PATH, "utf-8");
-  } catch {
-    compiled = null;
+// src/scripts/_lib/projection_key_migration.ts
+var MIGRATION_WINDOW = "one release window after the 2026-10 key removal";
+var LEGACY_FULL_VALUE = Object.freeze({
+  "lean_projection.mode": "eager-all",
+  "projection.mode": "legacy-all"
+});
+function readDotted(root, dotted) {
+  let node = root;
+  for (const part of dotted.split(".")) {
+    if (typeof node !== "object" || node === null || Array.isArray(node)) return void 0;
+    node = node[part];
   }
-  _cache = resolveTable(text, compiled);
-  return _cache;
+  return node;
 }
-function resolveTable(yamlText, compiledText) {
-  if (compiledText !== null) {
-    try {
-      const raw = JSON.parse(compiledText);
-      const table = raw["table"];
-      if (raw["fingerprint"] === tableFingerprint(yamlText) && typeof table === "object" && table !== null && // road-to-blocking-severities 2.3 — the BODY, not only its
-      // label. `fingerprint` above says the file was compiled from
-      // the YAML as it stands; it says nothing about whether the
-      // body underneath was edited afterwards, and an edited body
-      // with an untouched label was served. `body_fingerprint` is
-      // the fingerprint of the exact bytes the compiler emitted, so
-      // re-stringifying what we just parsed recovers them.
-      //
-      // A compiled file WITHOUT the field — one written before 2.3 —
-      // falls through here, which is slow and correct: accepting it
-      // would make the check optional and therefore absent.
-      //
-      // What it covers is a partial edit, never an author: anyone
-      // who edits the body can recompute this as easily as the
-      // compiler. The deny in `block_plumbing_writes` and the
-      // ratification record are the mechanisms aimed at an author;
-      // this one is aimed at a mistake.
-      raw["body_fingerprint"] === tableFingerprint(JSON.stringify(table))) {
-        return _structure(table);
-      }
-    } catch {
-    }
-  }
-  return _parse(yamlText);
+function readLegacyProjectionIntent(merged) {
+  const rows = [];
+  let pin = false;
+  for (const [key, full] of Object.entries(LEGACY_FULL_VALUE)) {
+    const raw = readDotted(merged, key);
+    if (typeof raw !== "string") continue;
+    const value = raw.trim();
+    if (value === "") continue;
+    const disposition = value.toLowerCase() === full ? "pin" : "dropped";
+    if (disposition === "pin") pin = true;
+    rows.push({ key, value, disposition });
+  }
+  return { pin, rows };
+}
+function migrationLines(intent) {
+  return intent.rows.map(
+    (row) => row.disposition === "pin" ? `${row.key}: "${row.value}" was removed (ADR-293); read once as a request to keep the rule layer full, and kept as the install receipt's pin \u2014 ${MIGRATION_WINDOW}.` : `${row.key}: "${row.value}" was removed (ADR-293); ignored \u2014 the package decides the layer form from machine evidence, and \`doctor --check layer-form\` says which form it chose and why \u2014 ${MIGRATION_WINDOW}.`
+  );
 }
-function surfaceRow(host, surface = DEFAULT_SURFACE, table = loadHostLowering()) {
-  return table.get(host)?.get(surface) ?? table.get(host)?.get(DEFAULT_SURFACE) ?? null;
-}
-function hostBindings(host, table = loadHostLowering()) {
-  const row = surfaceRow(host, DEFAULT_SURFACE, table);
-  if (!row) return [];
-  const out = [];
-  for (const [slot, sr] of row.slots) {
-    for (const native of sr.native) {
-      out.push({ slot, native, matcher: sr.matcher ?? "" });
-    }
-  }
-  return out;
+function legacyProjectionPin(merged, emit) {
+  if (merged === null) return false;
+  const intent = readLegacyProjectionIntent(merged);
+  for (const line of migrationLines(intent)) emit(line);
+  return intent.pin;
 }
 
 // src/install/partitionEligibility.ts
-import * as fs12 from "node:fs";
-import * as os3 from "node:os";
+import * as fs13 from "node:fs";
+import * as os4 from "node:os";
 
 // src/install/hostLayerFingerprint.ts
 import { createHash as createHash6 } from "node:crypto";
-import * as fs11 from "node:fs";
-import * as path11 from "node:path";
+import * as fs12 from "node:fs";
+import * as path12 from "node:path";
 var FINGERPRINT_SCHEMA = 1;
 function collectFiles(dir) {
   const out = [];
   const walk = (d) => {
     let entries;
     try {
-      entries = fs11.readdirSync(d, { withFileTypes: true });
+      entries = fs12.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     const sorted = [...entries].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const e of sorted) {
-      const p = path11.join(d, e.name);
+      const p = path12.join(d, e.name);
       if (e.isDirectory()) {
         walk(p);
       } else if (e.isFile()) {
@@ -1978,10 +2303,10 @@ function fingerprintLayers(layers) {
   for (const layer of layers) {
     h.update(`layer:${layer.label}\0`);
     for (const file of collectFiles(layer.root)) {
-      h.update(path11.relative(layer.root, file));
+      h.update(path12.relative(layer.root, file));
       h.update("\0");
       try {
-        h.update(fs11.readFileSync(file));
+        h.update(fs12.readFileSync(file));
       } catch {
         h.update("\0unreadable\0");
       }
@@ -1991,11 +2316,11 @@ function fingerprintLayers(layers) {
   return h.digest("hex");
 }
 function hostLayerInputs(userHome) {
-  const claude = path11.join(userHome, ".claude");
+  const claude = path12.join(userHome, ".claude");
   return [
-    { label: "rules", root: path11.join(claude, "rules") },
-    { label: "skills", root: path11.join(claude, "skills") },
-    { label: "commands", root: path11.join(claude, "commands") }
+    { label: "rules", root: path12.join(claude, "rules") },
+    { label: "skills", root: path12.join(claude, "skills") },
+    { label: "commands", root: path12.join(claude, "commands") }
   ];
 }
 
@@ -2004,7 +2329,7 @@ var MAINTAINER_WORKSPACE = "agent-config-maintainer";
 function isExclusivelyPackageOnly(source_path) {
   let meta;
   try {
-    [meta] = parseFrontmatter(fs12.readFileSync(source_path, "utf-8"));
+    [meta] = parseFrontmatter(fs13.readFileSync(source_path, "utf-8"));
   } catch {
     return false;
   }
@@ -2019,7 +2344,7 @@ function stampHostLayerFingerprint(installedVersion, tools, lockfilePath, skip2,
     return null;
   }
   try {
-    const fingerprint = fingerprintLayers(hostLayerInputs(os3.homedir()));
+    const fingerprint = fingerprintLayers(hostLayerInputs(os4.homedir()));
     write_lockfile(installedVersion, [...tools], {
       path: lockfilePath,
       host_layer_fingerprint: fingerprint
@@ -2035,8 +2360,8 @@ function stampHostLayerFingerprint(installedVersion, tools, lockfilePath, skip2,
 }
 
 // src/install/claudeRuleRewrite.ts
-import * as fs13 from "node:fs";
-import * as path12 from "node:path";
+import * as fs14 from "node:fs";
+import * as path13 from "node:path";
 
 // src/install/claudePathsPlan.ts
 function derive_trigger_globs(meta) {
@@ -2146,8 +2471,8 @@ function _withPreservedKeys(rendered, original) {
   }
   return ["---", ...keep, "---", "", rendered].join("\n");
 }
-function rewriteAndReport(rulesDir, quiet, info2, warn2, wrappers, preserved = /* @__PURE__ */ new Set()) {
-  const result = rewriteClaudeRules(rulesDir, preserved);
+function rewriteAndReport(rulesDir, quiet, info2, warn2, wrappers, preserved = /* @__PURE__ */ new Set(), onWrite) {
+  const result = rewriteClaudeRules(rulesDir, preserved, onWrite);
   if (wrappers && !quiet) {
     if (wrappers.wrapped.length > 0) {
       info2(
@@ -2201,27 +2526,27 @@ function renderClaudeRule(sourceText) {
   lines.push(pyRstrip(body) + "\n");
   return { text: lines.join("\n"), globs: plan.globs, dropped: plan.dropped };
 }
-function rewriteClaudeRules(rulesDir, preserved = /* @__PURE__ */ new Set()) {
+function rewriteClaudeRules(rulesDir, preserved = /* @__PURE__ */ new Set(), onWrite) {
   const result = { rewritten: 0, scoped: [], dropped: [], failed: [] };
   let entries;
   try {
-    entries = fs13.readdirSync(rulesDir);
+    entries = fs14.readdirSync(rulesDir);
   } catch {
     return result;
   }
   for (const name of entries.filter((n) => n.endsWith(".md")).sort()) {
-    const full = path12.join(rulesDir, name);
-    if (preserved.has(path12.resolve(full))) continue;
+    const full = path13.join(rulesDir, name);
+    if (preserved.has(path13.resolve(full))) continue;
     let stat;
     try {
-      stat = fs13.lstatSync(full);
+      stat = fs14.lstatSync(full);
     } catch {
       continue;
     }
     if (!stat.isFile() || stat.isSymbolicLink()) continue;
     let text;
     try {
-      text = fs13.readFileSync(full, "utf-8");
+      text = fs14.readFileSync(full, "utf-8");
     } catch {
       continue;
     }
@@ -2231,7 +2556,7 @@ function rewriteClaudeRules(rulesDir, preserved = /* @__PURE__ */ new Set()) {
     const withOwnership = _withPreservedKeys(rendered.text, text);
     if (withOwnership !== text) {
       try {
-        fs13.writeFileSync(full, withOwnership, "utf-8");
+        fs14.writeFileSync(full, withOwnership, "utf-8");
       } catch (e) {
         result.failed.push({
           rule: name.slice(0, -3),
@@ -2239,6 +2564,7 @@ function rewriteClaudeRules(rulesDir, preserved = /* @__PURE__ */ new Set()) {
         });
         continue;
       }
+      onWrite?.(full);
       result.rewritten += 1;
     }
     const stem = name.slice(0, -3);
@@ -2251,19 +2577,19 @@ function rewriteClaudeRules(rulesDir, preserved = /* @__PURE__ */ new Set()) {
 }
 
 // src/install/installThinLayer.ts
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
+import * as os7 from "node:os";
+
+// src/scripts/_lib/installed_layer.ts
 import * as fs15 from "node:fs";
-import * as path15 from "node:path";
 import * as os6 from "node:os";
+import * as path15 from "node:path";
+import { fileURLToPath } from "node:url";
 
-// src/scripts/_lib/installed_layer.ts
-import * as fs14 from "node:fs";
+// src/install/globalRuleLayers.ts
 import * as os5 from "node:os";
 import * as path14 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// src/install/globalRuleLayers.ts
-import * as os4 from "node:os";
-import * as path13 from "node:path";
 var GLOBAL_RULE_DIRS = {
   "claude-code": ".claude/rules",
   cursor: ".cursor/rules",
@@ -2273,9 +2599,17 @@ var GLOBAL_RULE_DIRS = {
   // Cline's scope root IS the rules directory — no `rules/` suffix.
   cline: "Documents/Cline/Rules"
 };
-function globalRuleLayerPath(toolId, home = process.env["HOME"] ?? os4.homedir()) {
+function globalRuleLayerPath(toolId, home = process.env["HOME"] ?? os5.homedir()) {
   const rel = GLOBAL_RULE_DIRS[toolId];
-  return rel === void 0 ? null : path13.join(home, rel);
+  return rel === void 0 ? null : path14.join(home, rel);
+}
+
+// src/scripts/_lib/installed_layer_normalise.ts
+var ABSOLUTE_PATH_TOKEN = "<abs>";
+var POSIX_ABSOLUTE = /(?<![A-Za-z0-9._~%@+:/\\-])(?:\/[A-Za-z0-9._@+~-]+){2,}/g;
+var WINDOWS_ABSOLUTE = /(?<![A-Za-z0-9._~%@+:/\\-])[A-Za-z]:(?:[\\/][A-Za-z0-9._@+~-]+)+/g;
+function normaliseLayerText(text) {
+  return text.replace(WINDOWS_ABSOLUTE, ABSOLUTE_PATH_TOKEN).replace(POSIX_ABSOLUTE, ABSOLUTE_PATH_TOKEN);
 }
 
 // src/scripts/_lib/installed_layer.ts
@@ -2294,6 +2628,7 @@ function readLayer(host, scope, dir, recorded) {
     files: 0,
     unconditional: 0,
     chars: 0,
+    normalised_chars: 0,
     package_owned: 0,
     foreign: 0,
     package_owned_chars: 0,
@@ -2304,19 +2639,19 @@ function readLayer(host, scope, dir, recorded) {
   };
   let names;
   try {
-    names = fs14.readdirSync(dir);
+    names = fs15.readdirSync(dir);
   } catch {
     return { host, scope, dir, present: false, ...empty };
   }
   const readings = [];
   for (const name of names.sort()) {
     if (!name.endsWith(".md")) continue;
-    const abs = path14.join(dir, name);
+    const abs = path15.join(dir, name);
     let text;
     try {
-      const st = fs14.statSync(abs);
+      const st = fs15.statSync(abs);
       if (!st.isFile()) continue;
-      text = fs14.readFileSync(abs, "utf-8");
+      text = fs15.readFileSync(abs, "utf-8");
     } catch {
       continue;
     }
@@ -2328,6 +2663,10 @@ function readLayer(host, scope, dir, recorded) {
       // a host loads" and "what a delivery carries" cannot drift into two
       // spellings of the same measurement.
       chars: ruleBody(text).length,
+      // THE SAME STRING, MEASURED TWICE. `chars` is what the host loads;
+      // this is that text with every absolute path substituted, so two
+      // machines with different package roots read one figure in common.
+      normalised_chars: normaliseLayerText(ruleBody(text)).length,
       unconditional: isUnconditional(text),
       package_owned: owned
     });
@@ -2341,6 +2680,7 @@ function readLayer(host, scope, dir, recorded) {
     files: readings.length,
     unconditional: readings.filter((r) => r.unconditional).length,
     chars: readings.reduce((n, r) => n + r.chars, 0),
+    normalised_chars: readings.reduce((n, r) => n + r.normalised_chars, 0),
     package_owned: readings.filter((r) => r.package_owned).length,
     foreign: readings.filter((r) => !r.package_owned).length,
     package_owned_chars: readings.reduce((n, r) => n + (r.package_owned ? r.chars : 0), 0),
@@ -2351,8 +2691,8 @@ function readLayer(host, scope, dir, recorded) {
   };
 }
 function defaultHostLimitsPath() {
-  return path14.join(
-    path14.dirname(fileURLToPath2(import.meta.url)),
+  return path15.join(
+    path15.dirname(fileURLToPath(import.meta.url)),
     "..",
     "..",
     "config",
@@ -2363,7 +2703,7 @@ function loadHostInstructionLimits(file = defaultHostLimitsPath()) {
   const out = /* @__PURE__ */ new Map();
   let raw;
   try {
-    raw = JSON.parse(fs14.readFileSync(file, "utf-8"));
+    raw = JSON.parse(fs15.readFileSync(file, "utf-8"));
   } catch {
     return out;
   }
@@ -2417,18 +2757,18 @@ function defaultInventoryPath(home) {
   try {
     const real = (q) => {
       try {
-        return fs14.realpathSync(q);
+        return fs15.realpathSync(q);
       } catch {
-        return path14.resolve(q);
+        return path15.resolve(q);
       }
     };
-    const mine = os5.homedir();
-    if (path14.resolve(home) === path14.resolve(mine) || real(home) === real(mine)) {
+    const mine = os6.homedir();
+    if (path15.resolve(home) === path15.resolve(mine) || real(home) === real(mine)) {
       return inventory_path();
     }
   } catch {
   }
-  return path14.join(home, DEFAULT_EVENT4U_ROOT_RELATIVE, INVENTORY_BASENAME);
+  return path15.join(home, DEFAULT_EVENT4U_ROOT_RELATIVE, INVENTORY_BASENAME);
 }
 function resolveLayerOwnership(opts) {
   const recorded = /* @__PURE__ */ new Map();
@@ -2448,18 +2788,18 @@ function resolveLayerOwnership(opts) {
   let fromDeploy = 0;
   for (const [anchor, rels] of opts.thisDeploy ?? /* @__PURE__ */ new Map()) {
     for (const rel of rels) {
-      const abs = path14.resolve(anchor, rel);
+      const abs = path15.resolve(anchor, rel);
       if (!recorded.has(abs)) fromDeploy += 1;
       recorded.set(abs, null);
       try {
-        recorded.set(fs14.realpathSync(abs), null);
+        recorded.set(fs15.realpathSync(abs), null);
       } catch {
       }
     }
   }
   if (fromDeploy > 0) sources.push("this-deploy");
   const manifestPath = opts.manifestPath ?? null;
-  if (manifestPath !== null && fs14.existsSync(manifestPath)) {
+  if (manifestPath !== null && fs15.existsSync(manifestPath)) {
     let n = 0;
     let recordedHashes;
     try {
@@ -2515,9 +2855,9 @@ function renderHostLimitRows(rows) {
 
 // src/install/installThinLayer.ts
 function thinInstalledRuleLayer(opts) {
-  const packageRoot = path15.resolve(opts.packageRoot);
-  const bodySourceDir = path15.join(packageRoot, "dist", "agent-src", "rules");
-  const bodyLinkPrefix = absoluteBodyLinkPrefix(packageRoot);
+  const packageRoot = path16.resolve(opts.packageRoot);
+  const bodySourceDir = path16.join(packageRoot, "dist", "agent-src", "rules");
+  const bodyLinkPrefix = absoluteBodyLinkPrefix(opts.bodyLinkRoot ?? packageRoot);
   const preserved = opts.preserved ?? /* @__PURE__ */ new Set();
   const stubs = build_thin(bodySourceDir, null, null, null, { packageRoot, bodyLinkPrefix });
   let thinned = 0;
@@ -2529,10 +2869,10 @@ function thinInstalledRuleLayer(opts) {
   const absent = [];
   const failed = [];
   for (const [name, stubText] of stubs) {
-    const target = path15.join(opts.rulesDir, name);
+    const target = path16.join(opts.rulesDir, name);
     let installed;
     try {
-      installed = fs15.readFileSync(target, "utf-8");
+      installed = fs16.readFileSync(target, "utf-8");
     } catch (e) {
       if (e.code === "ENOENT") absent.push(name);
       else failed.push({ rule: name, reason: String(e) });
@@ -2540,7 +2880,7 @@ function thinInstalledRuleLayer(opts) {
     }
     let sourceText;
     try {
-      sourceText = fs15.readFileSync(path15.join(bodySourceDir, name), "utf-8");
+      sourceText = fs16.readFileSync(path16.join(bodySourceDir, name), "utf-8");
     } catch {
       sourceText = null;
     }
@@ -2550,7 +2890,7 @@ function thinInstalledRuleLayer(opts) {
       charsAfter += installed.length;
       continue;
     }
-    if (preserved.has(path15.resolve(target))) {
+    if (preserved.has(path16.resolve(target))) {
       preservedHits.push(name);
       charsBefore += installed.length;
       charsAfter += installed.length;
@@ -2569,7 +2909,8 @@ function thinInstalledRuleLayer(opts) {
     const next = `${frontmatter}${stubText}`;
     try {
       if (next !== installed) {
-        fs15.writeFileSync(target, next, "utf-8");
+        fs16.writeFileSync(target, next, "utf-8");
+        opts.onWrite?.(target);
         rewritten += 1;
       }
       thinned += 1;
@@ -2612,7 +2953,7 @@ function describeThinInstalledLayer(res) {
   }
   return out;
 }
-function installReceiptBudgetLines(packageRoot, home = os6.homedir(), opts = {}) {
+function installReceiptBudgetLines(packageRoot, home = os7.homedir(), opts = {}) {
   try {
     const { recorded, sources } = resolveLayerOwnership({
       manifestPath: opts.manifestPath === void 0 ? manifest_path(packageRoot) : opts.manifestPath,
@@ -2696,107 +3037,18 @@ function resolveGlobalRuleScope(inputs) {
   }
 }
 
-// src/scripts/_lib/lean_projection_mode.ts
-import * as path16 from "node:path";
-var DEFAULT_LEAN_PROJECTION_MODE = "eager-all";
-function normalizeLeanProjectionMode(raw) {
-  const v = typeof raw === "string" ? raw.trim().toLowerCase() : "";
-  if (v === "thin") return "thin";
-  if (v === "delivery") return "delivery";
-  return DEFAULT_LEAN_PROJECTION_MODE;
-}
-function writesThinFiles(mode) {
-  return mode === "thin" || mode === "delivery";
-}
-var THINNABLE_HOSTS = ["claude-code", "cursor", "cline"];
-var DEFAULT_LEAN_PROJECTION_HOSTS = ["claude-code"];
-function resolveLeanProjectionHosts(raw) {
-  const known = new Set(THINNABLE_HOSTS);
-  if (!Array.isArray(raw) || raw.length === 0) {
-    return { hosts: [...DEFAULT_LEAN_PROJECTION_HOSTS], dropped: [], usedDefault: true };
-  }
-  const hosts = [];
-  const dropped = [];
-  for (const entry of raw) {
-    const id = typeof entry === "string" ? entry.trim().toLowerCase() : "";
-    if (id === "") {
-      dropped.push({ id: String(entry), reason: "unknown" });
-      continue;
-    }
-    if (!known.has(id)) {
-      dropped.push({ id, reason: KNOWN_NON_THINNABLE_HOSTS.has(id) ? "not-thinnable" : "unknown" });
-      continue;
-    }
-    if (!hosts.includes(id)) hosts.push(id);
-  }
-  hosts.sort();
-  return { hosts, dropped, usedDefault: false };
-}
-var KNOWN_NON_THINNABLE_HOSTS = /* @__PURE__ */ new Set([
-  "claude-desktop",
-  "augment",
-  "copilot",
-  "windsurf",
-  "gemini",
-  "codex",
-  "cowork"
-]);
-function thinsHost(mode, hosts, hostId) {
-  return writesThinFiles(mode) && hosts.includes(hostId);
-}
-function resolveLeanProjection(opts = {}) {
-  const file = opts.settingsPath ?? path16.join(opts.projectRoot ?? process.cwd(), ".agent-settings.yml");
-  const tpl = opts.packageRoot == null ? null : path16.join(opts.packageRoot, "src", "config", "agent-settings.template.yml");
-  let lean;
-  try {
-    lean = load_agent_settings(
-      tpl === null ? { project_path: file } : { project_path: file, template_path: tpl }
-    )["lean_projection"];
-  } catch {
-  }
-  const obj = typeof lean === "object" && lean !== null && !Array.isArray(lean) ? lean : {};
-  const o = obj;
-  return {
-    mode: normalizeLeanProjectionMode(o["mode"] ?? ""),
-    hosts: resolveLeanProjectionHosts(o["hosts"]),
-    // LAZY, and the hot path is the reason. Provenance needs a SECOND,
-    // template-isolated cascade, and only the installer reads it — the
-    // delivery concern on `user_prompt_submit` destructures `{ mode, hosts }`
-    // and discards this field, so computing it eagerly doubled the per-prompt
-    // settings read for an answer nobody asked for. A getter keeps the
-    // field's shape (`readonly modeExplicit: boolean`) and charges only the
-    // caller that touches it.
-    get modeExplicit() {
-      return rawExplicitLeanProjectionMode(opts) !== "";
+// src/install/toolsArg.ts
+function mergeToolsAliases(tools, ai) {
+  const items = [];
+  for (const raw of [tools, ai]) {
+    if (!raw) continue;
+    for (const piece of raw.split(",")) {
+      const stripped = piece.trim();
+      if (stripped && !items.includes(stripped)) items.push(stripped);
     }
-  };
-}
-var NO_TEMPLATE_LAYER = path16.join(path16.sep, "dev", "null", "agent-config-absent-template.yml");
-function rawExplicitLeanProjectionMode(opts = {}) {
-  const file = opts.settingsPath ?? path16.join(opts.projectRoot ?? process.cwd(), ".agent-settings.yml");
-  let lean;
-  try {
-    lean = load_agent_settings({ project_path: file, template_path: NO_TEMPLATE_LAYER })["lean_projection"];
-  } catch {
-    return "";
   }
-  if (typeof lean !== "object" || lean === null || Array.isArray(lean)) return "";
-  const m = lean["mode"];
-  return typeof m === "string" ? m.trim() : "";
+  return items.length > 0 ? items.join(",") : "all";
 }
-function installerThinsHost(hostId, opts = {}) {
-  const { mode, hosts, modeExplicit } = resolveLeanProjection({
-    ...opts,
-    settingsPath: opts.settingsPath ?? NO_PROJECT_LAYER
-  });
-  return modeExplicit && thinsHost(mode, hosts.hosts, hostId);
-}
-var NO_PROJECT_LAYER = path16.join(
-  path16.sep,
-  "dev",
-  "null",
-  "agent-config-absent-project-settings.yml"
-);
 
 // src/shared/settingsSurface.ts
 function unwrapRef(root) {
@@ -4153,7 +4405,7 @@ var zodToJsonSchema = (schema, options) => {
 };
 
 // src/scripts/_lib/module_detection.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as path17 from "node:path";
 var _SKIP_DIRS = /* @__PURE__ */ new Set([".module-template", ".example"]);
 var _RULES = [
@@ -4168,14 +4420,14 @@ var _RULES = [
 ];
 function _isDir(p) {
   try {
-    return fs16.statSync(p).isDirectory();
+    return fs17.statSync(p).isDirectory();
   } catch {
     return false;
   }
 }
 function _isFile(p) {
   try {
-    return fs16.statSync(p).isFile();
+    return fs17.statSync(p).isFile();
   } catch {
     return false;
   }
@@ -4189,7 +4441,7 @@ function _isUpperChar(ch) {
 function _list_module_subdirs(root) {
   let entries;
   try {
-    entries = fs16.readdirSync(root).sort();
+    entries = fs17.readdirSync(root).sort();
   } catch {
     return [];
   }
@@ -4254,58 +4506,8 @@ function detect_module_roots(project_root) {
   return [...high, ...medium];
 }
 
-// src/scripts/_lib/model_tier.ts
-import fs17 from "node:fs";
-var TIER_TO_CLAUDE_MODEL = {
-  frontier: "fable",
-  high: "opus",
-  medium: "sonnet",
-  lite: "haiku"
-};
-var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
-function read_model_tier(skill_md) {
-  if (!fs17.existsSync(skill_md)) return null;
-  const text = fs17.readFileSync(skill_md).toString("utf-8");
-  if (!text.startsWith("---\n")) return null;
-  const end = text.indexOf("\n---\n", 4);
-  if (end === -1) return null;
-  const m = MODEL_TIER_RE.exec(text.slice(4, end));
-  return m ? m[1] : null;
-}
-function render_native_model_md(text, tier) {
-  const model = TIER_TO_CLAUDE_MODEL[tier];
-  if (model === void 0) {
-    throw new Error(`'${tier}'`);
-  }
-  return text.replace(MODEL_TIER_RE, `model: ${model}`);
-}
-
-// src/install/paths.ts
-import { homedir as homedir8, tmpdir } from "node:os";
-import { join as join18 } from "node:path";
-var INSTALL_ROOT_SUBPATH = ".event4u/agent-config";
-var INSTALL_LOG_FILENAME = "install-log.jsonl";
-function resolveHome(home) {
-  if (home && home.length > 0) {
-    return home;
-  }
-  const fromOs = homedir8();
-  if (!fromOs) {
-    throw new Error(
-      "Cannot resolve home directory \u2014 both $HOME (POSIX) and $USERPROFILE (Windows) are unset."
-    );
-  }
-  return fromOs;
-}
-function getInstallRoot(home) {
-  return join18(resolveHome(home), INSTALL_ROOT_SUBPATH);
-}
-function getLogPath(home) {
-  return join18(getInstallRoot(home), INSTALL_LOG_FILENAME);
-}
-
 // src/scripts/install.ts
-var _HERE = fileURLToPath3(import.meta.url);
+var _HERE = fileURLToPath2(import.meta.url);
 var SystemExitError = class extends Error {
   constructor(code) {
     super(`system-exit-${code}`);
@@ -4321,9 +4523,9 @@ var ArgparseExit = class extends Error {
   code;
 };
 function expanduser3(p) {
-  if (p === "~") return os7.homedir();
+  if (p === "~") return os8.homedir();
   if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path18.join(os7.homedir(), p.slice(2));
+    return path18.join(os8.homedir(), p.slice(2));
   }
   return p;
 }
@@ -4464,7 +4666,8 @@ var LEGACY_RENAME_MAP = {
 };
 var state = {
   QUIET: false,
-  PROGRESS_NDJSON: false
+  PROGRESS_NDJSON: false,
+  FULL_PIN: false
 };
 function _emit_progress(obj) {
   if (!state.PROGRESS_NDJSON) return;
@@ -4854,7 +5057,7 @@ function ensure_augment_bridge(project_root, force) {
     ".augment/settings.json"
   );
 }
-var AUGMENT_USER_DIR = path18.join(os7.homedir(), ".augment");
+var AUGMENT_USER_DIR = path18.join(os8.homedir(), ".augment");
 var AUGMENT_USER_HOOKS_DIR = path18.join(AUGMENT_USER_DIR, "hooks");
 var AUGMENT_DISPATCHER_TRAMPOLINE = "augment-dispatcher.sh";
 var AUGMENT_LEGACY_TRAMPOLINES = [
@@ -4955,7 +5158,7 @@ function ensure_cursor_bridge(project_root, force) {
     ".cursor/hooks.json"
   );
 }
-var CURSOR_USER_DIR = path18.join(os7.homedir(), ".cursor");
+var CURSOR_USER_DIR = path18.join(os8.homedir(), ".cursor");
 var CURSOR_USER_HOOKS_DIR = path18.join(CURSOR_USER_DIR, "hooks");
 var CURSOR_DISPATCHER_TRAMPOLINE = "cursor-dispatcher.sh";
 function ensure_cursor_user_hooks(package_root, force) {
@@ -5039,7 +5242,7 @@ function ensure_cline_bridge(project_root, force) {
     skip(".clinerules/hooks/ already up to date");
   }
 }
-var CLINE_USER_DIR = path18.join(os7.homedir(), "Documents", "Cline", "Hooks");
+var CLINE_USER_DIR = path18.join(os8.homedir(), "Documents", "Cline", "Hooks");
 var CLINE_DISPATCHER_TRAMPOLINE = "cline-dispatcher.sh";
 function ensure_cline_user_hooks(package_root, force) {
   const src = path18.join(package_root, "scripts", "hooks", CLINE_DISPATCHER_TRAMPOLINE);
@@ -5091,7 +5294,7 @@ function ensure_windsurf_bridge(project_root, force) {
     ".windsurf/hooks.json"
   );
 }
-var WINDSURF_USER_DIR = path18.join(os7.homedir(), ".codeium", "windsurf");
+var WINDSURF_USER_DIR = path18.join(os8.homedir(), ".codeium", "windsurf");
 var WINDSURF_USER_HOOKS_DIR = path18.join(WINDSURF_USER_DIR, "hooks");
 var WINDSURF_DISPATCHER_TRAMPOLINE = "windsurf-dispatcher.sh";
 function ensure_windsurf_user_hooks(package_root, force) {
@@ -5147,7 +5350,7 @@ function ensure_gemini_bridge(project_root, force) {
     ".gemini/settings.json"
   );
 }
-var GEMINI_USER_DIR = path18.join(os7.homedir(), ".gemini");
+var GEMINI_USER_DIR = path18.join(os8.homedir(), ".gemini");
 var GEMINI_USER_HOOKS_DIR = path18.join(GEMINI_USER_DIR, "hooks");
 var GEMINI_DISPATCHER_TRAMPOLINE = "gemini-dispatcher.sh";
 function ensure_gemini_user_hooks(package_root, force) {
@@ -5638,7 +5841,7 @@ To remove this marker, delete this file.
 `;
 }
 var _CLAUDE_DESKTOP_BUNDLES_SUBPATH = "claude-desktop/bundles";
-var GLOBAL_ROOT = path18.join(os7.homedir(), ".event4u", "agent-config");
+var GLOBAL_ROOT = path18.join(os8.homedir(), ".event4u", "agent-config");
 var GLOBAL_USER_SETTINGS_PATH = path18.join(GLOBAL_ROOT, ".agent-user.yml");
 var GLOBAL_AGENT_SETTINGS_PATH = path18.join(GLOBAL_ROOT, ".agent-settings.yml");
 function _bridge_marker(tool_id, scope) {
@@ -5910,7 +6113,7 @@ function _update_installed_tools_manifest(project_root, tools, scope, force, fil
       throw exc;
     }
   }
-  write_manifest(target, version, entries);
+  write_manifest(target, version, dropGlobalScopeFiles(entries, scope === "global" ? tools : /* @__PURE__ */ new Set()));
   if (!state.QUIET) {
     const rel = isRelativeTo(target, project_root) ? path18.relative(project_root, target) : target;
     info(`Manifest updated: ${rel}`);
@@ -6026,7 +6229,7 @@ function _run_migrate_to_global(project_root) {
   }
 }
 function _format_global_root_for_marker(global_root) {
-  const home = resolvePath(os7.homedir());
+  const home = resolvePath(os8.homedir());
   const resolved = resolvePath(global_root);
   const rel = path18.relative(home, resolved);
   if (rel === "" || rel.startsWith("..") || path18.isAbsolute(rel)) {
@@ -6182,7 +6385,7 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
       return [0, 0, written_paths];
     }
     mkdirp(path18.dirname(dest));
-    const decision = tracker.resolve(dest, force);
+    const decision = tracker.resolve(dest, force, { from: resolved_src, packageRoot: package_root });
     if (decision === "preserve") {
       tracker.preserve(dest, resolved_src, package_root);
       _log_tx_entry("skip", dest);
@@ -6245,7 +6448,7 @@ function _copy_dir_dereferencing_symlinks(src, dest, force, package_root = null,
     if (file_filter !== null && !file_filter(entry)) {
       continue;
     }
-    const decision = tracker.resolve(target, force);
+    const decision = tracker.resolve(target, force, { from: resolved, packageRoot: package_root });
     if (decision === "preserve") {
       tracker.preserve(target, resolved, package_root);
       skipped += 1;
@@ -6269,7 +6472,7 @@ function _write_claude_desktop_marker(force, lockfile_path2, bundles_dir, bundle
   const target = path18.join(anchor, "agent-config.md");
   mkdirp(anchor);
   const body = claudeDesktopMarkerBody(lockfile_path2, anchor, bundles_dir, bundle_count);
-  if (tracker.resolve(target, force) === "preserve") {
+  if (tracker.resolve(target, force, { content: body }) === "preserve") {
     tracker.preserveContent(target, body);
     return [0, 1, []];
   }
@@ -6282,12 +6485,8 @@ function _deploy_claude_desktop(force, package_root, lockfile_path2) {
   build_skill_bundles(package_root, bundles_dir, force);
   build_command_bundles(package_root, bundles_dir, force);
   const bundle_count = countZips(bundles_dir);
-  const [, , marker_paths] = _write_claude_desktop_marker(
-    force,
-    lockfile_path2,
-    bundles_dir,
-    bundle_count
-  );
+  const [, , marker_paths] = _write_claude_desktop_marker(force, lockfile_path2, bundles_dir, bundle_count);
+  recordGlobalDeploy({ toolId: "claude-desktop", anchorRaw: USER_SCOPE_PATHS["claude-desktop"], anchor: expanduser3(USER_SCOPE_PATHS["claude-desktop"]), currentFiles: /* @__PURE__ */ new Set(["agent-config.md"]), destSubs: [], packageTag: PACKAGE_TAG_ID, preserved: tracker.conflictState.preserved, staged: tracker.conflictState.staged, recordedFor: tracker.recordedDigest });
   return [bundle_count, 0, "deployed", [bundles_dir, ...marker_paths]];
 }
 var _CLAUDE_FLAT_WRAPPER_EXTRA = /* @__PURE__ */ new Set(["commit"]);
@@ -6390,20 +6589,19 @@ function _deploy_global_content(tools, force, package_root, lockfile_path2) {
         info,
         warn,
         res,
-        preserved_now
+        preserved_now,
+        onlyDeployed(anchor, current_files, (p) => _log_tx_entry("write", p))
       );
-      if (installerThinsHost(tool_id, { packageRoot: package_root })) {
-        try {
-          const thin = thinInstalledRuleLayer({
-            rulesDir: path18.join(anchor, "rules"),
-            packageRoot: package_root,
-            preserved: preserved_now
-          });
-          if (!state.QUIET) for (const l of describeThinInstalledLayer(thin)) info(l);
-        } catch (e) {
-          warn(`claude-code: thinned rule layer not written \u2014 ${String(e)}`);
-        }
-      }
+      deployClaudeCarrier({
+        packageRoot: package_root,
+        rulesDir: path18.join(anchor, "rules"),
+        quiet: state.QUIET,
+        info,
+        warn,
+        userPin: state.FULL_PIN,
+        wantsThin: installerThinsHost(tool_id, { packageRoot: package_root }),
+        thin: (bodyLinkRoot) => describeThinInstalledLayer(thinInstalledRuleLayer({ rulesDir: path18.join(anchor, "rules"), packageRoot: package_root, preserved: preserved_now, bodyLinkRoot, onWrite: onlyDeployed(anchor, current_files, (p) => _log_tx_entry("write", p)) }))
+      });
       if (!state.QUIET) for (const l of installReceiptBudgetLines(package_root, void 0, { thisDeploy: /* @__PURE__ */ new Map([[anchor, current_files]]) })) info(l);
     }
     const missing_targets = _verify_deploy_targets(anchor, plan);
@@ -6418,25 +6616,18 @@ function _deploy_global_content(tools, force, package_root, lockfile_path2) {
       continue;
     }
     _emit_progress({ type: "verified", tool: tool_id });
-    const inventory = load_inventory();
-    let reaped = [];
-    const inv_tools = inventory["tools"] ?? {};
-    if (tool_id in inv_tools) {
-      reaped = reaped.concat(
-        reap_stale(tool_id, anchor, current_files, inventory)
-      );
-    }
-    reaped = reaped.concat(
-      reap_tagged_orphans(
-        anchor,
-        plan.map(([, dest_sub]) => dest_sub),
-        current_files,
-        PACKAGE_TAG_ID
-      )
-    );
-    reaped = [...new Set(reaped)].sort();
-    record_deploy(tool_id, anchor_raw, current_files, inventory);
-    save_inventory(inventory);
+    const { reaped, retained } = recordGlobalDeploy({
+      toolId: tool_id,
+      anchorRaw: anchor_raw,
+      anchor,
+      currentFiles: current_files,
+      destSubs: plan.map(([, dest_sub]) => dest_sub),
+      packageTag: PACKAGE_TAG_ID,
+      preserved: tracker.conflictState.preserved,
+      staged: tracker.conflictState.staged,
+      recordedFor: tracker.recordedDigest
+    });
+    for (const p of retained) warn(retainedFileMessage(p));
     if (reaped.length > 0 && !state.QUIET) {
       info(
         `  ${tool_id}: reaped ${reaped.length} stale deployed file(s) from a previous install`
@@ -6509,7 +6700,9 @@ function _preview_global_reap(tools, package_root) {
         plan.map(([, dest_sub]) => dest_sub),
         current_files,
         PACKAGE_TAG_ID,
-        true
+        true,
+        // The ledger spares an edited retired file, so the preview must too.
+        recorded_digests(tool_id, anchor, inventory)
       )
     );
     const paths = [...new Set(would_reap.map((p) => String(p)))].sort();
@@ -6535,7 +6728,6 @@ function _verify_deploy_targets(anchor, plan) {
   }
   return missing;
 }
-var _prune_modules_by = prune_modules_by;
 var _prune_lab_modules = prune_lab_modules;
 var _load_packs_registry = load_packs_registry;
 var _compute_active_pack_ids = compute_active_pack_ids;
@@ -6574,12 +6766,7 @@ function _rule_filter_for_source(src_rel, scope) {
   if (src_rel !== RULE_SOURCE_REL) return null;
   return (srcFile) => ruleFileArrives(srcFile, scope) && !isExclusivelyPackageOnly(srcFile);
 }
-function _prune_scoped_modules(deploy_results, active_ids) {
-  return _prune_modules_by(
-    deploy_results,
-    (p) => is_pruned_under_scoped(p, active_ids)
-  );
-}
+var _prune_scoped_modules = prune_scoped_modules;
 function install_global(tools, force, project_root = null, core_only = false) {
   const migrated = migrate_legacy_namespace();
   if (migrated && !state.QUIET) {
@@ -6657,13 +6844,6 @@ function install_global(tools, force, project_root = null, core_only = false) {
   }
   try {
     const { mode, active_packs } = _resolve_scoped_projection(package_root);
-    if (mode === "tiered") {
-      const outcome = applyTieredPrune(deploy_results, package_root, _prune_modules_by);
-      deploy_results = outcome.deployResults;
-      if (!state.QUIET && outcome.message !== null) {
-        (outcome.level === "warn" ? warn : info)(outcome.message);
-      }
-    }
     if (mode === "scoped") {
       const packs_registry = _load_packs_registry(package_root);
       const active_ids = _compute_active_pack_ids(packs_registry, active_packs);
@@ -6680,6 +6860,7 @@ function install_global(tools, force, project_root = null, core_only = false) {
       warn(`Scoped-projection prune failed \u2014 restoring full tree (${String(e)}).`);
     }
   }
+  applyHostListingPolicies({ claudeCode: deploy_results["claude-code"]?.[2] === "deployed", codex: deploy_results["codex"]?.[2] === "deployed" }, os8.homedir(), expanduser3(USER_SCOPE_PATHS["claude-code"]), state.QUIET ? () => void 0 : info);
   const failed_tools = new Set(
     Object.keys(deploy_results).filter(
       (tool_id) => deploy_results[tool_id][2] === "deploy_failed"
@@ -6889,17 +7070,6 @@ function _write_settings_surface_snapshot(installed_version) {
 function arrayStrEqual(a, b) {
   return a.length === b.length && a.every((v, i) => v === b[i]);
 }
-function _merge_tools_aliases(tools, ai) {
-  const items = [];
-  for (const raw of [tools, ai]) {
-    if (!raw) continue;
-    for (const piece of raw.split(",")) {
-      const stripped = piece.trim();
-      if (stripped && !items.includes(stripped)) items.push(stripped);
-    }
-  }
-  return items.length > 0 ? items.join(",") : "all";
-}
 var PROG = "agent-config install";
 var USAGE = `usage: ${PROG} [-h] [--profile PROFILE] [--user-type USER_TYPE] [--force]
                   [--skip-bridges] [--augment-user-hooks]
@@ -6907,7 +7077,7 @@ var USAGE = `usage: ${PROG} [-h] [--profile PROFILE] [--user-type USER_TYPE] [--
                   [--windsurf-user-hooks] [--gemini-user-hooks]
                   [--project PROJECT] [--package PACKAGE] [--quiet]
                   [--tools TOOLS] [--ai AI] [--packs PACKS] [--core-only]
-                  [--no-smoke] [--global]
+                  [--no-smoke] [--global] [--full]
                   [--scope {project,global,prompt,auto}]
                   [--layer {global,project,both-acknowledged}]
                   [--custom-path CUSTOM_PATH] [--offline] [--minimal]
@@ -6931,7 +7101,8 @@ var _STORE_TRUE_FLAGS = {
   "--settings-only": "minimal",
   "--interactive": "interactive",
   "--no-ui": "no_ui",
-  "--dry-run": "dry_run"
+  "--dry-run": "dry_run",
+  "--full": "full"
 };
 var _VALUE_FLAGS = {
   "--profile": "profile",
@@ -6979,6 +7150,7 @@ function parse_options(argv) {
     interactive: false,
     no_ui: false,
     dry_run: false,
+    full: false,
     apply_payload: null,
     layer: null
   };
@@ -7035,7 +7207,7 @@ function parse_options(argv) {
   if (positionals.length > 0) {
     _argError(`unrecognized arguments: ${positionals.join(" ")}`);
   }
-  opts.tools = _merge_tools_aliases(opts.tools, opts.ai);
+  opts.tools = mergeToolsAliases(opts.tools, opts.ai);
   const rawPacks = opts.packs;
   opts.packs = typeof rawPacks === "string" ? rawPacks.split(",").map((p) => p.trim()).filter((p) => p) : [];
   if (opts.scope === "global" && opts.custom_path) {
@@ -7310,7 +7482,7 @@ function _wizard_cli_dist(_project_root) {
   return pathExists(cli) ? cli : null;
 }
 function _server_info_path() {
-  return path18.join(os7.homedir(), ".event4u", "agent-config", "local-server.json");
+  return path18.join(os8.homedir(), ".event4u", "agent-config", "local-server.json");
 }
 function _pid_is_agent_config(pid) {
   let res;
@@ -7406,7 +7578,7 @@ function _wizard_spawn(project_root, pass_project_root = true) {
 function _wizard_run_sync(cmd, env, cli) {
   const total = _WIZARD_TIMEOUTS.reduce((a, b) => a + b, 0);
   const log_path = path18.join(
-    os7.tmpdir(),
+    os8.tmpdir(),
     `agent-config-wizard-${process2.pid}-${Date.now()}.log`
   );
   let child;
@@ -7500,8 +7672,7 @@ function _dry_run_summary(opts) {
 `);
   process2.stdout.write(`  tools:       ${opts.tools || "all"}
 `);
-  process2.stdout.write(`  target:      ${target}
-`);
+  process2.stdout.write(dryRunTargetLines(Boolean(opts.global_install) || opts.scope === "global", _parse_tools(opts.tools || "all"), target));
   process2.stdout.write(`  minimal:     ${pyBool(opts.minimal)}
 `);
   process2.stdout.write(`  force:       ${pyBool(opts.force)}
@@ -7598,6 +7769,7 @@ function pyRepr(v) {
 function main2(argv) {
   const opts = parse_options(argv);
   state.QUIET = opts.quiet;
+  state.FULL_PIN = opts.full || _legacy_projection_pin();
   if (opts.apply_payload) {
     const payload_path = resolvePath(opts.apply_payload);
     if (!isFile(payload_path)) fail(`--apply-payload path not found: ${payload_path}`);
@@ -7755,6 +7927,15 @@ function _propose_modules_config(project_root, is_first_run) {
     "Re-run anytime via `./scripts-run src/scripts/propose_modules_config` (installed under <package>/src/scripts/)."
   );
 }
+var _ABSENT_LAYER = ["project-settings", "template"].map((n) => path18.join(path18.sep, "dev", "null", `agent-config-absent-${n}.yml`));
+function _legacy_projection_pin() {
+  let data = null;
+  try {
+    data = load_agent_settings({ project_path: _ABSENT_LAYER[0], template_path: _ABSENT_LAYER[1] });
+  } catch {
+  }
+  return legacyProjectionPin(data, (line) => warn(line));
+}
 function _read_consumer_auto_switch(project_root) {
   let data;
   try {
@@ -7987,6 +8168,11 @@ if (_isCliEntry || _argv1 === _HERE) {
 
 export {
   subtract_pointers,
+  recordPath,
+  codexSkillRoots,
+  removeCodexResidentSet,
+  recordPath2,
+  removeListingOverrides,
   SETTINGS_FILE,
   ROOCODE_MARKER,
   CLAUDE_DESKTOP_MARKER,