@amsterdamdatalabs/enact-extensions 0.1.47 → 0.1.49

package/scripts/lib/build-index.mjs

@@ -25,9 +25,7 @@ export function buildIndex(roots, opts = {}) {
   const { now = null, packageRoot } = opts;
 
   // Resolve package root: two levels up from this file (scripts/lib/ → repo root)
-  const pkgRoot =
-    packageRoot ??
-    new URL("../../", import.meta.url).pathname.replace(/\/$/, "");
+  const pkgRoot = packageRoot ?? new URL("../../", import.meta.url).pathname.replace(/\/$/, "");
 
   // Source bundles via the canonical list-bundles helper (deduplicated, resilient).
   const entries = listBundles(roots);

package/scripts/lib/resolve-bundle.mjs

@@ -115,7 +115,5 @@ export function resolveBundlePath(arg, opts = {}) {
   // --- Rule 3: nothing found ---
   const uniqueCandidates = [...new Set(candidates)];
   const candidateList = uniqueCandidates.map((c) => `  - ${c}`).join("\n");
-  throw new Error(
-    `Plugin "${arg}" not found. Looked in:\n${candidateList}\nPass an explicit path instead.`,
-  );
+  throw new Error(`Plugin "${arg}" not found. Looked in:\n${candidateList}\nPass an explicit path instead.`);
 }

package/scripts/lib/run-repo-doctor.mjs

@@ -44,21 +44,22 @@
  * version, host trust/approval notes, hookDoctor unavailability, a stale
  * `.agents/enact-repo.toml`) is informational.
  */
+
+import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, lstatSync, readFileSync, readlinkSync } from "node:fs";
-import { spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import * as TOML from "@iarna/toml";
 import { entryPresent, findBlock } from "../../dist/index.js";
 import {
-  CONFIG_PATH,
-  HOOK_LOG_FILES,
-  REPO_HOSTS,
   abs,
   buildPlan,
+  CONFIG_PATH,
   fileSha,
+  HOOK_LOG_FILES,
   lockRel,
+  REPO_HOSTS,
   readBundle,
   readJsonStrict,
   readLock,
@@ -76,7 +77,16 @@ const REQUIRED_BINARIES = ["enact-hook", "lean-ctx", "azure-devops-mcp"];
 // global `enact-hook` runtime, never by this package; reported read-only.
 const [DENY_LOG_REL, ACTIVITY_LOG_REL] = HOOK_LOG_FILES;
 const DENY_LOG_COLUMNS = ["timestamp", "surface", "reason_id", "command", "agent_message"];
-const ACTIVITY_LOG_COLUMNS = [...DENY_LOG_COLUMNS, "host", "kind", "event", "tool", "session", "downstream", "duration_ms"];
+const ACTIVITY_LOG_COLUMNS = [
+  ...DENY_LOG_COLUMNS,
+  "host",
+  "kind",
+  "event",
+  "tool",
+  "session",
+  "downstream",
+  "duration_ms",
+];
 const DENY_LOG_LAST_ROWS = 5;
 
 // ---------------------------------------------------------------------------
@@ -118,10 +128,15 @@ function checkCodexTrust(repo, home) {
   try {
     doc = TOML.parse(readFileSync(configPath, "utf8"));
   } catch (err) {
-    return { configFound: true, trustLevel: null, note: `cannot parse ${configPath}: ${err instanceof Error ? err.message : String(err)}` };
+    return {
+      configFound: true,
+      trustLevel: null,
+      note: `cannot parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`,
+    };
   }
   const entry = doc.projects && typeof doc.projects === "object" ? doc.projects[repo] : undefined;
-  const trustLevel = entry && typeof entry === "object" && typeof entry.trust_level === "string" ? entry.trust_level : null;
+  const trustLevel =
+    entry && typeof entry === "object" && typeof entry.trust_level === "string" ? entry.trust_level : null;
   return {
     configFound: true,
     trustLevel,
@@ -176,14 +191,18 @@ function checkKimiWorkspaceTrust(repo) {
     return {
       trusted: false,
       recordPath,
-      note: untrustedNote(`trust record at ${recordPath} is malformed JSON (${err instanceof Error ? err.message : String(err)})`),
+      note: untrustedNote(
+        `trust record at ${recordPath} is malformed JSON (${err instanceof Error ? err.message : String(err)})`,
+      ),
     };
   }
   if (!record || record.root !== repo) {
     return {
       trusted: false,
       recordPath,
-      note: untrustedNote(`trust record at ${recordPath} is for a different root (${record?.root ?? "(none)"}), not ${repo}`),
+      note: untrustedNote(
+        `trust record at ${recordPath} is for a different root (${record?.root ?? "(none)"}), not ${repo}`,
+      ),
     };
   }
   return { trusted: true, recordPath, trustedAt: record.trustedAt ?? null };
@@ -248,7 +267,9 @@ function readHookLogSummary(repo, rel, columns, lastN) {
   if (!existsSync(path)) return { path: rel, exists: false, rowCount: 0, lastRows: [] };
   const rows = parseCsvRows(readFileSync(path, "utf8"));
   const lastRows =
-    lastN > 0 ? rows.slice(-lastN).map((cols) => Object.fromEntries(columns.map((name, i) => [name, cols[i] ?? ""]))) : [];
+    lastN > 0
+      ? rows.slice(-lastN).map((cols) => Object.fromEntries(columns.map((name, i) => [name, cols[i] ?? ""])))
+      : [];
   return { path: rel, exists: true, rowCount: rows.length, lastRows };
 }
 
@@ -358,7 +379,9 @@ function checkHosts(repo, lock, home, contentOutdated) {
   for (const host of REPO_HOSTS) {
     const targeted = lock.hosts.includes(host);
     if (host === "claude") {
-      const present = !targeted || (existsSync(abs(repo, ".claude-plugin/marketplace.json")) && existsSync(abs(repo, ".claude/settings.json")));
+      const present =
+        !targeted ||
+        (existsSync(abs(repo, ".claude-plugin/marketplace.json")) && existsSync(abs(repo, ".claude/settings.json")));
       hosts.claude = {
         targeted,
         present,
@@ -367,7 +390,8 @@ function checkHosts(repo, lock, home, contentOutdated) {
           : "not targeted by this install",
       };
     } else if (host === "codex") {
-      const present = !targeted || existsSync(abs(repo, ".codex/hooks.json")) || existsSync(abs(repo, ".codex/config.toml"));
+      const present =
+        !targeted || existsSync(abs(repo, ".codex/hooks.json")) || existsSync(abs(repo, ".codex/config.toml"));
       hosts.codex = {
         targeted,
         present,
@@ -377,7 +401,8 @@ function checkHosts(repo, lock, home, contentOutdated) {
           : "not targeted by this install",
       };
     } else if (host === "cursor") {
-      const present = !targeted || existsSync(abs(repo, ".cursor/hooks.json")) || existsSync(abs(repo, ".cursor/mcp.json"));
+      const present =
+        !targeted || existsSync(abs(repo, ".cursor/hooks.json")) || existsSync(abs(repo, ".cursor/mcp.json"));
       hosts.cursor = {
         targeted,
         present,
@@ -407,7 +432,9 @@ function checkHosts(repo, lock, home, contentOutdated) {
         targeted,
         present,
         generatedFromCurrentBundle,
-        note: targeted ? "one generated plugin file; re-run install after a bundle update to regenerate it" : "not targeted by this install",
+        note: targeted
+          ? "one generated plugin file; re-run install after a bundle update to regenerate it"
+          : "not targeted by this install",
       };
     }
   }
@@ -447,7 +474,9 @@ function checkMarker(repo) {
   // enact-hook-managed, and its sub-tables are the declared extension set.
   const extensionsPresent = doc.extensions !== undefined;
   const declared = extensionsPresent
-    ? Object.entries(doc.extensions).filter(([, v]) => v && typeof v === "object" && !Array.isArray(v)).map(([k]) => k)
+    ? Object.entries(doc.extensions)
+        .filter(([, v]) => v && typeof v === "object" && !Array.isArray(v))
+        .map(([k]) => k)
     : [];
   return {
     ...base,
@@ -466,7 +495,9 @@ function checkStaleMarker(repo) {
   return {
     path: STALE_MARKER_PATH,
     present,
-    note: present ? `stale leftover from the pre-${CONFIG_PATH} installer; nothing reads it -- safe to delete` : undefined,
+    note: present
+      ? `stale leftover from the pre-${CONFIG_PATH} installer; nothing reads it -- safe to delete`
+      : undefined,
   };
 }
 
@@ -489,7 +520,9 @@ export function runRepoDoctor(pluginRoot, options = {}) {
       name,
       repo,
       installed: false,
-      problems: [`${name} is not installed in ${repo} (no ${lockRel(name)}) -- install with: enact-extensions install ${name} --repo ${repo}`],
+      problems: [
+        `${name} is not installed in ${repo} (no ${lockRel(name)}) -- install with: enact-extensions install ${name} --repo ${repo}`,
+      ],
       exitCode: 1,
     };
   }

package/scripts/lib/run-repo-install.mjs

@@ -71,55 +71,50 @@ import { createHash } from "node:crypto";
 import {
   existsSync,
   lstatSync,
-  mkdirSync,
   mkdtempSync,
-  readFileSync,
   readdirSync,
+  readFileSync,
   readlinkSync,
   realpathSync,
   rmSync,
-  rmdirSync,
   statSync,
-  symlinkSync,
-  writeFileSync,
 } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import * as TOML from "@iarna/toml";
 import {
   applyHostFlagToHooksDoc,
   assertSupportedHookEvents,
   clampHookTimeoutsForHost,
-  deriveOpenCodePlugin,
-  materializeCodexSkillMetadata,
-  MANIFEST_BY_PLATFORM,
-  EXTENSIONS_BLOCK,
-  blockMarkers,
+  cutBlock,
   cutExtensionsBlock,
+  cutLegacySkillsBlock,
   declaredExtensionsFrom,
-  extensionBlock,
-  removeExtensionBlock,
-  upsertExtensionBlock,
-  cutBlock,
+  declareExtension,
+  deriveOpenCodePlugin,
+  EXTENSIONS_BLOCK,
   ensureContainer,
+  entryPresent,
   extractTomlTable,
   findBlock,
+  getAt,
+  MANIFEST_BY_PLATFORM,
   makeFileOps,
+  materializeCodexSkillMetadata,
+  pathKey,
+  projectClaudePluginRoot,
+  projectCursorHooks,
+  projectPluginRoot,
   reinsertTomlSpans,
+  removeExtensionBlock,
+  removeJsonEntries,
   renderTomlBlock,
   siblingOwnersOf,
   siblingOwnsPrefix,
   siblingRecordsJsonEntry,
-  entryPresent,
-  getAt,
-  pathKey,
-  removeJsonEntries,
-  valueHash,
-  projectClaudePluginRoot,
-  projectPluginRoot,
-  projectCursorHooks,
   unmappedCursorHookEvents,
   unmappedCursorHookMatchers,
+  valueHash,
 } from "../../dist/index.js";
 
 export const REPO_HOSTS = ["claude", "codex", "cursor", "kimi", "opencode"];
@@ -140,8 +135,8 @@ export function readDeclaredExtensions(configText) {
 // Shared repo config at the repo root; its presence marks a repo as managed
 // (enact-hook's contract). One owner per root table: enact-hook owns
 // `version`/[hooks]/[rules]/[repo], enact-repo-controls owns [controls], this
-// package owns [skills]. We never parse or rewrite anyone else's table: the
-// [skills] block is appended once at text level and cut at text level.
+// package owns [extensions]. We never parse or rewrite anyone else's table:
+// the [extensions] block is appended once at text level and cut at text level.
 export const CONFIG_PATH = "enact-config.toml";
 const GITIGNORE_PATH = ".agents/.gitignore";
 // The global `enact-hook` runtime (not this installer) writes two per-repo
@@ -204,7 +199,13 @@ const GITIGNORE_LINES = [
 // package-lock.json\nbun.lock\n.gitignore"). We never write these
 // ourselves; `--purge` removes them ONLY when nothing else user-owned
 // remains under `.opencode/` (besides our own now-removed `plugins/*.ts`).
-const OPENCODE_AUTOGEN_ENTRIES = new Set(["node_modules", "package.json", "package-lock.json", "bun.lock", ".gitignore"]);
+const OPENCODE_AUTOGEN_ENTRIES = new Set([
+  "node_modules",
+  "package.json",
+  "package-lock.json",
+  "bun.lock",
+  ".gitignore",
+]);
 // ONE marketplace per repo, listing every installed plugin -- not one per
 // plugin. A marketplace.json carries exactly one `name` field, so per-plugin
 // names cannot coexist in it; the previous `<plugin>-local` scheme meant the
@@ -225,7 +226,7 @@ const CONFIG_ROOT_CONTENT = "version = 1\n";
 // ---------------------------------------------------------------------------
 
 export const sha256 = (data) => createHash("sha256").update(data).digest("hex");
-const has = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+const has = (obj, key) => Object.hasOwn(obj, key);
 
 export const abs = (repo, rel) => join(repo, ...rel.split("/"));
 
@@ -258,7 +259,11 @@ function serializeJson(doc, format) {
 }
 
 function sortObject(obj) {
-  return Object.fromEntries(Object.keys(obj).sort().map((k) => [k, obj[k]]));
+  return Object.fromEntries(
+    Object.keys(obj)
+      .sort()
+      .map((k) => [k, obj[k]]),
+  );
 }
 
 // Drop empty per-rel entries before persisting `displaced` to the lock.
@@ -274,6 +279,35 @@ function pruneDisplaced(displaced) {
 // repo + bundle resolution
 // ---------------------------------------------------------------------------
 
+/**
+ * Every real path this process could reasonably mean by "the home directory".
+ *
+ * `os.homedir()` alone is not enough, because runtimes disagree about it.
+ * Measured: node 26 resolves it from `$HOME` on POSIX, bun 1.4.2 does NOT --
+ * after `process.env.HOME = "/tmp/pretend-home"`, node reports the override and
+ * bun still reports the real account home. So a guard reading only `homedir()`
+ * quietly stops matching wherever HOME is overridden: CI images, containers,
+ * `sudo -E`, and this repo's own test suite.
+ *
+ * Refusing all of the candidates is strictly safer than betting on one of them,
+ * and makes the guard mean the same thing on every runtime.
+ */
+function homeDirectories() {
+  const found = new Set();
+  for (const candidate of [homedir(), process.env.HOME, process.env.USERPROFILE]) {
+    if (typeof candidate !== "string" || candidate === "") continue;
+    found.add(resolve(candidate));
+    try {
+      found.add(realpathSync(candidate));
+    } catch {
+      // A HOME that does not resolve cannot be the directory being installed
+      // into -- `repo` is realpath'd above, so it always exists. Nothing is
+      // being suppressed here: the candidate simply cannot match.
+    }
+  }
+  return found;
+}
+
 export function resolveRepoRoot(repoArg) {
   if (!repoArg || typeof repoArg !== "string") {
     throw new Error("--repo <path> is required for a repo-local install");
@@ -282,7 +316,7 @@ export function resolveRepoRoot(repoArg) {
     throw new Error(`--repo ${repoArg} is not a directory`);
   }
   const repo = realpathSync(resolve(repoArg));
-  if (repo === realpathSync(homedir())) {
+  if (homeDirectories().has(repo)) {
     throw new Error(`--repo ${repoArg} is the home directory; repo-local installs must target a git repository root`);
   }
   // Filesystem check, deliberately NOT `git rev-parse --show-toplevel`. A
@@ -302,7 +336,14 @@ export function resolveRepoRoot(repoArg) {
 export function parseRepoHosts(host, manifest) {
   const targets = Array.isArray(manifest.targets) ? manifest.targets : REPO_HOSTS;
   if (!host) return REPO_HOSTS.filter((h) => targets.includes(h));
-  const parts = [...new Set(String(host).split(",").map((p) => p.trim()).filter(Boolean))];
+  const parts = [
+    ...new Set(
+      String(host)
+        .split(",")
+        .map((p) => p.trim())
+        .filter(Boolean),
+    ),
+  ];
   for (const part of parts) {
     if (!REPO_HOSTS.includes(part)) {
       throw new Error(`Unknown repo host: "${part}". Valid: ${REPO_HOSTS.join(", ")}`);
@@ -415,7 +456,6 @@ function addSharedSkills(plan, bundle, codexPolicy) {
   });
 }
 
-
 // Project a self-contained plugin root for a host that has a plugin format,
 // and stage it into the plan. Every such host namespaces a plugin's skills by
 // the plugin name, which is what lets two extensions ship the same skill name
@@ -605,7 +645,7 @@ export function buildPlan(pluginRoot, bundle, hosts, repo) {
   plan.gitignore.set(GITIGNORE_PATH, GITIGNORE_LINES);
   const leanCtxConfig = addLeanCtxConfig(plan, pluginRoot);
 
-  // The repo's DECLARED extension set, from `[skills].extensions`. Installing a
+  // The repo's DECLARED extension set, from the `[extensions.<name>]` tables. Installing a
   // plugin declares it: the file is the user-editable statement of what this
   // repo should have, and install reconciles the repo to it. Order is stable
   // (declaration order, ours appended last) so regenerating the marketplace
@@ -764,9 +804,9 @@ function removeManagedGitignoreLines(repo, rel, ginfo, ops) {
 }
 
 // ---------------------------------------------------------------------------
-// enact-config.toml [skills] — text-level only. The document is parsed solely
-// to refuse invalid TOML and to learn whether OUR `skills` key exists; no other
-// table is read, and the document is never re-serialized.
+// enact-config.toml [extensions] — text-level only. The document is parsed
+// solely to refuse invalid TOML and to learn which extensions are declared; no
+// other table is read, and the document is never re-serialized.
 // ---------------------------------------------------------------------------
 
 function parseConfigText(text, action) {
@@ -815,7 +855,9 @@ function purgeOpenCodeAutogenIfClean(repo, ops) {
   }
   for (const e of entries) ops.removeDir(`.opencode/${e}`, "OpenCode auto-generated file (--purge)");
   ops.rmdirIfEmpty(".opencode");
-  console.log("purged .opencode/ auto-generated files (node_modules/package.json/package-lock.json/bun.lock/.gitignore -- matched OpenCode's own auto-generated shape, nothing else present)");
+  console.log(
+    "purged .opencode/ auto-generated files (node_modules/package.json/package-lock.json/bun.lock/.gitignore -- matched OpenCode's own auto-generated shape, nothing else present)",
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -861,7 +903,13 @@ export function runRepoInstall(pluginRoot, options = {}) {
   // -- preflight: enact-config.toml must be valid TOML before we append to it
   const configExists = existsSync(abs(repo, CONFIG_PATH));
   const configText = configExists ? readFileSync(abs(repo, CONFIG_PATH), "utf8") : null;
-  const configHasExtensions = configExists && parseConfigText(configText, "refusing to append [extensions]").extensions !== undefined;
+  const configHasExtensions =
+    configExists && parseConfigText(configText, "refusing to append [extensions]").extensions !== undefined;
+  // -- preflight: the legacy `[skills]` marker is cut here, not carried. It
+  // refuses rather than guesses when the table is not the one install wrote,
+  // and it runs BEFORE any file is touched so a refusal leaves the repo
+  // untouched instead of half-installed.
+  const configLegacyCut = configExists ? cutLegacySkillsBlock(configText) : null;
 
   // -- preflight: skills never overwrite a USER-AUTHORED skill dir (not even
   // with --force). A dir owned by THIS plugin, or by any SIBLING plugin
@@ -900,6 +948,13 @@ export function runRepoInstall(pluginRoot, options = {}) {
   // it here would report a real collision with useless advice ("rename one").
   const SHARED_CONTENT_EXEMPT = new Set([".claude-plugin/marketplace.json"]);
   const divergent = [];
+  // Every repo-relative path this run changed, in write order. Declared HERE
+  // rather than beside the other `-- apply` locals because the stale-symlink
+  // sweep below already pushes to it, and that sweep has to run before any file
+  // is written. `const` further down put this in its temporal dead zone, so the
+  // sweep threw `Cannot access 'written' before initialization` on exactly the
+  // runs where it had a symlink to drop -- see install-stale-symlink-crash.test.mjs.
+  const written = [];
   // BEFORE any file is written: drop a recorded symlink that is no longer in
   // the plan. A managed directory that is still a symlink from an earlier
   // layout would otherwise be FOLLOWED by the writes below -- the skills a
@@ -1020,16 +1075,19 @@ export function runRepoInstall(pluginRoot, options = {}) {
 
   const problems = [];
   if (edited.length > 0) {
-    problems.push(`Managed content was edited since the last install (re-run with --force to overwrite):\n  ${edited.join("\n  ")}`);
+    problems.push(
+      `Managed content was edited since the last install (re-run with --force to overwrite):\n  ${edited.join("\n  ")}`,
+    );
   }
   if (conflicts.length > 0) {
-    problems.push(`Conflict with existing entries not owned by ${bundle.name} (re-run with --force to take them over):\n  ${conflicts.join("\n  ")}`);
+    problems.push(
+      `Conflict with existing entries not owned by ${bundle.name} (re-run with --force to take them over):\n  ${conflicts.join("\n  ")}`,
+    );
   }
   if (problems.length > 0 && !force) throw new Error(problems.join("\n"));
 
   // -- apply
   const createdDirs = prev.createdDirs.filter((d) => existsSync(abs(repo, d)));
-  const written = [];
   const writeRepoFile = (rel, content, reason) => {
     replaceSymlinkAncestors(repo, rel, ops);
     recordMissingDirs(repo, rel, createdDirs);
@@ -1255,19 +1313,25 @@ export function runRepoInstall(pluginRoot, options = {}) {
   let config;
   {
     let text;
+    // The legacy `[skills]` table is already gone from `base` when one was
+    // present; `configText` stays the ORIGINAL so the "did anything change"
+    // comparison below still sees the cut.
+    const base = configLegacyCut ?? configText;
     if (!configExists) {
       const appended = `\n${EXTENSIONS_BLOCK}`;
       text = `${CONFIG_ROOT_CONTENT}${appended}`;
       config = { created: true, appended };
     } else if (!configHasExtensions) {
-      const appended = `${configText.length === 0 ? "" : configText.endsWith("\n") ? "\n" : "\n\n"}${EXTENSIONS_BLOCK}`;
-      text = `${configText}${appended}`;
+      const appended = `${base.length === 0 ? "" : base.endsWith("\n") ? "\n" : "\n\n"}${EXTENSIONS_BLOCK}`;
+      text = `${base}${appended}`;
       config = { created: prev.config?.created ?? false, appended };
     } else {
-      text = configText;
+      text = base;
       config = prev.config ?? { created: false, appended: null };
     }
-    const declared = upsertExtensionBlock(text, bundle.name, bundle.version);
+    // Insert-once: null means already declared (or no [extensions] to write
+    // into), and an existing declaration is never rewritten -- see declareExtension.
+    const declared = declareExtension(text, bundle.name, bundle.version);
     if (declared !== null) text = declared;
     if (text !== configText) {
       parseConfigText(text, "refusing to write invalid TOML");
@@ -1296,9 +1360,7 @@ export function runRepoInstall(pluginRoot, options = {}) {
   const tag = dryRun ? "[dry-run] " : "";
   console.log(`${tag}repo install ${bundle.name}@${bundle.version} -> ${repo} (hosts: ${hosts.join(", ")})`);
   console.log(
-    written.length > 0
-      ? `${dryRun ? "would change" : "changed"} ${written.length} file(s)`
-      : "up to date (no changes)",
+    written.length > 0 ? `${dryRun ? "would change" : "changed"} ${written.length} file(s)` : "up to date (no changes)",
   );
   // Live-testing finding (2026-09-14): even after trusting the folder, hooks
   // and skills were observed NOT active in the very FIRST Claude Code
@@ -1314,8 +1376,10 @@ export function runRepoInstall(pluginRoot, options = {}) {
       "claude: the plugin loads after you trust this folder in Claude Code -- if hooks/skills are missing in that FIRST session, start a NEW Claude Code session in this folder (the marketplace registers on first launch; the second session has it active)",
     );
   }
-  if (hosts.includes("codex")) console.log("codex: config and hooks load after you trust this project and review hooks (/hooks)");
-  if (hosts.includes("kimi")) console.log("kimi: hooks are global-only (installed by enact-vps); no repo hook file written");
+  if (hosts.includes("codex"))
+    console.log("codex: config and hooks load after you trust this project and review hooks (/hooks)");
+  if (hosts.includes("kimi"))
+    console.log("kimi: hooks are global-only (installed by enact-vps); no repo hook file written");
   return { repo, name: bundle.name, version: bundle.version, hosts, changed: written, actions, dryRun };
 }
 
@@ -1339,7 +1403,6 @@ export function runRepoUninstall(name, options = {}) {
   // surviving entries have to be read while they still exist.
   const uninstallConfigPath = abs(repo, CONFIG_PATH);
   const uninstallConfigText = existsSync(uninstallConfigPath) ? readFileSync(uninstallConfigPath, "utf8") : "";
-  const remainingExtensions = readDeclaredExtensions(uninstallConfigText).filter((n) => n !== name);
   const survivingMarketplace = (() => {
     const p = abs(repo, MARKETPLACE_PATH);
     if (!existsSync(p)) return null;
@@ -1391,7 +1454,7 @@ export function runRepoUninstall(name, options = {}) {
     const found = existsSync(path) ? findBlock(readFileSync(path, "utf8"), name) : null;
     if (!found || sha256(found.block) !== record.sha256) edited.push(rel);
   }
-  // --purge cuts our [skills] block from enact-config.toml; plan it up front so
+  // --purge cuts our [extensions] block from enact-config.toml; plan it up front so
   // an edited block is refused like any other edited managed content.
   let configCut = null;
   if (options.purge && typeof lock.config?.appended === "string" && existsSync(abs(repo, CONFIG_PATH))) {
@@ -1400,7 +1463,9 @@ export function runRepoUninstall(name, options = {}) {
     if (configCut === null) edited.push(`${CONFIG_PATH} ([extensions] block edited since install)`);
   }
   if (edited.length > 0 && !force) {
-    throw new Error(`Managed content was edited since install (re-run with --force to remove anyway):\n  ${edited.join("\n  ")}`);
+    throw new Error(
+      `Managed content was edited since install (re-run with --force to remove anyway):\n  ${edited.join("\n  ")}`,
+    );
   }
 
   // Originals displaced by a --force takeover during install; restored below
@@ -1512,7 +1577,10 @@ export function runRepoUninstall(name, options = {}) {
     const presentRuntimePaths = [...presentRuntimeDirs, ...presentHookLogFiles];
     retainedGitignore = !options.purge && presentRuntimePaths.length > 0;
     if (retainedGitignore) {
-      const kept = [GITIGNORE_PATH, ...(typeof lock.config?.appended === "string" ? [`${CONFIG_PATH} [skills]`] : [])];
+      const kept = [
+        GITIGNORE_PATH,
+        ...(typeof lock.config?.appended === "string" ? [`${CONFIG_PATH} [extensions]`] : []),
+      ];
       console.log(
         `kept ${kept.join(" and ")} -- lean-ctx runtime dirs / enact-hook log files still present (${presentRuntimePaths.join(", ")}); re-run uninstall --purge to remove them too`,
       );
@@ -1556,20 +1624,24 @@ export function runRepoUninstall(name, options = {}) {
       createdDirs: lock.createdDirs,
       displaced: { files: {}, json: {}, toml: {} },
     };
-    ops.write(lockRel(name), `${JSON.stringify(residual, null, 2)}\n`, "residual lock (gitignore/config retained pending --purge)");
+    ops.write(
+      lockRel(name),
+      `${JSON.stringify(residual, null, 2)}\n`,
+      "residual lock (gitignore/config retained pending --purge)",
+    );
   }
 
   if (options.purge) {
     if (configCut !== null) {
       if (lock.config.created && configCut.trim() === CONFIG_ROOT_CONTENT.trim()) {
-        ops.remove(CONFIG_PATH, "managed-repo marker created by install ([skills] removed, only version = 1 left)");
+        ops.remove(CONFIG_PATH, "managed-repo marker created by install ([extensions] removed, only version = 1 left)");
       } else {
-        ops.write(CONFIG_PATH, configCut, "[skills] block removed (--purge)");
+        ops.write(CONFIG_PATH, configCut, "[extensions] block removed (--purge)");
       }
     } else if (typeof lock.config?.appended === "string" && existsSync(abs(repo, CONFIG_PATH))) {
-      console.log(`kept ${CONFIG_PATH} [skills] block (edited since install; --force never cuts an edited block)`);
+      console.log(`kept ${CONFIG_PATH} [extensions] block (edited since install; --force never cuts an edited block)`);
     } else if (existsSync(abs(repo, CONFIG_PATH))) {
-      console.log(`kept ${CONFIG_PATH} (install did not write its [skills] block)`);
+      console.log(`kept ${CONFIG_PATH} (install did not write its [extensions] block)`);
     }
     purgeOpenCodeAutogenIfClean(repo, ops);
   }

package/scripts/lib/run-sync.mjs

@@ -1,10 +1,6 @@
-import { readFileSync, existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import {
-  syncPlatformManifests,
-  createEnactManifest,
-  assertSupportedHookEvents,
-} from "../../dist/index.js";
+import { assertSupportedHookEvents, createEnactManifest, syncPlatformManifests } from "../../dist/index.js";
 
 export function runSync(pluginRoot, { name } = {}) {
   const enactPath = join(pluginRoot, ".agents/plugin.json");
@@ -13,9 +9,7 @@ export function runSync(pluginRoot, { name } = {}) {
   if (existsSync(enactPath)) {
     enact = JSON.parse(readFileSync(enactPath, "utf8"));
   } else if (!name) {
-    throw new Error(
-      `No .agents/plugin.json in ${pluginRoot}. Pass --name <kebab-name> to create one.`,
-    );
+    throw new Error(`No .agents/plugin.json in ${pluginRoot}. Pass --name <kebab-name> to create one.`);
   } else {
     enact = createEnactManifest({ name });
   }

package/scripts/lib/run-validate.mjs

@@ -1,6 +1,4 @@
-import {
-  runBundleValidation,
-} from "../../dist/index.js";
+import { runBundleValidation } from "../../dist/index.js";
 import { formatDiagnostics, validatePlugin } from "./skill-validator.mjs";
 
 /**