@amsterdamdatalabs/enact-extensions 0.1.54 → 0.1.55

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

@@ -7,47 +7,32 @@
  * exception is the gitignored `.claude/settings.local.json` env block (see
  * the claude adapter), which cannot work any other way.
  *
- *   claude   — plugin root copied to `.claude-plugin/<name>/` (its `skills/` is
- *              a RELATIVE SYMLINK to the shared `.agents/skills/` tree, not a
- *              copy — see "Shared skills" below); repo marketplace
- *              `.claude-plugin/marketplace.json` (marketplace root = repo root,
- *              the dir CONTAINING .claude-plugin/, so the plugin entry is
- *              `source: "./.claude-plugin/<name>"`); `.claude/settings.json`
- *              merged with `extraKnownMarketplaces` (directory source, path "./")
- *              and `enabledPlugins`; `.claude/settings.local.json` merged with
- *              the absolute LEAN_CTX_*_DIR env block (gitignored via
- *              `.claude/.gitignore`). Loads only after the user trusts the folder.
- *   codex    — `.codex/config.toml` `[mcp_servers.<name>]` tables in a
- *              marker-delimited block (user TOML and comments untouched) +
- *              `.codex/hooks.json` (canonical nested schema, `--host=codex`).
- *              Loads only after the user trusts the project and reviews hooks.
- *   cursor   — `.cursor/hooks.json` (version 1, camelCase, `--host=cursor`) +
- *              `.cursor/mcp.json` (`type: "stdio"`).
- *   kimi     — `.kimi-code/mcp.json`. Kimi hooks are global-only (enact-vps),
- *              so NO hook file is written here.
- *   opencode — one generated `.opencode/plugins/<name>.ts` (hooks + MCP via the
- *              `config` hook, NO skills path: OpenCode reads `.agents/skills/`).
+ * Every host receives only its native project files:
+ *   claude   — `.claude/agents`, `.claude/skills`, `.mcp.json`, and hooks in
+ *              `.claude/settings.json`.
+ *   codex    — `.codex/agents`, `.agents/skills`, `.codex/config.toml`, and
+ *              `.codex/hooks.json`.
+ *   cursor   — `.cursor/agents`, `.cursor/skills`, `.cursor/hooks.json`, and
+ *              `.cursor/mcp.json`.
+ *   kimi     — `.kimi-code/agents`, `.kimi-code/skills`, and `.kimi-code/mcp.json`.
+ *              Kimi hooks remain global-only and are not owned here.
+ *   opencode — `.opencode/agents`, `.opencode/skills`, and `opencode.json` MCP.
+ *              OpenCode has no native project hook surface, so a hook-bearing
+ *              bundle fails before writes and names enact-vps' global plugin path.
  *
- * Shared skills: ONE real copy, in `.agents/skills/<skill>/`, written
- * UNCONDITIONALLY for every host (`.agents` is universal — every host,
- * including a claude-only install, needs it present so nothing dangles).
- * Claude's plugin-bundled `skills/` is a relative symlink to that same tree
- * (`../../.agents/skills`), not a second copy: Claude Code dereferences a
- * within-marketplace symlink (see `plan.symlinks` / the claude adapter below).
+ * Repo installation never writes a plugin root, marketplace, or plugin
+ * registration. Those belong exclusively to explicit global installation.
  *
  * State: `.agents/<name>.lock.json` records every managed file (sha256) and
  * every entry merged into a user file. Re-runs are idempotent.
  *
- * Owner decision (Tarun): hooks, mcp and skills content is ALWAYS force-
- * installed -- our own generated content and our own entries in a shared
- * file are repaired to match the bundle on every install, no `--force` flag
- * needed and no "not managed"/"edited" refusal. Two kinds:
- *   - Whole files we exclusively generate (`.claude-plugin/<name>/**`,
- *     `.agents/skills/**`, `.opencode/plugins/<name>.ts`, the claude skills
- *     symlink): nothing user-authored can live there, so drift or a stale
- *     pre-existing entry is just silently overwritten -- no displace/restore,
- *     nothing worth preserving. `plan.forcedFiles` marks exactly this subset
- *     of `plan.files`.
+ * Owner decision (Tarun): merged hooks and MCP entries are always repaired.
+ * Direct native agent and skill files are lock-owned files: user collisions
+ * fail loudly and the lock makes uninstall remove only this bundle's files.
+ *
+ * Two kinds:
+ *   - Whole files in host-native agent/skill locations, which are conflict
+ *     checked and recorded as files.
  *   - Merged surfaces shared with the user (`.cursor/hooks.json`,
  *     `.cursor/mcp.json`, `.kimi-code/mcp.json`, `.codex/hooks.json`,
  *     `.claude/settings.json`, the marker block in `.codex/config.toml`):
@@ -56,12 +41,9 @@
  *     share OUR key/server name is taken over and its original captured into
  *     `displaced` for a byte-exact restore on uninstall, exactly like a
  *     `--force` takeover always has -- it just no longer needs the flag.
- * `--force` still gates the two surfaces OUTSIDE that scope: the repo-root
- * `.claude-plugin/marketplace.json` and the lean-ctx baseline config files
- * (`.agents/lean-ctx/config/lean-ctx/*.toml`) -- both can plausibly hold
- * independent user content, so a pre-existing foreign file there is still a
- * refused conflict until `--force` takes it over (with restore-on-uninstall,
- * unchanged).
+ * `--force` gates native whole-file drift and baseline lean-ctx config files
+ * (`.agents/lean-ctx/config/lean-ctx/*.toml`), preserving displaced content
+ * for byte-exact restoration on uninstall.
  * Uninstall removes exactly what the lock records; uninstall's OWN drift
  * check (refusing to remove content edited since install without --force)
  * is unaffected by any of the above -- that gate is about safe removal, not
@@ -91,20 +73,18 @@ import {
   cutLegacySkillsBlock,
   declaredExtensionsFrom,
   declareExtension,
-  deriveOpenCodePlugin,
+  deriveOpenCodeMcp,
   EXTENSIONS_BLOCK,
   ensureContainer,
   entryPresent,
   extractTomlTable,
   findBlock,
   getAt,
-  MANIFEST_BY_PLATFORM,
   makeFileOps,
   materializeCodexSkillMetadata,
   pathKey,
-  projectClaudePluginRoot,
   projectCursorHooks,
-  projectPluginRoot,
+  projectNativeAgentsDir,
   reinsertTomlSpans,
   removeExtensionBlock,
   removeJsonEntries,
@@ -118,15 +98,20 @@ import {
 } from "../../dist/index.js";
 
 export const REPO_HOSTS = ["claude", "codex", "cursor", "kimi", "opencode"];
-// OpenCode is the ONLY host left needing a flat skills directory: per
-// spec/opencode.json its "documented plugin surface has no skills/agents/
-// commands concept", so a plugin root cannot carry them. Every other host
-// gets skills INSIDE its plugin root, namespaced by plugin name.
-//
-// `.opencode/skills/` is OpenCode's own documented project location, not a
-// shared cross-host pool -- so a collision here is scoped to one host instead
-// of every host, and nothing else reads it.
-const SHARED_SKILLS_DIR = ".opencode/skills";
+const HOST_SKILLS_DIR = {
+  codex: ".agents/skills",
+  claude: ".claude/skills",
+  cursor: ".cursor/skills",
+  kimi: ".kimi-code/skills",
+  opencode: ".opencode/skills",
+};
+const HOST_AGENTS_DIR = {
+  codex: ".codex/agents",
+  claude: ".claude/agents",
+  cursor: ".cursor/agents",
+  kimi: ".kimi-code/agents",
+  opencode: ".opencode/agents",
+};
 /** Declared extension names from `[extensions.<name>]` sub-tables, or []. */
 export function readDeclaredExtensions(configText) {
   if (typeof configText !== "string" || configText.length === 0) return [];
@@ -192,13 +177,9 @@ const GITIGNORE_LINES = [
 // `.claude/.gitignore` line to hide it. Both were removed with the carrier:
 // absolute paths in an installed file are machine-specific and go stale
 // silently on a rename or a fresh clone at a different path.
-// OpenCode's own auto-generated project-local files (verified 2026-09-14,
-// this session, against a live `.opencode/` created by a real OpenCode run
-// -- .scratch/opencode-plugin-example/.opencode/.gitignore lists exactly
-// these as what OpenCode itself manages: "node_modules\npackage.json\n
-// 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`).
+// OpenCode's own auto-generated project-local files. We never write these;
+// `--purge` removes them only when no user-owned content remains under
+// `.opencode/` after the lock-owned native files are removed.
 const OPENCODE_AUTOGEN_ENTRIES = new Set([
   "node_modules",
   "package.json",
@@ -206,17 +187,6 @@ const OPENCODE_AUTOGEN_ENTRIES = new Set([
   "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
-// file's identity was "whoever installed last", and the second plugin silently
-// erased the first's entry (measured: installing enact-repo then enact-wiki
-// with --force left `name: enact-wiki-local`, `plugins: [enact-wiki]`).
-// Claude: "To publish multiple plugins under one marketplace name, list them
-// all in a single marketplace.json." Codex reads this file too, as a
-// legacy-compatible repo marketplace.
-const MARKETPLACE_NAME = "enact-local";
-const MARKETPLACE_PATH = ".claude-plugin/marketplace.json";
 const LOCK_VERSION = 1;
 
 const CONFIG_ROOT_CONTENT = "version = 1\n";
@@ -432,128 +402,59 @@ function addLeanCtxConfig(plan, pluginRoot) {
   return added;
 }
 
-function addSharedSkills(plan, bundle, codexPolicy) {
+function addNativeSkills(plan, bundle, host) {
   if (!bundle.skillsDir) return;
+  const skillsDir = HOST_SKILLS_DIR[host];
   for (const entry of readdirSync(bundle.skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    plan.skills.add(entry.name);
+    plan.skills.add(`${skillsDir}/${entry.name}`);
     for (const rel of listFilesRecursive(join(bundle.skillsDir, entry.name))) {
-      // Skill content is force-installed (owner decision): always ours, see
-      // file-header comment.
-      const fileRel = `${SHARED_SKILLS_DIR}/${entry.name}/${rel}`;
+      const fileRel = `${skillsDir}/${entry.name}/${rel}`;
       plan.files.set(fileRel, readFileSync(join(bundle.skillsDir, entry.name, rel)));
-      plan.forcedFiles.add(fileRel);
     }
   }
-  if (!codexPolicy) return;
+  if (host !== "codex") return;
   stageDir("enact-repo-codex-skills-", (staging) => {
     materializeCodexSkillMetadata(bundle.skillsDir, staging);
     for (const rel of listFilesRecursive(staging)) {
-      const fileRel = `${SHARED_SKILLS_DIR}/${rel}`;
+      const fileRel = `${skillsDir}/${rel}`;
       plan.files.set(fileRel, readFileSync(join(staging, rel)));
-      plan.forcedFiles.add(fileRel);
     }
   });
 }
 
-// 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
-// safely -- the reason loose per-host files needed a flat shared skills pool.
-function addPluginRoot(plan, pluginRoot, bundle, platform) {
-  const rootRel = `${MANIFEST_BY_PLATFORM[platform].directory}/${bundle.name}`;
-  stageDir(`enact-repo-${platform}-`, (staging) => {
-    const target = join(staging, "plugin");
-    projectPluginRoot(pluginRoot, target, platform);
-    // Codex reads per-skill invocation policy from `agents/openai.yaml` beside
-    // each SKILL.md. It used to be written into the shared pool; it belongs
-    // inside the plugin root now, next to the skills it governs.
-    if (platform === "codex" && bundle.skillsDir) {
-      materializeCodexSkillMetadata(bundle.skillsDir, join(target, "skills"));
-    }
+function addNativeAgents(plan, pluginRoot, host) {
+  const source = join(pluginRoot, "agents");
+  if (!existsSync(source)) return;
+  const targetRel = HOST_AGENTS_DIR[host];
+  stageDir(`enact-repo-${host}-agents-`, (staging) => {
+    const target = join(staging, "agents");
+    projectNativeAgentsDir(source, target, host);
     for (const rel of listFilesRecursive(target)) {
-      const fileRel = `${rootRel}/${rel}`;
-      plan.files.set(fileRel, readFileSync(join(target, rel)));
-      plan.forcedFiles.add(fileRel);
+      plan.files.set(`${targetRel}/${rel}`, readFileSync(join(target, rel)));
     }
   });
-  return rootRel;
 }
 
-// Host adapters. Codex is a direct-file adapter like Cursor: a committed repo
-// marketplace is not auto-discovered by Codex, so none is written.
+// Host adapters write only documented native project files.
 const HOST_ADAPTERS = {
-  claude(plan, bundle, pluginRoot, ctx) {
-    const pluginRel = `.claude-plugin/${bundle.name}`;
-    stageDir("enact-repo-claude-", (staging) => {
-      const target = join(staging, "plugin");
-      // Skills are carried INSIDE the plugin root, like every other host with
-      // a plugin format -- that is what namespaces them by plugin name. The
-      // earlier symlink into a shared `.agents/skills/` pool existed only
-      // because that pool existed; it is retired with it.
-      projectClaudePluginRoot(pluginRoot, target);
-      for (const rel of listFilesRecursive(target)) {
-        // The whole projected plugin root is exclusively our own generated
-        // content -- force-installed, never gated (see file-header comment).
-        const fileRel = `${pluginRel}/${rel}`;
-        plan.files.set(fileRel, readFileSync(join(target, rel)));
-        plan.forcedFiles.add(fileRel);
+  claude(plan, bundle, pluginRoot) {
+    addNativeAgents(plan, pluginRoot, "claude");
+    addNativeSkills(plan, bundle, "claude");
+    const mcp = jsonMerge(plan, ".mcp.json");
+    for (const [name, def] of Object.entries(bundle.mcpServers))
+      mcp.keys.push({ path: ["mcpServers", name], value: def });
+    if (bundle.hooks) {
+      const merge = jsonMerge(plan, ".claude/settings.json");
+      for (const [event, entries] of Object.entries(applyHostFlagToHooksDoc(bundle.hooks, "claude").hooks ?? {})) {
+        for (const entry of entries) merge.items.push({ path: ["hooks", event], value: entry });
       }
-    });
-    const author = bundle.manifest.author;
-    plan.files.set(
-      MARKETPLACE_PATH,
-      Buffer.from(
-        `${JSON.stringify(
-          {
-            name: MARKETPLACE_NAME,
-            owner: { name: typeof author?.name === "string" ? author.name : bundle.name },
-            // Seeded from the entry already on disk so a sibling's description
-            // and version survive OUR install; only our own entry is rebuilt.
-            // Regeneration must not quietly strip fields it did not author.
-            plugins: ctx.declaredExtensions.map((name) =>
-              name === bundle.name
-                ? {
-                    name,
-                    source: `./.claude-plugin/${name}`,
-                    ...(typeof bundle.manifest.description === "string"
-                      ? { description: bundle.manifest.description }
-                      : {}),
-                    version: bundle.version,
-                  }
-                : (ctx.existingMarketplaceEntries.get(name) ?? { name, source: `./.claude-plugin/${name}` }),
-            ),
-          },
-          null,
-          2,
-        )}\n`,
-      ),
-    );
-    // NOT forced: a pre-existing FOREIGN marketplace must still be refused
-    // until --force, with restore-on-uninstall, because it can plausibly be
-    // the user's own. But it IS derived -- we regenerate it whenever the
-    // declared set changes, including from a sibling's uninstall -- so it is
-    // exempt from the uninstall drift check, which would otherwise read our
-    // own regeneration as damage.
-    plan.derivedFiles.add(MARKETPLACE_PATH);
-    const settings = jsonMerge(plan, ".claude/settings.json");
-    settings.keys.push({
-      path: ["extraKnownMarketplaces", MARKETPLACE_NAME],
-      value: { source: { source: "directory", path: "./" } },
-    });
-    settings.keys.push({ path: ["enabledPlugins", `${bundle.name}@${MARKETPLACE_NAME}`], value: true });
-    // NOTE: the installer deliberately writes NO lean-ctx env carrier here.
-    // Scoping lean-ctx to the repo config is done by `enact-hook`, which
-    // prefixes LEAN_CTX_CONFIG_DIR/DATA_DIR/STATE_DIR/CACHE_DIR onto the
-    // rewritten command, derived from `inv.root` at invocation time. Nothing
-    // is stored, so nothing can go stale, and it is not Claude-specific.
-    // A settings.local.json `env` block was tried and rejected: it is
-    // Claude-only, machine-local, gitignored, and does not travel with the
-    // repo. Do not reintroduce it.
+    }
   },
 
   codex(plan, bundle, pluginRoot) {
-    addPluginRoot(plan, pluginRoot, bundle, "codex");
+    addNativeAgents(plan, pluginRoot, "codex");
+    addNativeSkills(plan, bundle, "codex");
     if (Object.keys(bundle.mcpServers).length > 0) plan.toml.set(".codex/config.toml", { tables: bundle.mcpServers });
     if (bundle.hooks) {
       const merge = jsonMerge(plan, ".codex/hooks.json");
@@ -571,7 +472,8 @@ const HOST_ADAPTERS = {
   },
 
   cursor(plan, bundle, pluginRoot) {
-    addPluginRoot(plan, pluginRoot, bundle, "cursor");
+    addNativeAgents(plan, pluginRoot, "cursor");
+    addNativeSkills(plan, bundle, "cursor");
     if (bundle.hooks) {
       const dropped = unmappedCursorHookEvents(bundle.hooks);
       if (dropped.length > 0) {
@@ -596,24 +498,26 @@ const HOST_ADAPTERS = {
   },
 
   kimi(plan, bundle, pluginRoot) {
-    addPluginRoot(plan, pluginRoot, bundle, "kimi");
+    addNativeAgents(plan, pluginRoot, "kimi");
+    addNativeSkills(plan, bundle, "kimi");
     const mcp = jsonMerge(plan, ".kimi-code/mcp.json");
     for (const [name, def] of Object.entries(bundle.mcpServers)) {
       mcp.keys.push({ path: ["mcpServers", name], value: def });
     }
   },
 
-  opencode(plan, bundle) {
-    // No skillsDir on purpose: OpenCode natively reads the shared .agents/skills/
-    // copy; a skills.paths entry would list every skill twice.
-    const source = deriveOpenCodePlugin(
-      { hooks: bundle.hooks ?? undefined, mcpServers: { mcpServers: bundle.mcpServers } },
-      bundle.name,
-    );
-    // Generated whole file (hooks + mcp): force-installed, see file-header comment.
-    const fileRel = `.opencode/plugins/${bundle.name}.ts`;
-    plan.files.set(fileRel, Buffer.from(source));
-    plan.forcedFiles.add(fileRel);
+  opencode(plan, bundle, pluginRoot) {
+    if (bundle.hooks) {
+      throw new Error(
+        "OpenCode repo-local installation cannot install hooks: install the explicit global OpenCode plugin through enact-vps first",
+      );
+    }
+    addNativeAgents(plan, pluginRoot, "opencode");
+    addNativeSkills(plan, bundle, "opencode");
+    const mcp = jsonMerge(plan, "opencode.json");
+    for (const [name, def] of Object.entries(deriveOpenCodeMcp({ mcpServers: bundle.mcpServers }).mcp)) {
+      mcp.keys.push({ path: ["mcp", name], value: def });
+    }
   },
 };
 
@@ -631,10 +535,8 @@ export function buildPlan(pluginRoot, bundle, hosts, repo) {
     // `--force`, never captured for a displaced-content restore. See the
     // file-header doc comment.
     forcedFiles: new Set(),
-    // Files we REGENERATE from a source of truth (today: the marketplace, built
-    // from the declared extension set). Still conflict-gated on install, but
-    // exempt from the uninstall drift check -- a sibling's install or uninstall
-    // legitimately rewrites them.
+    // Files regenerated from a source of truth. They are exempt from uninstall
+    // drift checks when a sibling can legitimately rewrite them.
     derivedFiles: new Set(),
     json: new Map(),
     toml: new Map(),
@@ -645,40 +547,15 @@ 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 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
-  // does not churn the diff.
+  // The repo's declared extension set is the user-editable membership roster.
   const configPath = abs(repo, CONFIG_PATH);
   const configText = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
   const declared = readDeclaredExtensions(configText);
   const declaredExtensions = declared.includes(bundle.name) ? declared : [...declared, bundle.name];
 
-  // Existing marketplace entries, so regeneration preserves fields belonging to
-  // plugins other than the one being installed.
-  const existingMarketplaceEntries = new Map();
-  const mktPath = abs(repo, MARKETPLACE_PATH);
-  if (existsSync(mktPath)) {
-    try {
-      for (const entry of JSON.parse(readFileSync(mktPath, "utf8")).plugins ?? []) {
-        if (entry && typeof entry.name === "string") existingMarketplaceEntries.set(entry.name, entry);
-      }
-    } catch {
-      // Unparsable or foreign: the ordinary conflict gate handles it below.
-    }
-  }
-
-  const ctx = { repo, leanCtxConfig, declaredExtensions, existingMarketplaceEntries };
+  const ctx = { repo, leanCtxConfig, declaredExtensions };
   for (const host of hosts) HOST_ADAPTERS[host](plan, bundle, pluginRoot, ctx);
   plan.declaredExtensions = declaredExtensions;
-  // `.agents/skills` is written UNCONDITIONALLY -- .agents is universal, and a
-  // claude-only install still needs the real tree its plugin skills/ symlink
-  // points at, or the link dangles and Claude Code drops the skills silently.
-  // Only for OpenCode. `.agents/skills/` is retired: it was a flat pool shared
-  // by every host precisely because we were not building plugin roots, and a
-  // flat pool is what made two extensions shipping one skill name unsafe.
-  if (hosts.includes("opencode")) addSharedSkills(plan, bundle, false);
   for (const [rel, merge] of [...plan.json]) {
     if (merge.keys.length + merge.items.length === 0) plan.json.delete(rel);
   }
@@ -919,14 +796,12 @@ export function runRepoInstall(pluginRoot, options = {}) {
   // made every sibling-owned dir look foreign, which refused the install with
   // a false "non-managed" claim and advised deleting files another plugin
   // depends on.
-  const skillConflicts = [...plan.skills]
-    .map((skill) => `${SHARED_SKILLS_DIR}/${skill}`)
-    .filter(
-      (dirRel) =>
-        existsSync(abs(repo, dirRel)) &&
-        !Object.keys(prev.files).some((f) => f.startsWith(`${dirRel}/`)) &&
-        !siblingOwnsPrefix(siblings, dirRel),
-    );
+  const skillConflicts = [...plan.skills].filter(
+    (dirRel) =>
+      existsSync(abs(repo, dirRel)) &&
+      !Object.keys(prev.files).some((f) => f.startsWith(`${dirRel}/`)) &&
+      !siblingOwnsPrefix(siblings, dirRel),
+  );
   if (skillConflicts.length > 0) {
     throw new Error(
       `Refusing to overwrite existing user-authored skill dir(s); rename or remove them first:\n  ${skillConflicts.join("\n  ")}`,
@@ -940,13 +815,7 @@ export function runRepoInstall(pluginRoot, options = {}) {
   // that reads it, so two plugins cannot ship different skills under one name.
   // Refuse, and do NOT let --force through -- forcing would leave the other
   // plugin's lock pointing at bytes it did not write.
-  // `.claude-plugin/marketplace.json` is excluded: it is a multi-plugin
-  // REGISTRY, so differing content there is expected and correct -- every
-  // plugin adds its own entry. It is still written as a whole file today, so
-  // the second install is refused by the ordinary foreign-content gate below;
-  // Phase 2 turns it into a merged surface keyed by `plugins[].name`. Listing
-  // it here would report a real collision with useless advice ("rename one").
-  const SHARED_CONTENT_EXEMPT = new Set([".claude-plugin/marketplace.json"]);
+  const SHARED_CONTENT_EXEMPT = new Set();
   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
@@ -1033,8 +902,8 @@ export function runRepoInstall(pluginRoot, options = {}) {
     // Owned by US or by any SIBLING enact plugin. A key another installed
     // extension wrote is not foreign: capturing it as a "displaced original"
     // made uninstall RESTORE it instead of deleting it, so a shared
-    // registration key (`extraKnownMarketplaces.<marketplace>`) survived the
-    // last uninstall forever.
+    // legacy registration key survives migration only while another installed
+    // extension still records it; otherwise the final uninstall removes it.
     const ownedKeys = new Set([
       ...(record?.entries ?? []).filter((e) => e.type === "key").map((e) => pathKey(e.path)),
       ...siblings.flatMap(({ lock: l }) =>
@@ -1166,13 +1035,10 @@ export function runRepoInstall(pluginRoot, options = {}) {
     const created = [];
     for (const s of want.scaffold) {
       if (getAt(doc, s.path) === undefined) doc[s.path[0]] = s.value;
-      // Recorded whether or not WE created it. Scaffold is shared repo-level
-      // framing (a marketplace's `name`/`owner`), so recording it only in the
-      // creator's lock left the LAST plugin out with nothing to prune: it
-      // removed its own entry, `plugins` emptied, and `{name, owner}` stayed
-      // behind forever in a marketplace listing no plugins. The prune is
-      // already conditional on nothing else remaining, so recording it in
-      // every owner's lock is safe.
+      // Record shared framing whether or not we created it. This is retained
+      // for lock migration: all current install projections are direct native
+      // files, but an old lock can still name shared metadata that must be
+      // removed only after its final owner uninstalls.
       if (!scaffold.some((x) => pathKey(x.path) === pathKey(s.path))) scaffold.push({ path: s.path });
     }
     const entries = [];
@@ -1362,19 +1228,8 @@ export function runRepoInstall(pluginRoot, options = {}) {
   console.log(
     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
-  // session in this trusted folder (the newly-added extraKnownMarketplaces
-  // entry + enabledPlugins registers on that first launch, but does not
-  // finish activating in time for that same session) -- the SECOND session
-  // works. This matches Claude Code's own documented plugin-activation
-  // caveats (code.claude.com/docs/en/discover-plugins, "Apply plugin
-  // changes without restarting"). Told explicitly here so a user isn't left
-  // thinking the install failed.
   if (hosts.includes("claude")) {
-    console.log(
-      "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)",
-    );
+    console.log("claude: trust this folder and review the project hooks before using the installed agents and skills");
   }
   if (hosts.includes("codex"))
     console.log("codex: config and hooks load after you trust this project and review hooks (/hooks)");
@@ -1398,22 +1253,8 @@ export function runRepoUninstall(name, options = {}) {
   // Other plugins still installed here; their claims outlive this uninstall.
   const siblings = readSiblingLocks(repo, name);
 
-  // Captured BEFORE the removal loop deletes the file: uninstalling one
-  // extension must leave a marketplace listing the ones that remain, so the
-  // surviving entries have to be read while they still exist.
   const uninstallConfigPath = abs(repo, CONFIG_PATH);
   const uninstallConfigText = existsSync(uninstallConfigPath) ? readFileSync(uninstallConfigPath, "utf8") : "";
-  const survivingMarketplace = (() => {
-    const p = abs(repo, MARKETPLACE_PATH);
-    if (!existsSync(p)) return null;
-    try {
-      const doc = JSON.parse(readFileSync(p, "utf8"));
-      const kept = (doc.plugins ?? []).filter((e) => e && e.name !== name);
-      return kept.length > 0 ? { ...doc, plugins: kept } : null;
-    } catch {
-      return null;
-    }
-  })();
 
   const edited = [];
   for (const [rel, record] of Object.entries(lock.files)) {
@@ -1439,11 +1280,9 @@ export function runRepoUninstall(name, options = {}) {
     const text = readFileSync(path, "utf8");
     const doc = readJsonStrict(path, rel);
     for (const entry of record.entries) {
-      // An entry a SIBLING also records is shared registration, not drift:
-      // both plugins legitimately claim `extraKnownMarketplaces.<marketplace>`
-      // and the marketplace's own `name`/`owner`. Whichever uninstalls first
-      // removes it, and the second must not then report it as edited -- that
-      // read the shared state as damage and refused the uninstall outright.
+      // An entry a SIBLING also records is shared lock-owned metadata, not
+      // drift. This only matters while uninstalling historical lock content;
+      // current installs create no plugin registration or marketplace data.
       if (siblingRecordsJsonEntry(siblings, rel, entry)) continue;
       if (!entryPresent(doc, entry)) edited.push(`${rel} (${entry.path.join(".")})`);
     }
@@ -1497,16 +1336,6 @@ export function runRepoUninstall(name, options = {}) {
   for (const rel of Object.keys(lock.symlinks ?? {})) {
     ops.removeSymlink(rel, "managed symlink");
   }
-  // Put the marketplace back if other extensions are still declared. The
-  // removal loop above deleted it as one of our managed files; regenerating it
-  // from the survivors is what keeps the remaining plugins loadable.
-  if (survivingMarketplace) {
-    ops.write(
-      MARKETPLACE_PATH,
-      `${JSON.stringify(survivingMarketplace, null, 2)}\n`,
-      `marketplace regenerated without ${name}`,
-    );
-  }
   // Undeclare this extension: remove its own `[extensions.<name>]` table. The
   // `[extensions]` root table is cut only by --purge, and only once no other
   // extension is declared.
@@ -1520,12 +1349,9 @@ export function runRepoUninstall(name, options = {}) {
   for (const [rel, record] of Object.entries(lock.merged)) {
     if (!jsonDocs.has(rel)) continue;
     const { text, doc } = jsonDocs.get(rel);
-    // Reference counting, same law as managed files: an entry a sibling still
-    // records is shared repo-level registration, not ours to delete. Without
-    // this the FIRST uninstall removed `extraKnownMarketplaces.<marketplace>`
-    // and the marketplace's `name`/`owner`, leaving the surviving plugin
-    // unregistered -- and its own uninstall then refused, reporting the
-    // missing shared entry as drift.
+    // Reference-count historical shared metadata just as managed files. A
+    // sibling lock can still own an old registration during migration, so the
+    // first uninstall must leave it for the final owner to remove.
     const retained = record.entries.filter((e) => siblingRecordsJsonEntry(siblings, rel, e));
     const ours = { ...record, entries: record.entries.filter((e) => !retained.includes(e)) };
     for (const e of retained) ops.skip(`${rel} (${e.path.join(".")})`, "still registered by another installed plugin");