@wrongstack/cli 0.295.1 → 0.296.2

package/dist/chunk-XJXDOF63.js

@@ -0,0 +1,28 @@
+
+// src/version.ts
+import { createRequire } from "node:module";
+var req = createRequire(import.meta.url);
+function readOwnVersion() {
+  const candidates = ["../package.json", "../../package.json"];
+  for (const rel of candidates) {
+    try {
+      const pkg = req(rel);
+      if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+    } catch {
+    }
+  }
+  return "dev";
+}
+var CLI_VERSION = readOwnVersion();
+var API_VERSION = "0.0.0";
+try {
+  const corePkg = req("@wrongstack/core/package.json");
+  if (corePkg.wrongstackApiVersion) API_VERSION = corePkg.wrongstackApiVersion;
+} catch {
+}
+
+export {
+  CLI_VERSION,
+  API_VERSION
+};
+//# sourceMappingURL=chunk-XJXDOF63.js.map

package/dist/chunk-XJXDOF63.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/version.ts"],
+  "sourcesContent": ["import { createRequire } from 'node:module';\n\nconst req = createRequire(import.meta.url);\n\nfunction readOwnVersion(): string {\n  const candidates = ['../package.json', '../../package.json'];\n  for (const rel of candidates) {\n    try {\n      const pkg = req(rel) as { version?: unknown | undefined };\n      if (typeof pkg.version === 'string' && pkg.version.length > 0) return pkg.version;\n    } catch {\n      // try next\n    }\n  }\n  return 'dev';\n}\n\nexport const CLI_VERSION = readOwnVersion();\n\nlet API_VERSION = '0.0.0';\ntry {\n  const corePkg = req('@wrongstack/core/package.json') as {\n    wrongstackApiVersion?: string | undefined;\n  };\n  if (corePkg.wrongstackApiVersion) API_VERSION = corePkg.wrongstackApiVersion;\n} catch {\n  /* fallback */\n}\n\nexport { API_VERSION };\n"],
+  "mappings": ";;;AAAA,SAAS,qBAAqB;AAE9B,IAAM,MAAM,cAAc,YAAY,GAAG;AAEzC,SAAS,iBAAyB;AAChC,QAAM,aAAa,CAAC,mBAAmB,oBAAoB;AAC3D,aAAW,OAAO,YAAY;AAC5B,QAAI;AACF,YAAM,MAAM,IAAI,GAAG;AACnB,UAAI,OAAO,IAAI,YAAY,YAAY,IAAI,QAAQ,SAAS,EAAG,QAAO,IAAI;AAAA,IAC5E,QAAQ;AAAA,IAER;AAAA,EACF;AACA,SAAO;AACT;AAEO,IAAM,cAAc,eAAe;AAE1C,IAAI,cAAc;AAClB,IAAI;AACF,QAAM,UAAU,IAAI,+BAA+B;AAGnD,MAAI,QAAQ,qBAAsB,eAAc,QAAQ;AAC1D,QAAQ;AAER;",
+  "names": []
+}

package/dist/chunk-XWEGWYDU.js

@@ -0,0 +1,560 @@
+
+// src/plugin-management.ts
+import * as fs from "node:fs/promises";
+import { atomicWrite } from "@wrongstack/core/utils";
+import { OFFICIAL_PLUGIN_AUDIT_ENTRIES } from "@wrongstack/plugins/audit";
+var HOST_PLUGIN_AUDIT_ENTRIES = [
+  {
+    name: "wstack-prompts",
+    risk: "medium",
+    summary: "Prompt library and prompt authoring commands.",
+    defaultState: "active",
+    canDisable: true
+  },
+  {
+    name: "wstack-sync",
+    risk: "medium",
+    summary: "Cloud sync commands for prompts, skills, settings, memory, and history.",
+    defaultState: "active",
+    canDisable: true
+  },
+  {
+    name: "wstack-git",
+    risk: "high",
+    summary: "Git commands for commit, status checks, and push.",
+    defaultState: "active",
+    canDisable: true
+  },
+  {
+    name: "wstack-observability",
+    risk: "low",
+    summary: "Runtime metrics and health slash commands.",
+    defaultState: "active",
+    canDisable: true
+  },
+  {
+    name: "wstack-chimera",
+    risk: "medium",
+    summary: "Spawns a post-session code review subagent when explicitly enabled.",
+    defaultState: "inactive",
+    canDisable: true
+  },
+  {
+    name: "wstack-skills",
+    risk: "medium",
+    summary: "Skill library, authoring, install, update, and uninstall commands.",
+    defaultState: "active",
+    canDisable: true
+  },
+  {
+    name: "wstack-plan",
+    risk: "medium",
+    summary: "Strategic plan board slash command.",
+    defaultState: "active",
+    canDisable: true
+  },
+  {
+    name: "@wrongstack/plug-lsp",
+    risk: "medium",
+    summary: "Language Server Protocol tools and slash commands.",
+    defaultState: "inactive",
+    canDisable: true
+  },
+  {
+    name: "telegram",
+    risk: "medium",
+    summary: "Telegram bridge for messages, approvals, and notifications.",
+    defaultState: "inactive",
+    canDisable: true
+  }
+];
+var PLUGIN_AUDIT_ENTRIES = Object.freeze([
+  ...HOST_PLUGIN_AUDIT_ENTRIES,
+  ...OFFICIAL_PLUGIN_AUDIT_ENTRIES
+]);
+var OFFICIAL_PLUGINS = [
+  {
+    alias: "telegram",
+    specifier: "@wrongstack/telegram",
+    description: "Telegram bridge for prompts, notifications, and slash commands."
+  },
+  {
+    alias: "lsp",
+    specifier: "@wrongstack/plug-lsp",
+    description: "Language Server Protocol tools for code intelligence."
+  }
+];
+var OFFICIAL_ALIASES = new Map(
+  OFFICIAL_PLUGINS.flatMap((p) => [
+    [p.alias, p.specifier],
+    [p.specifier, p.specifier]
+  ])
+);
+async function runPluginManagementCommand(args, deps) {
+  const sub = args[0];
+  if (!sub || sub === "list" || sub === "status") {
+    return {
+      code: 0,
+      level: "output",
+      message: renderConfiguredPlugins(deps.config)
+    };
+  }
+  if (sub === "official" || sub === "officials") {
+    return {
+      code: 0,
+      level: "output",
+      message: renderOfficialPlugins(deps.config)
+    };
+  }
+  if (sub === "report" || sub === "audit" || sub === "menu") {
+    return {
+      code: 0,
+      level: "output",
+      message: renderPluginAuditReport(deps.config)
+    };
+  }
+  if (sub === "add" || sub === "install") {
+    const spec = args[1];
+    if (!spec) {
+      return errorResult("Usage: wstack plugin add <specifier|official-alias> [--disabled]");
+    }
+    return upsertPlugin(
+      resolvePluginSpecifier(spec),
+      { enabled: !args.includes("--disabled") },
+      deps,
+      "Added"
+    );
+  }
+  if (sub === "remove" || sub === "rm" || sub === "uninstall") {
+    const spec = args[1];
+    if (!spec) {
+      return errorResult("Usage: wstack plugin remove <specifier|official-alias>");
+    }
+    return removePlugin(resolvePluginSpecifier(spec), deps);
+  }
+  if (sub === "enable" || sub === "disable") {
+    const spec = args[1];
+    if (!spec) {
+      return errorResult(`Usage: wstack plugin ${sub} <specifier|official-alias>`);
+    }
+    return upsertPlugin(
+      resolvePluginSpecifier(spec),
+      { enabled: sub === "enable" },
+      deps,
+      sub === "enable" ? "Enabled" : "Disabled"
+    );
+  }
+  if (sub === "toggle") {
+    const spec = args[1];
+    if (!spec) {
+      return errorResult("Usage: wstack plugin toggle <plugin-name|official-alias>");
+    }
+    return togglePlugin(resolvePluginToggleSpecifier(spec), deps);
+  }
+  if (sub === "manager") {
+    return runPluginManagerPolicyCommand(args.slice(1), deps);
+  }
+  if (sub === "llm") {
+    return runPluginLlmCommand(args.slice(1), deps);
+  }
+  return errorResult(
+    `Unknown plugin subcommand: ${sub}
+Usage: wstack plugin [list|status|report|menu|official|add|install|remove|enable|disable|toggle|manager|llm]`
+  );
+}
+var PLUGIN_MANAGER_POLICY_USAGE = [
+  "Usage:",
+  "  wstack plugin manager                         List plugins locked against LLM state changes.",
+  "  wstack plugin manager lock <plugin|*>         Prevent plugin_manager from enabling/disabling it.",
+  "  wstack plugin manager unlock <plugin|*>       Restore plugin_manager enable/disable access.",
+  "",
+  "This policy affects only the LLM-facing plugin_manager tool. Human /plugin and",
+  "wstack plugin enable/disable commands remain available."
+].join("\n");
+async function runPluginManagerPolicyCommand(args, deps) {
+  const action = args[0] ?? "list";
+  if (action === "list") {
+    const locked = deps.config.pluginManager?.locked ?? [];
+    return {
+      code: 0,
+      level: "output",
+      message: locked.length === 0 ? "LLM plugin-manager policy: no plugins are locked." : `LLM plugin-manager policy \u2014 locked (${locked.length}):
+${locked.map((name2) => `  ${name2}`).join("\n")}`
+    };
+  }
+  if (action !== "lock" && action !== "unlock") {
+    return errorResult(PLUGIN_MANAGER_POLICY_USAGE);
+  }
+  const rawName = args[1];
+  if (!rawName) return errorResult(PLUGIN_MANAGER_POLICY_USAGE);
+  const name = rawName === "*" ? "*" : resolvePluginToggleSpecifier(rawName);
+  const existing = await readConfig(deps.configPath);
+  const filePolicy = isRecord(existing.pluginManager) ? existing.pluginManager : void 0;
+  const current = Array.isArray(filePolicy?.["locked"]) ? filePolicy["locked"].filter((entry) => typeof entry === "string") : [...deps.config.pluginManager?.locked ?? []];
+  const canonical = canonicalPolicyName(name);
+  const next = action === "lock" ? current.some((entry) => canonicalPolicyName(entry) === canonical) ? current : [...current, name] : current.filter((entry) => canonicalPolicyName(entry) !== canonical);
+  const pluginManager = { locked: next };
+  existing.pluginManager = { ...filePolicy ?? {}, ...pluginManager };
+  await atomicWrite(deps.configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  return {
+    code: 0,
+    level: "info",
+    message: action === "lock" ? `Locked "${name}" against LLM enable/disable changes. Human plugin commands still work.` : `Unlocked "${name}" for LLM enable/disable changes.`,
+    patch: { pluginManager }
+  };
+}
+function canonicalPolicyName(name) {
+  if (name === "*") return name;
+  return resolvePluginToggleSpecifier(name).trim().toLowerCase();
+}
+var PLUGIN_LLM_USAGE = [
+  "Usage:",
+  "  wstack plugin llm                               List every per-plugin LLM override.",
+  "  wstack plugin llm <plugin>                      Show one plugin's LLM override.",
+  "  wstack plugin llm <plugin> <provider> [model]   Route this plugin through a provider (and model).",
+  "  wstack plugin llm <plugin> - <model>            Keep the session provider, override only the model.",
+  "  wstack plugin llm <plugin> --clear              Remove the override (back to the session default).",
+  "",
+  "The override is stored as config.extensions.<plugin>.llm and is used by",
+  "every api.llm call the plugin makes. Without an override, plugins follow",
+  "the active session provider/model (the chat leader)."
+].join("\n");
+function renderPluginLlmOverviews(config, sessionDefault) {
+  const rows = [];
+  for (const [pluginName2, ext] of Object.entries(config.extensions ?? {})) {
+    const llm = ext?.["llm"];
+    if (llm && typeof llm === "object") {
+      const o = llm;
+      rows.push({
+        name: pluginName2,
+        provider: o.provider ?? "(session)",
+        model: o.model ?? "(session)"
+      });
+    }
+  }
+  const lines = [`Per-plugin LLM routing (session default: ${sessionDefault}):`];
+  if (rows.length === 0) {
+    lines.push(
+      "  No plugin overrides \u2014 every plugin follows the session default.",
+      "  Set one with: wstack plugin llm <plugin> <provider> [model]"
+    );
+  } else {
+    rows.sort((a, b) => a.name.localeCompare(b.name));
+    for (const r of rows) {
+      lines.push(`  ${r.name.padEnd(24)} provider=${r.provider.padEnd(16)} model=${r.model}`);
+    }
+    lines.push("", "Clear one with: wstack plugin llm <plugin> --clear");
+  }
+  return lines.join("\n");
+}
+async function runPluginLlmCommand(args, deps) {
+  const sessionDefault = `${deps.config.provider ?? "?"} / ${deps.config.model ?? "?"}`;
+  if (args.length === 0 || args[0] === "list") {
+    return {
+      code: 0,
+      level: "output",
+      message: renderPluginLlmOverviews(deps.config, sessionDefault)
+    };
+  }
+  const name = args[0];
+  if (!name || name.startsWith("-")) return errorResult(PLUGIN_LLM_USAGE);
+  const currentOverride = deps.config.extensions?.[name]?.["llm"];
+  if (args.length === 1) {
+    const lines = [`LLM routing for plugin "${name}":`];
+    if (currentOverride && typeof currentOverride === "object") {
+      const o = currentOverride;
+      lines.push(
+        `  override: provider=${o.provider ?? "(session)"} model=${o.model ?? "(session)"}`,
+        `  session default: ${sessionDefault}`
+      );
+    } else {
+      lines.push(
+        `  no override \u2014 follows the session default (${sessionDefault}).`,
+        `  Set one with: wstack plugin llm ${name} <provider> [model]`
+      );
+    }
+    return { code: 0, level: "output", message: lines.join("\n") };
+  }
+  const existing = await readConfig(deps.configPath);
+  const fileExtensions = isRecord(existing.extensions) ? existing.extensions : {};
+  const pluginExt = isRecord(fileExtensions[name]) ? { ...fileExtensions[name] } : {};
+  if (args[1] === "--clear" || args[1] === "clear") {
+    if (!("llm" in pluginExt) && !currentOverride) {
+      return { code: 0, level: "info", message: `Plugin "${name}" has no LLM override.` };
+    }
+    delete pluginExt["llm"];
+    if (Object.keys(pluginExt).length === 0) delete fileExtensions[name];
+    else fileExtensions[name] = pluginExt;
+    existing.extensions = fileExtensions;
+    await atomicWrite(deps.configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+    const merged2 = mergeExtensionsForPatch(deps.config, fileExtensions);
+    const mergedEntry = merged2[name];
+    if (mergedEntry) {
+      delete mergedEntry["llm"];
+      if (Object.keys(mergedEntry).length === 0) delete merged2[name];
+    }
+    return {
+      code: 0,
+      level: "info",
+      message: `Cleared LLM override for "${name}" \u2014 it now follows the session default (${sessionDefault}). Takes effect immediately for api.llm calls.`,
+      patch: { extensions: merged2 }
+    };
+  }
+  const providerArg = args[1];
+  const modelArg = args[2];
+  if (!providerArg || providerArg.startsWith("--")) return errorResult(PLUGIN_LLM_USAGE);
+  const provider = providerArg === "-" ? void 0 : providerArg;
+  const model = modelArg && modelArg !== "-" ? modelArg : void 0;
+  if (!provider && !model) return errorResult(PLUGIN_LLM_USAGE);
+  const llm = {};
+  if (provider) llm["provider"] = provider;
+  if (model) llm["model"] = model;
+  pluginExt["llm"] = llm;
+  fileExtensions[name] = pluginExt;
+  existing.extensions = fileExtensions;
+  await atomicWrite(deps.configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  const configured = Object.keys(deps.config.providers ?? {});
+  const note = provider && configured.length > 0 && !configured.includes(provider) ? `
+Note: "${provider}" is not in config.providers (configured: ${configured.join(", ")}). Catalog providers (anthropic, openai, \u2026) still resolve if credentials are available.` : "";
+  const merged = mergeExtensionsForPatch(deps.config, fileExtensions);
+  return {
+    code: 0,
+    level: "info",
+    message: `Plugin "${name}" now routes api.llm calls via provider=${provider ?? "(session)"} model=${model ?? "(session)"}. Session default stays ${sessionDefault}. Takes effect immediately for api.llm calls.${note}`,
+    patch: { extensions: merged }
+  };
+}
+function mergeExtensionsForPatch(config, fileExtensions) {
+  const merged = {};
+  for (const [k, v] of Object.entries(config.extensions ?? {})) {
+    merged[k] = { ...v };
+  }
+  for (const [k, v] of Object.entries(fileExtensions)) {
+    if (isRecord(v)) merged[k] = { ...merged[k] ?? {}, ...v };
+  }
+  for (const k of Object.keys(merged)) {
+    if (!(k in fileExtensions) && !(k in (config.extensions ?? {}))) delete merged[k];
+  }
+  return merged;
+}
+function resolvePluginSpecifier(input) {
+  return OFFICIAL_ALIASES.get(input.toLowerCase()) ?? input;
+}
+function resolvePluginToggleSpecifier(input) {
+  if (input.toLowerCase() === "@wrongstack/telegram") return "telegram";
+  if (auditEntryFor(input)) return input;
+  return resolvePluginSpecifier(input);
+}
+function renderOfficialPlugins(config) {
+  return [
+    "Official plugins:",
+    ...OFFICIAL_PLUGINS.map((p) => {
+      const state = config ? officialPluginState(config, p.specifier) : "";
+      const status = state ? `${state.padEnd(14)} ` : "";
+      return `  ${p.alias.padEnd(12)} ${status}${p.specifier.padEnd(24)} ${p.description}`;
+    }),
+    "",
+    "Use `wstack plugin add <alias>` or `/plugin install <alias>`."
+  ].join("\n");
+}
+function renderConfiguredPlugins(config) {
+  const plugins = config.plugins ?? [];
+  if (plugins.length === 0) {
+    return [
+      "No plugins configured.",
+      "Use `wstack plugin add <specifier>` or `/plugin install <official-alias>`."
+    ].join("\n");
+  }
+  return plugins.map((p) => {
+    const name = pluginName(p);
+    const enabled = typeof p === "object" && p.enabled === false ? "disabled" : "enabled";
+    const official = OFFICIAL_PLUGINS.find((entry) => entry.specifier === name);
+    const suffix = official ? ` (${official.alias})` : "";
+    return `  ${`${name}${suffix}`.padEnd(44)} ${enabled}`;
+  }).join("\n");
+}
+function renderPluginAuditReport(config) {
+  const configured = config.plugins ?? [];
+  const lines = [
+    "Plugin audit report:",
+    "  State shows the effective boot state. Default-active plugins run unless disabled in config.",
+    "  Built-in audit rows are toggleable unless a future row explicitly marks itself locked.",
+    "",
+    "  Built-in audit entries:"
+  ];
+  for (const entry of PLUGIN_AUDIT_ENTRIES) {
+    const { state, source } = effectiveAuditState(config, entry);
+    const policy = entry.canDisable ? "toggleable" : lockedReason(entry);
+    lines.push(
+      `  ${entry.name.padEnd(24)} ${state.padEnd(8)} ${source.padEnd(8)} risk=${entry.risk.padEnd(6)} ${policy.padEnd(24)} ${entry.summary}`
+    );
+  }
+  const extra = configured.filter(
+    (plugin) => !PLUGIN_AUDIT_ENTRIES.some((entry) => pluginMatchesToggleSpec(plugin, entry.name))
+  );
+  if (extra.length > 0) {
+    lines.push("", "  Configured plugins outside the audit list:");
+    for (const plugin of extra) {
+      const name = pluginName(plugin);
+      const state = typeof plugin === "object" && plugin.enabled === false ? "disabled" : "enabled";
+      lines.push(
+        `  ${name.padEnd(24)} ${state.padEnd(8)} config   risk=custom user-configured plugin`
+      );
+    }
+  }
+  lines.push(
+    "",
+    "Use `/plugin menu` in the TUI, or `wstack plugin toggle <name>` for toggleable rows."
+  );
+  return lines.join("\n");
+}
+async function readConfig(file) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function pluginName(p) {
+  return typeof p === "string" ? p : p.name;
+}
+function pluginEntry(spec, enabled) {
+  return enabled ? spec : { name: spec, enabled: false };
+}
+function pluginMatchesToggleSpec(p, spec) {
+  const name = pluginName(p);
+  if (spec === "telegram") return name === "telegram" || name === "@wrongstack/telegram";
+  return name === spec;
+}
+function effectiveAuditState(config, entry) {
+  const configured = (config.plugins ?? []).find(
+    (plugin) => pluginMatchesToggleSpec(plugin, entry.name)
+  );
+  if (configured) {
+    return {
+      state: typeof configured === "object" && configured.enabled === false ? "disabled" : "enabled",
+      source: "config"
+    };
+  }
+  return {
+    state: entry.defaultState === "active" ? "enabled" : "disabled",
+    source: "default"
+  };
+}
+function lockedReason(entry) {
+  if (entry.canDisable) return "toggleable";
+  if (entry.name === "secret-scanner") {
+    return "locked: safety guard";
+  }
+  return "locked: core surface";
+}
+function auditEntryFor(spec) {
+  return PLUGIN_AUDIT_ENTRIES.find((entry) => entry.name === spec);
+}
+function officialPluginState(config, spec) {
+  const match = (config.plugins ?? []).find((p) => pluginName(p) === spec);
+  if (!match) return "not configured";
+  return typeof match === "object" && match.enabled === false ? "disabled" : "enabled";
+}
+async function togglePlugin(spec, deps) {
+  const auditEntry = auditEntryFor(spec);
+  if (auditEntry?.canDisable === false) {
+    return errorResult(`Plugin "${spec}" is locked and cannot be toggled from the plugin menu.`);
+  }
+  const existing = await readConfig(deps.configPath);
+  const plugins = Array.isArray(existing.plugins) ? existing.plugins : [];
+  const idx = plugins.findIndex((p) => pluginMatchesToggleSpec(p, spec));
+  const configured = idx >= 0 ? plugins[idx] : void 0;
+  const enabled = configured ? !(typeof configured === "object" && configured.enabled === false) : auditEntry?.defaultState === "active";
+  if (!configured && !auditEntry) {
+    return errorResult(
+      `Plugin "${spec}" is not configured. Use "wstack plugin add ${spec}" first.`
+    );
+  }
+  let nextPlugins;
+  let nextEnabled;
+  if (enabled) {
+    nextEnabled = false;
+    nextPlugins = plugins.filter((p) => !pluginMatchesToggleSpec(p, spec));
+    if (auditEntry?.defaultState !== "inactive") {
+      nextPlugins.push({ name: spec, enabled: false });
+    }
+  } else {
+    nextEnabled = true;
+    if (auditEntry?.defaultState === "active") {
+      nextPlugins = plugins.filter((p) => !pluginMatchesToggleSpec(p, spec));
+    } else {
+      nextPlugins = plugins.filter((p) => !pluginMatchesToggleSpec(p, spec));
+      nextPlugins.push(spec);
+    }
+  }
+  const features = {
+    ...isRecord(deps.config.features) ? deps.config.features : {},
+    ...isRecord(existing.features) ? existing.features : {},
+    plugins: true
+  };
+  existing.plugins = nextPlugins;
+  existing.features = features;
+  await atomicWrite(deps.configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  const restartRequired = spec === "branch-guard" && !nextEnabled ? void 0 : true;
+  return {
+    code: 0,
+    level: "info",
+    message: `${nextEnabled ? "Enabled" : "Disabled"} "${spec}". Config written to ${deps.configPath}.` + (spec === "branch-guard" && !nextEnabled ? " The running branch-guard hook will disable itself on config update." : ""),
+    patch: { plugins: nextPlugins, features },
+    restartRequired
+  };
+}
+async function upsertPlugin(spec, opts, deps, verb) {
+  const existing = await readConfig(deps.configPath);
+  const plugins = Array.isArray(existing.plugins) ? existing.plugins : [];
+  const idx = plugins.findIndex((p) => pluginName(p) === spec);
+  const nextEntry = pluginEntry(spec, opts.enabled);
+  if (idx >= 0) plugins[idx] = nextEntry;
+  else plugins.push(nextEntry);
+  const features = {
+    ...isRecord(deps.config.features) ? deps.config.features : {},
+    ...isRecord(existing.features) ? existing.features : {},
+    plugins: true
+  };
+  existing.plugins = plugins;
+  existing.features = features;
+  await atomicWrite(deps.configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  const restartRequired = spec === "branch-guard" && !opts.enabled ? void 0 : true;
+  return {
+    code: 0,
+    level: "info",
+    message: `${verb} "${spec}" (${opts.enabled ? "enabled" : "disabled"}). Config written to ${deps.configPath}.` + (spec === "branch-guard" && !opts.enabled ? " The running branch-guard hook will disable itself on config update." : ""),
+    patch: { plugins, features },
+    restartRequired
+  };
+}
+async function removePlugin(spec, deps) {
+  const existing = await readConfig(deps.configPath);
+  const plugins = Array.isArray(existing.plugins) ? existing.plugins : [];
+  const next = plugins.filter((p) => pluginName(p) !== spec);
+  if (next.length === plugins.length) {
+    return errorResult(`Plugin "${spec}" not in config.`);
+  }
+  existing.plugins = next;
+  await atomicWrite(deps.configPath, JSON.stringify(existing, null, 2), { mode: 384 });
+  return {
+    code: 0,
+    level: "info",
+    message: `Removed "${spec}" from config.`,
+    patch: { plugins: next },
+    restartRequired: true
+  };
+}
+function errorResult(message) {
+  return { code: 1, level: "error", message };
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  PLUGIN_AUDIT_ENTRIES,
+  runPluginManagementCommand
+};
+//# sourceMappingURL=chunk-XWEGWYDU.js.map