@amsterdamdatalabs/enact-extensions 0.1.1 → 0.1.3

package/scripts/enact-extensions.mjs

@@ -7,10 +7,11 @@ import { runValidate } from "./lib/run-validate.mjs";
 import { runSync } from "./lib/run-sync.mjs";
 import { runInstall } from "./lib/run-install.mjs";
 import { runUpdate } from "./lib/run-update.mjs";
+import { runPrune } from "./lib/run-prune.mjs";
 import { runUninstall } from "./lib/run-uninstall.mjs";
 import { readLedger } from "./lib/ledger.mjs";
 import { computeOutdated } from "./lib/outdated.mjs";
-import { startServer } from "./lib/serve.mjs";
+import { startServer, resolveServePort } from "./lib/serve.mjs";
 import { registerHook, removeHook, SUPPORTED_SURFACES } from "./lib/hooks.mjs";
 import { dirname, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -21,8 +22,12 @@ import { Ajv } from "ajv";
 import addFormatsModule from "ajv-formats";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = resolve(__dirname, "..");
+const PACKAGE_JSON = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8"));
+const VERSION = PACKAGE_JSON.version ?? "unknown";
 
 const HELP = `enact-extensions — Enact multi-platform plugin manifests
+Version: ${VERSION}
 
 Usage:
   enact-extensions list [dir]             List available plugin bundles (default: bundled + cwd/extensions/)
@@ -35,6 +40,9 @@ Usage:
   enact-extensions update --all           Refresh EVERY outdated plugin/surface
   enact-extensions update <name> --dry-run  Show what would be refreshed; change nothing
   enact-extensions update --all --dry-run   Show every outdated surface that would be refreshed
+  enact-extensions prune --platform all   Remove ledger-installed plugin surfaces whose local source bundle is gone
+  enact-extensions prune --platform shared  Remove orphaned shared skill drops (explicit only)
+  enact-extensions prune --dry-run        Show orphaned surfaces that would be removed
   enact-extensions index [--out <path>]   Generate a discovery index of all bundles (generated artifact, never committed)
   enact-extensions index --out -          Print the discovery index JSON to stdout
   enact-extensions index --stdout         Alias for --out -
@@ -47,7 +55,7 @@ Usage:
   enact-extensions install [path|name] --platform enact    Install to Enact (Codex fork)
   enact-extensions install [path|name] --platform codex    Install to Codex (explicit)
   enact-extensions install [path|name] --platform shared   Install skills to host-neutral .agents/skills/
-  enact-extensions install [path|name] --platform all      Install to every platform (codex, claude, cursor, enact, shared)
+  enact-extensions install [path|name] --platform all      Install to every plugin platform (codex, claude, cursor, enact)
   enact-extensions install [path|name] --platform claude,cursor   Install to a subset of platforms
   enact-extensions install [path|name] --global            Install into the default agent home (default)
   enact-extensions install [path|name] --local             Install into a project home under cwd (./.codex, ...)
@@ -57,9 +65,9 @@ Usage:
   enact-extensions uninstall [path|name] --platform enact    Uninstall from Enact (Codex fork)
   enact-extensions uninstall [path|name] --platform codex    Uninstall from Codex (explicit)
   enact-extensions uninstall [path|name] --platform shared   Remove skills from host-neutral .agents/skills/
-  enact-extensions uninstall [path|name] --platform all      Uninstall from every platform
+  enact-extensions uninstall [path|name] --platform all      Uninstall from every plugin platform
   enact-extensions uninstall [path|name] --platform claude,cursor   Uninstall from a subset of platforms
-  enact-extensions serve [--port 43217] [--host 127.0.0.1] [--open]  Start the localhost management UI + API
+  enact-extensions serve [--port N] [--prod] [--host 127.0.0.1] [--open]  Start the localhost management UI + API (dev 43217 / prod 53217)
   enact-extensions hooks [setup] [--surfaces <list>|--all] [--remove] [--local]
                                           Register (or remove) the session-start drift-check hook
                                           for each named surface (claude, codex, cursor, enact).
@@ -71,6 +79,7 @@ Hooks command:
   enact-extensions hooks setup --all --remove            Remove the drift hook from all surfaces
   enact-extensions hooks setup --surfaces claude --local  Register using project-local home (under cwd)
   enact-extensions hooks setup                           Interactive surface picker (TTY only)
+  enact-extensions -v | --version                        Print version and exit
 
 Options:
   path|name  Plugin root path, or a bare plugin name resolved from bundled extensions.
@@ -80,12 +89,12 @@ Options:
   --stdout                 (index only) Alias for --out -.
   --json                   (list only) Emit a JSON array to stdout instead of a human table.
   --platform <name>        Target platform: codex (default), claude, cursor, enact, shared.
-                           Use "all" to install to every platform, or a comma-separated list
+                           Use "all" to install to every plugin platform, or a comma-separated list
                            (e.g. "claude,cursor") to install to a named subset.
   --global                 Install into the agent's default home (default)
   --local                  Install into a project-scoped home under the current dir
   --codex-home <path>      Install only into the given Codex-compatible home
-  --enact-home <path>      Target a specific local Enact home (default: ~/.enact)
+  --enact-home <path>      Target a specific local Enact home (default: ~/.enact/agent)
   --claude-home <path>     Target a specific local Claude home (default: ~/.claude)
   --cursor-home <path>     Target a specific local Cursor home (default: ~/.cursor)
   --shared-home <path>     Base dir for shared install (skills land at <path>/.agents/skills/)
@@ -105,7 +114,7 @@ Name resolution (bare plugin names):
     3. <npm-global-root>/@amsterdamdatalabs/enact-extensions/extensions/<name>
 
 Multi-platform notes:
-  - Platforms are installed sequentially in deterministic order: codex, claude, cursor, enact, shared.
+  - Platforms are installed sequentially in deterministic order: codex, claude, cursor, enact.
   - Per-platform --<platform>-home flags apply to their respective platform in a multi-target run.
   - If any platform fails, the others still proceed; a non-zero exit is returned and the summary
     of succeeded/failed platforms is printed to stderr.
@@ -118,13 +127,13 @@ Examples:
   enact-extensions index --out -           Print discovery index JSON to stdout (pipe-friendly)
   enact-extensions index --stdout          Same as --out -
   enact-extensions index --out /tmp/my-index.json
-  cd ../enact-operator/extensions && enact-extensions validate
+  cd extensions/enact-factory && enact-extensions validate
   enact-extensions sync . --name my-plugin
   enact-extensions install net-revenue-management --platform enact --global
   enact-extensions install net-revenue-management --platform enact --local
   enact-extensions install extensions/net-revenue-management --platform enact --global
-  enact-extensions install ../enact-operator/extensions --platform claude
-  enact-extensions install ../enact-operator/extensions --platform cursor
+  enact-extensions install enact-factory --platform claude
+  enact-extensions install enact-factory --platform cursor
   enact-extensions install net-revenue-management --platform shared
   enact-extensions install net-revenue-management --platform shared --local
   enact-extensions install net-revenue-management --platform all
@@ -182,6 +191,8 @@ function parseArgs(argv) {
       options.host = argv[++i];
     } else if (arg === "--open") {
       options.open = true;
+    } else if (arg === "--prod") {
+      options.prod = true;
     } else if (arg === "--surfaces" && argv[i + 1]) {
       // Comma-separated list of surfaces: claude,codex,cursor,enact
       options.surfaces = argv[++i].split(",").map((s) => s.trim()).filter(Boolean);
@@ -197,7 +208,13 @@ function parseArgs(argv) {
   return { command: positional[0], path: positional[1], options };
 }
 
-const { command, path, options } = parseArgs(process.argv.slice(2));
+const rawArgv = process.argv.slice(2);
+if (rawArgv.length === 1 && (rawArgv[0] === "-v" || rawArgv[0] === "--version")) {
+  console.log(`enact-extensions ${VERSION}`);
+  process.exit(0);
+}
+
+const { command, path, options } = parseArgs(rawArgv);
 
 if (!command || command === "help") {
   console.log(HELP);
@@ -667,13 +684,63 @@ if (command === "update") {
   process.exit(summary.failed.length > 0 ? 1 : 0);
 }
 
+// ---------------------------------------------------------------------------
+// `prune` command — remove orphaned installed surfaces, driven by the ledger.
+//
+// A surface is pruned only when:
+//   - the ledger still says it is installed,
+//   - it belongs to the requested marketplace,
+//   - its platform is in scope, and
+//   - no local source bundle exists for that plugin name.
+// ---------------------------------------------------------------------------
+if (command === "prune") {
+  let summary;
+  try {
+    summary = runPrune({
+      platform: options.platform ?? "all",
+      dryRun: options.dryRun,
+      ledgerHome: homedir(),
+      cwd: processCwd(),
+      marketplaceName: options.marketplaceName,
+    });
+  } catch (err) {
+    process.stderr.write(
+      `[enact-extensions prune] ${err instanceof Error ? err.message : String(err)}\n`,
+    );
+    process.exit(1);
+  }
+
+  if (options.json) {
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+    process.exit(summary.failed.length > 0 ? 1 : 0);
+  }
+
+  const rows = summary.dryRun ? summary.candidates : summary.pruned;
+  const verb = summary.dryRun ? "would prune" : "pruned";
+  if (rows.length === 0) {
+    process.stderr.write("Nothing to prune — no orphaned installed surfaces in scope.\n");
+  }
+  for (const entry of rows) {
+    console.log(`${verb}: ${entry.name} [${entry.platform}] @ ${entry.home}`);
+  }
+  for (const f of summary.failed) {
+    process.stderr.write(
+      `failed: ${f.entry.name} [${f.entry.platform}] @ ${f.entry.home}: ${f.error.message}\n`,
+    );
+  }
+  process.stderr.write(
+    `${rows.length} ${summary.dryRun ? "would be pruned" : "pruned"}, ${summary.failed.length} failed.\n`,
+  );
+  process.exit(summary.failed.length > 0 ? 1 : 0);
+}
+
 // ---------------------------------------------------------------------------
 // `serve` command — localhost API + static-file server (no pluginRoot needed).
 // Handled here (before resolveRoot) because it is async + long-running.
 // ---------------------------------------------------------------------------
 if (command === "serve") {
   const PACKAGE_ROOT = resolve(__dirname, "..");
-  const port = options.port ?? 43217;
+  const port = resolveServePort(options);
   const host = options.host ?? "127.0.0.1";
 
   if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1") {

package/scripts/lib/hooks.mjs

@@ -195,6 +195,264 @@ command = "node ${scriptPath}"
 const TOML_BEGIN_MARKER = `# [${TOML_HOOK_MARKER}] BEGIN`;
 const TOML_END_MARKER = `# [${TOML_HOOK_MARKER}] END`;
 
+function pluginMarker(pluginName) {
+  return `enact-extensions:plugin-hooks:${pluginName}`;
+}
+
+function eventTomlName(eventName) {
+  return String(eventName)
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z])([A-Z][a-z])/g, "$1_$2")
+    .toLowerCase();
+}
+
+/**
+ * Map a PascalCase Claude/Enact event name to the camelCase key Cursor uses
+ * in its plugin-shipped hooks.json.
+ *
+ * Cursor hook events (from spec/cursor.md and plugin format):
+ *   SessionStart       → sessionStart
+ *   UserPromptSubmit   → beforeSubmitPrompt
+ *   PreToolUse         → preToolUse
+ *   PostToolUse        → postToolUse
+ *   Stop               → stop
+ *   PreCompact         → preCompact
+ *   SessionEnd         → sessionEnd
+ *   SubagentStart      → subagentStart
+ *   SubagentStop       → subagentStop
+ *
+ * Any unmapped event falls back to lowercase-first (simple camelCase).
+ *
+ * NOTE: Cursor reads hooks from the plugin-bundled hooks/hooks.json
+ * (installed into ~/.cursor/plugins/local/<name>/hooks/hooks.json via
+ * installCursorPluginBundle). There is NO global ~/.cursor/hooks.json.
+ * This function exists so the bundled hooks.json can be serialised with
+ * the Cursor-native camelCase event keys when needed.
+ *
+ * @param {string} event — PascalCase event name
+ * @returns {string} camelCase Cursor event name
+ */
+export function eventCursorName(event) {
+  const MAP = {
+    SessionStart:     "sessionStart",
+    UserPromptSubmit: "beforeSubmitPrompt",
+    PreToolUse:       "preToolUse",
+    PostToolUse:      "postToolUse",
+    Stop:             "stop",
+    PreCompact:       "preCompact",
+    SessionEnd:       "sessionEnd",
+    SubagentStart:    "subagentStart",
+    SubagentStop:     "subagentStop",
+  };
+  const mapped = MAP[String(event)];
+  if (mapped) return mapped;
+  // Fallback: lowercase the first character.
+  const s = String(event);
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function flattenHookCommands(hookConfig) {
+  const out = [];
+  const hooks = hookConfig?.hooks && typeof hookConfig.hooks === "object" ? hookConfig.hooks : {};
+  for (const [eventName, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      if (!group || typeof group !== "object") continue;
+      const commands = Array.isArray(group.hooks) ? group.hooks : [];
+      for (const hook of commands) {
+        if (!hook || typeof hook !== "object" || hook.type !== "command" || typeof hook.command !== "string") {
+          continue;
+        }
+        out.push({
+          eventName,
+          matcher: typeof group.matcher === "string" ? group.matcher : undefined,
+          command: hook.command,
+          statusMessage: typeof hook.statusMessage === "string" ? hook.statusMessage : undefined,
+          timeout: typeof hook.timeout === "number" ? hook.timeout : undefined,
+        });
+      }
+    }
+  }
+  return out;
+}
+
+function commandLooksPluginOwned(command) {
+  return /^enact-(?:operator|context)\s+hook\s+/.test(String(command));
+}
+
+/**
+ * True when `command` is owned by the named plugin's runtime CLI, i.e. it
+ * starts with `<pluginName> hook ` (the operator/context binaries invoke their
+ * hooks as `enact-operator hook <x>` / `enact-context hook <x>`).
+ *
+ * Scoping removal to the SPECIFIC plugin avoids reconciling one plugin from
+ * stripping a sibling plugin's marker-less entries. Falls back to the broad
+ * operator|context match when no plugin name is given.
+ */
+function commandOwnedByPlugin(command, pluginName) {
+  if (!pluginName) return commandLooksPluginOwned(command);
+  const esc = String(pluginName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^${esc}\\s+hook\\s+`).test(String(command));
+}
+
+function registerJsonPluginHooks(settingsPath, pluginName, hookConfig) {
+  const settings = readSettings(settingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  const marker = pluginMarker(pluginName);
+  let registered = 0;
+  let already = 0;
+
+  for (const entry of flattenHookCommands(hookConfig)) {
+    if (!commandLooksPluginOwned(entry.command)) continue;
+    if (!Array.isArray(settings.hooks[entry.eventName])) settings.hooks[entry.eventName] = [];
+    const exists = settings.hooks[entry.eventName].some((group) =>
+      group?._enact_marker === marker &&
+      Array.isArray(group.hooks) &&
+      group.hooks.some((hook) => hook?.command === entry.command),
+    );
+    if (exists) {
+      already += 1;
+      continue;
+    }
+    settings.hooks[entry.eventName].push({
+      _enact_marker: marker,
+      ...(entry.matcher ? { matcher: entry.matcher } : {}),
+      hooks: [
+        {
+          type: "command",
+          command: entry.command,
+          ...(entry.statusMessage ? { statusMessage: entry.statusMessage } : {}),
+          ...(entry.timeout ? { timeout: entry.timeout } : {}),
+        },
+      ],
+    });
+    registered += 1;
+  }
+
+  if (registered > 0) writeSettings(settingsPath, settings);
+  return registered > 0 ? "registered" : already > 0 ? "already_registered" : "skipped";
+}
+
+function removeJsonPluginHooks(settingsPath, pluginName) {
+  if (!existsSync(settingsPath)) return "not_found";
+  const settings = readSettings(settingsPath);
+  if (!settings.hooks || typeof settings.hooks !== "object") return "not_found";
+  const marker = pluginMarker(pluginName);
+  let removed = 0;
+
+  for (const [eventName, groups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(groups)) continue;
+    const next = groups.filter((group) => {
+      const markerMatch = group?._enact_marker === marker;
+      const commandMatch =
+        Array.isArray(group?.hooks) &&
+        group.hooks.some((hook) => commandOwnedByPlugin(hook?.command, pluginName));
+      const shouldRemove = markerMatch || commandMatch;
+      if (shouldRemove) removed += 1;
+      return !shouldRemove;
+    });
+    // Drop event keys we have fully emptied so a removed/unsupported event
+    // (e.g. SessionIdle) does not linger as `[]` and trip host "unknown hook
+    // event" warnings. Personal/other-plugin entries keep the key alive.
+    if (next.length === 0) delete settings.hooks[eventName];
+    else settings.hooks[eventName] = next;
+  }
+
+  if (removed === 0) return "not_found";
+  writeSettings(settingsPath, settings);
+  return "removed";
+}
+
+function pluginTomlBlock(pluginName, entry) {
+  const marker = pluginMarker(pluginName);
+  const eventName = eventTomlName(entry.eventName);
+  const suffix = `${entry.eventName}:${entry.command}`;
+  const fields = [
+    `# [${marker}] BEGIN ${suffix}`,
+    `[[hooks.${eventName}]]`,
+    ...(entry.matcher ? [`matcher = ${tomlString(entry.matcher)}`] : []),
+    `command = ${tomlString(entry.command)}`,
+    ...(entry.statusMessage ? [`status_message = ${tomlString(entry.statusMessage)}`] : []),
+    ...(entry.timeout ? [`timeout = ${entry.timeout}`] : []),
+    `# [${marker}] END ${suffix}`,
+  ];
+  return `${fields.join("\n")}\n`;
+}
+
+function registerTomlPluginHooks(configPath, pluginName, hookConfig) {
+  const existing = readToml(configPath);
+  const marker = pluginMarker(pluginName);
+  const blocks = [];
+  let already = 0;
+  for (const entry of flattenHookCommands(hookConfig)) {
+    if (!commandLooksPluginOwned(entry.command)) continue;
+    const suffix = `${entry.eventName}:${entry.command}`;
+    if (existing.includes(`# [${marker}] BEGIN ${suffix}`)) {
+      already += 1;
+      continue;
+    }
+    blocks.push(pluginTomlBlock(pluginName, entry));
+  }
+  if (blocks.length === 0) return already > 0 ? "already_registered" : "skipped";
+  const next = `${existing.replace(/\s+$/, "")}${existing.trim() ? "\n\n" : ""}${blocks.join("\n")}`;
+  writeToml(configPath, next.endsWith("\n") ? next : `${next}\n`);
+  return "registered";
+}
+
+function removeTomlPluginHooks(configPath, pluginName) {
+  const existing = readToml(configPath);
+  const marker = pluginMarker(pluginName);
+  const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`\\n?# \\[${escaped}\\] BEGIN[^\\n]*\\n[\\s\\S]*?# \\[${escaped}\\] END[^\\n]*\\n?`, "g");
+  let next = existing.replace(pattern, "\n");
+  let removed = next !== existing;
+
+  // Legacy cleanup: older codex installs could preserve the hook tables while
+  // dropping the marker comments when config.toml was reserialized. Remove any
+  // remaining plain [[hooks.*]] blocks that still point at the operator runtime
+  // command set.
+  const lines = next.split(/\r?\n/);
+  const out = [];
+  for (let i = 0; i < lines.length;) {
+    const line = lines[i];
+    if (line.startsWith("[[hooks.")) {
+      const block = [line];
+      i += 1;
+      while (
+        i < lines.length &&
+        !lines[i].startsWith("[[hooks.") &&
+        !/^\[[^\[]/.test(lines[i]) &&
+        !lines[i].startsWith(`# [${marker}] BEGIN`)
+      ) {
+        block.push(lines[i]);
+        i += 1;
+      }
+      const commandLine = block.find((entry) => entry.trim().startsWith("command = "));
+      const commandMatch = commandLine
+        ? commandOwnedByPlugin(commandLine.replace(/^command\s*=\s*/, "").replace(/^"|"$/g, ""), pluginName)
+        : false;
+      const markerMatch = block.some((entry) => entry.includes(marker));
+      if (markerMatch || commandMatch) {
+        removed = true;
+        continue;
+      }
+      out.push(...block);
+      continue;
+    }
+    out.push(line);
+    i += 1;
+  }
+
+  if (!removed) return "not_found";
+  next = out.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
+  writeToml(configPath, next.endsWith("\n") ? next : `${next}\n`);
+  return "removed";
+}
+
 /**
  * Read config.toml content. Returns empty string on missing.
  */
@@ -385,5 +643,99 @@ export function removeHook(surface, opts = {}) {
   }
 }
 
+export function registerPluginHooks(surface, pluginName, hookConfig, opts = {}) {
+  try {
+    switch (surface) {
+      case "claude": {
+        const home = opts.claudeHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".claude") : defaultHome("claude"));
+        const settingsPath = join(home, "settings.json");
+        const result = registerJsonPluginHooks(settingsPath, pluginName, hookConfig);
+        return { surface, result, location: settingsPath };
+      }
+
+      case "cursor": {
+        // Cursor reads hooks from the plugin-bundled hooks/hooks.json
+        // (installed to ~/.cursor/plugins/local/<name>/hooks/hooks.json by
+        // installCursorPluginBundle). There is NO global ~/.cursor/hooks.json
+        // to write to. Registering into ~/.cursor/settings.json is incorrect.
+        // Hook lifecycle is handled by the plugin bundle itself — skip here.
+        return {
+          surface,
+          result: "skipped",
+          note: "Cursor reads hooks from the plugin bundle (hooks/hooks.json installed via installCursorPluginBundle). No global hook file to register into.",
+        };
+      }
+
+      case "codex": {
+        const home = opts.codexHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".codex") : defaultHome("codex"));
+        const configPath = join(home, "config.toml");
+        const result = registerTomlPluginHooks(configPath, pluginName, hookConfig);
+        return { surface, result, location: configPath };
+      }
+
+      case "enact": {
+        const home = opts.enactHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".enact", "agent") : defaultHome("enact"));
+        const configPath = join(home, "config.toml");
+        const result = registerTomlPluginHooks(configPath, pluginName, hookConfig);
+        return { surface, result, location: configPath };
+      }
+
+      default:
+        return { surface, result: "skipped", note: `Unknown surface: ${surface}` };
+    }
+  } catch (err) {
+    return {
+      surface,
+      result: "skipped",
+      note: `Error: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
+export function removePluginHooks(surface, pluginName, opts = {}) {
+  try {
+    switch (surface) {
+      case "claude": {
+        const home = opts.claudeHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".claude") : defaultHome("claude"));
+        const settingsPath = join(home, "settings.json");
+        const result = removeJsonPluginHooks(settingsPath, pluginName);
+        return { surface, result, location: settingsPath };
+      }
+
+      case "cursor": {
+        // Cursor reads hooks from the plugin bundle — nothing to remove globally.
+        return {
+          surface,
+          result: "skipped",
+          note: "Cursor reads hooks from the plugin bundle (hooks/hooks.json installed via installCursorPluginBundle). No global hook file to remove from.",
+        };
+      }
+
+      case "codex": {
+        const home = opts.codexHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".codex") : defaultHome("codex"));
+        const configPath = join(home, "config.toml");
+        const result = removeTomlPluginHooks(configPath, pluginName);
+        return { surface, result, location: configPath };
+      }
+
+      case "enact": {
+        const home = opts.enactHome ?? (opts.local ? join(opts.cwd ?? process.cwd(), ".enact", "agent") : defaultHome("enact"));
+        const configPath = join(home, "config.toml");
+        const result = removeTomlPluginHooks(configPath, pluginName);
+        return { surface, result, location: configPath };
+      }
+
+      default:
+        return { surface, result: "skipped", note: `Unknown surface: ${surface}` };
+    }
+  } catch (err) {
+    return {
+      surface,
+      result: "skipped",
+      note: `Error: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+}
+
 // The 4 supported surfaces.
 export const SUPPORTED_SURFACES = ["claude", "codex", "cursor", "enact"];

package/scripts/lib/ledger.mjs

@@ -13,7 +13,7 @@ import { dirname, join } from "node:path";
  * to this single global ledger. The `home` override exists so tests never touch
  * the real ~/.enact.
  *
- * Entry shape: { ts, action, name, version, platform, scope, home, path }
+ * Entry shape: { ts, action, name, version, platform, scope, home, path, marketplaceName }
  *
  * All file I/O is best-effort: failures throw a catchable error so callers
  * (the install path) can swallow + warn rather than aborting an install.
@@ -127,13 +127,13 @@ export function findInstalled(name, { home } = {}) {
  * still-installed targets across all plugin names.
  *
  * Each returned entry carries the full ledger fields for the installed surface:
- *   { name, version, platform, scope, home, path, hash }
+ *   { name, version, platform, scope, home, path, hash, marketplaceName }
  *
  * A target is keyed by name+platform+scope+home+path so the same plugin installed
  * to multiple platforms/homes/names is tracked independently.
  *
  * @param {object} [opts] - { home }
- * @returns {{ name: string, version: string, platform: string, scope: string, home: string, path: string, hash: string|null }[]}
+ * @returns {{ name: string, version: string, platform: string, scope: string, home: string, path: string, hash: string|null, marketplaceName: string|null }[]}
  */
 export function listInstalled({ home } = {}) {
   const all = readLedger({ home });
@@ -153,6 +153,7 @@ export function listInstalled({ home } = {}) {
         home: e.home,
         path: e.path,
         hash: e.hash ?? null,
+        marketplaceName: e.marketplaceName ?? null,
       });
     } else if (e.action === "uninstall") {
       state.delete(key);