thoth-agents 0.3.11 → 0.3.12

package/dist/{chunk-ZEAAWBF2.js → chunk-VPVBYBPU.js}

@@ -35,7 +35,7 @@ import {
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-GIUU6FNE.js";
+} from "./chunk-DX4U3AD3.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -638,8 +638,8 @@ function stripProviderMcp(content) {
 }
 function pluginRootReference(pathValue) {
   const normalized = normalizePath(pathValue);
-  const relative = normalized.slice(".codex-plugin/".length);
-  return `./${relative}`;
+  const relative2 = normalized.slice(".codex-plugin/".length);
+  return `./${relative2}`;
 }
 function sha256(content) {
   return `sha256:${createHash("sha256").update(content).digest("hex")}`;
@@ -692,7 +692,7 @@ function codexHookPackageDiagnostic(code, message, severity = "warning") {
 function normalizeHookDefinition(hook) {
   return {
     command: hook.handler.command,
-    ...hook.outputFields?.length ? { output: [...hook.outputFields].sort() } : {}
+    type: "command"
   };
 }
 function renderHookDefinitions(hookDefinitions) {
@@ -705,7 +705,10 @@ function renderHookDefinitions(hookDefinitions) {
       continue;
     }
     const eventHooks = hooksByEvent.get(validation.event) ?? [];
-    eventHooks.push(normalizeHookDefinition(hook));
+    eventHooks.push({
+      ...hook.matcher !== void 0 ? { matcher: hook.matcher } : {},
+      hooks: [normalizeHookDefinition(hook)]
+    });
     hooksByEvent.set(validation.event, eventHooks);
   }
   if (hooksByEvent.size === 0) {
@@ -718,11 +721,11 @@ function renderHookDefinitions(hookDefinitions) {
     );
     return { diagnostics };
   }
-  const content = stableJson(
-    Object.fromEntries(
+  const content = stableJson({
+    hooks: Object.fromEntries(
       [...hooksByEvent.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([event, hooks]) => [event, hooks.map(stableValue)])
     )
-  );
+  });
   return { content, diagnostics };
 }
 function parseRawHookContent(content) {
@@ -753,37 +756,66 @@ function parseRawHookContent(content) {
       ]
     };
   }
-  for (const [event, definitions] of Object.entries(parsed)) {
+  if (!isRecord(parsed.hooks)) {
+    return {
+      hookDefinitions,
+      diagnostics: [
+        codexHookPackageDiagnostic(
+          "codex.plugin.hooks.invalid_shape",
+          'Skipping Codex plugin hooks asset because hooks.json must contain a nested "hooks" object.'
+        )
+      ]
+    };
+  }
+  for (const [event, definitions] of Object.entries(parsed.hooks)) {
     if (!Array.isArray(definitions)) {
       diagnostics.push(
         codexHookPackageDiagnostic(
           "codex.plugin.hooks.invalid_shape",
-          `Skipping Codex plugin hook event "${event}" because its value is not an array of command handlers.`
+          `Skipping Codex plugin hook event "${event}" because its value is not an array of matcher groups.`
         )
       );
       continue;
     }
-    for (const definition of definitions) {
-      if (!isRecord(definition)) {
+    for (const group of definitions) {
+      if (!isRecord(group) || !Array.isArray(group.hooks)) {
         diagnostics.push(
           codexHookPackageDiagnostic(
             "codex.plugin.hooks.invalid_shape",
-            `Skipping Codex plugin hook event "${event}" entry because it is not an object.`
+            `Skipping Codex plugin hook event "${event}" entry because it is not a matcher group with a hooks array.`
           )
         );
         continue;
       }
-      const output = definition.output;
-      hookDefinitions.push({
-        event,
-        handler: {
-          type: typeof definition.type === "string" ? definition.type : "command",
-          command: definition.command,
-          async: definition.async
-        },
-        outputFields: Array.isArray(output) ? output.filter((field) => typeof field === "string") : void 0,
-        interceptsToolExecution: definition.interceptsToolExecution === true
-      });
+      if (group.matcher !== void 0 && typeof group.matcher !== "string") {
+        diagnostics.push(
+          codexHookPackageDiagnostic(
+            "codex.plugin.hooks.invalid_shape",
+            `Skipping Codex plugin hook event "${event}" matcher group because matcher is not a string.`
+          )
+        );
+        continue;
+      }
+      for (const definition of group.hooks) {
+        if (!isRecord(definition)) {
+          diagnostics.push(
+            codexHookPackageDiagnostic(
+              "codex.plugin.hooks.invalid_shape",
+              `Skipping Codex plugin hook event "${event}" handler because it is not an object.`
+            )
+          );
+          continue;
+        }
+        hookDefinitions.push({
+          event,
+          ...typeof group.matcher === "string" ? { matcher: group.matcher } : {},
+          handler: {
+            type: typeof definition.type === "string" ? definition.type : "command",
+            command: definition.command,
+            async: definition.async
+          }
+        });
+      }
     }
   }
   return { hookDefinitions, diagnostics };
@@ -1763,7 +1795,7 @@ function buildCodexSetupPlan(config) {
     configPath: targets.configPath,
     pluginId: config.pluginId,
     diagnostics: [
-      "The combined install flow runs `codex plugin marketplace add EremesNG/thoth-agents` and `codex plugin add thoth-agents@thoth-agents` through the native manager; restart Codex, then use /plugins to review its state.",
+      "The combined install flow runs `codex plugin marketplace add https://github.com/EremesNG/thoth-plugins.git` and `codex plugin add thoth-agents@thoth-plugins` through the native manager; restart Codex, then use /plugins to review its state.",
       "The CLI does not copy a plugin into ~/.codex/plugins or merge ~/.agents/plugins/marketplace.json directly; Codex owns marketplace snapshots and installed plugin cache state.",
       "The /hooks surface may show hooks from independently installed plugins; this thoth-agents setup plan does not install provider hooks.",
       "Codex Default mode user-input requests require features.default_mode_request_user_input = true and use the request_user_input tool; other modes may not expose it.",
@@ -2139,11 +2171,18 @@ var CLAUDE_CODE_ROLE_NAMES = [
 ];
 
 // src/cli/claude-code-install.ts
-var MARKETPLACE_NAME = "thoth-agents";
-var MARKETPLACE_SOURCE = "EremesNG/thoth-agents";
-var PLUGIN_ID = "thoth-agents@thoth-agents";
-var MARKETPLACE_TARGET = "claude://marketplaces/thoth-agents";
-var PLUGIN_TARGET = "claude://plugins/thoth-agents@thoth-agents";
+var PLUGIN_NAME = "thoth-agents";
+var MARKETPLACE_NAME = "thoth-plugins";
+var MARKETPLACE_SOURCE = "https://github.com/EremesNG/thoth-plugins.git";
+var MARKETPLACE_INSTALL_SOURCE = MARKETPLACE_SOURCE;
+var PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+var LEGACY_MARKETPLACE_SOURCE = "https://github.com/EremesNG/thoth-agents.git";
+var LEGACY_MARKETPLACE_NAMES = [PLUGIN_NAME, `${PLUGIN_NAME}-claude`];
+var LEGACY_PLUGIN_IDS = LEGACY_MARKETPLACE_NAMES.map(
+  (name) => `${PLUGIN_NAME}@${name}`
+);
+var MARKETPLACE_TARGET = `claude://marketplaces/${MARKETPLACE_NAME}`;
+var PLUGIN_TARGET = `claude://plugins/${PLUGIN_ID}`;
 function defaultCommandExecutor(command, args, options) {
   const result = spawnSync(command, [...args], {
     cwd: options.cwd,
@@ -2171,12 +2210,26 @@ function parseJsonRecords(content) {
   }
 }
 function isCanonicalMarketplace(entry) {
-  if (entry.name !== MARKETPLACE_NAME) return false;
-  if (entry.repo === MARKETPLACE_SOURCE || entry.source === MARKETPLACE_SOURCE) {
-    return true;
+  return isMarketplaceIdentity(entry, MARKETPLACE_NAME);
+}
+function normalizeMarketplaceSource(value) {
+  return value.trim().replace(/#.*$/u, "").replace(/^git@github\.com:/i, "").replace(/^(?:https?|ssh):\/\/(?:git@)?github\.com\//i, "").replace(/^github\.com\//i, "").replace(/\/?\.git\/?$/i, "").replace(/\/$/u, "").toLowerCase();
+}
+function marketplaceSources(entry) {
+  const sources = [entry.repo, entry.source];
+  if (isRecord3(entry.marketplaceSource)) {
+    sources.push(entry.marketplaceSource.repo, entry.marketplaceSource.source);
   }
-  const source = entry.source;
-  return isRecord3(source) && (source.repo === MARKETPLACE_SOURCE || source.source === MARKETPLACE_SOURCE);
+  return sources.filter(
+    (source) => typeof source === "string"
+  );
+}
+function isMarketplaceIdentity(entry, name, source = MARKETPLACE_SOURCE) {
+  if (entry.name !== name) return false;
+  const canonical = normalizeMarketplaceSource(source);
+  return marketplaceSources(entry).some(
+    (source2) => normalizeMarketplaceSource(source2) === canonical
+  );
 }
 function inspectClaudeManager(executor, cwd, scope) {
   const marketplaceResult = executor(
@@ -2212,6 +2265,19 @@ function inspectClaudeManager(executor, cwd, scope) {
       diagnostics
     };
   }
+  const legacyMarketplace = LEGACY_MARKETPLACE_NAMES.some(
+    (name) => marketplaces.some(
+      (entry) => isMarketplaceIdentity(entry, name, LEGACY_MARKETPLACE_SOURCE)
+    )
+  );
+  const hasLegacyState = legacyMarketplace || plugins.some(
+    (entry) => typeof entry.id === "string" && LEGACY_PLUGIN_IDS.includes(entry.id)
+  );
+  if (hasLegacyState) {
+    diagnostics.push(
+      "Legacy Claude thoth-agents marketplace or plugin state was detected and preserved; the host-specific identity will be managed independently."
+    );
+  }
   const namedMarketplaces = marketplaces.filter(
     (entry) => entry.name === MARKETPLACE_NAME
   );
@@ -2221,7 +2287,7 @@ function inspectClaudeManager(executor, cwd, scope) {
   }
   if (marketplace === "conflict") {
     diagnostics.push(
-      "A Claude marketplace named thoth-agents is registered from a different source; resolve it through Claude Code before retrying."
+      "A Claude marketplace named thoth-plugins is registered from a different source; resolve it through Claude Code before retrying."
     );
   }
   const matchingPlugins = plugins.filter(
@@ -2246,7 +2312,7 @@ function commandItem(action, scope, projectRoot) {
       kind: "native-marketplace",
       action,
       targetPath: MARKETPLACE_TARGET,
-      description: "Register the package-owned thoth-agents Claude marketplace.",
+      description: "Register the central Thoth Claude marketplace.",
       requiresBackup: false,
       command: {
         executable: "claude",
@@ -2254,7 +2320,7 @@ function commandItem(action, scope, projectRoot) {
           "plugin",
           "marketplace",
           "add",
-          MARKETPLACE_SOURCE,
+          MARKETPLACE_INSTALL_SOURCE,
           "--scope",
           scope
         ],
@@ -2328,7 +2394,7 @@ function buildClaudeCodeSetupPlan(config) {
     commandExecutor,
     diagnostics: [
       ...inspection.diagnostics,
-      "Claude Code installs thoth-agents from EremesNG/thoth-agents through its native marketplace and owns the cached plugin files.",
+      "Claude Code installs thoth-agents from the central thoth-plugins marketplace, while the thoth-agents repository remains the pinned plugin source.",
       "Restart Claude Code or run /reload-plugins after installation; use /plugin to inspect marketplace and plugin state.",
       "Provider capability is owned by the external provider and is not established by this thoth-agents setup plan."
     ],
@@ -3549,16 +3615,52 @@ function defaultClaudeCodeModelRoles() {
 }
 
 // src/cli/operations/codex.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { basename as basename2 } from "path";
 
 // src/cli/codex-plugin-install.ts
 import { spawnSync as spawnSync4 } from "child_process";
-var MARKETPLACE_NAME2 = "thoth-agents";
-var MARKETPLACE_SOURCE2 = "EremesNG/thoth-agents";
-var PLUGIN_ID2 = "thoth-agents@thoth-agents";
-var MARKETPLACE_TARGET2 = "codex://marketplaces/thoth-agents";
-var PLUGIN_TARGET2 = "codex://plugins/thoth-agents@thoth-agents";
+import {
+  lstatSync,
+  readdirSync,
+  readFileSync as readFileSync6,
+  realpathSync,
+  rmSync as rmSync2
+} from "fs";
+import { isAbsolute, join as join4, relative, resolve as resolve2, sep } from "path";
+var PLUGIN_NAME2 = "thoth-agents";
+var MARKETPLACE_NAME2 = "thoth-plugins";
+var MARKETPLACE_SOURCE2 = "https://github.com/EremesNG/thoth-plugins.git";
+var PLUGIN_ID2 = `${PLUGIN_NAME2}@${MARKETPLACE_NAME2}`;
+var LEGACY_MARKETPLACE_SOURCE2 = "https://github.com/EremesNG/thoth-agents.git";
+var LEGACY_MARKETPLACE_NAMES2 = [PLUGIN_NAME2, `${PLUGIN_NAME2}-codex`];
+var LEGACY_PLUGIN_IDS2 = LEGACY_MARKETPLACE_NAMES2.map(
+  (name) => `${PLUGIN_NAME2}@${name}`
+);
+var LEGACY_ROOTS = [
+  {
+    relativePath: "plugins/cache/thoth-agents",
+    kind: "cache",
+    marketplaceName: "thoth-agents"
+  },
+  {
+    relativePath: "plugins/cache/thoth-agents-codex",
+    kind: "cache",
+    marketplaceName: "thoth-agents-codex"
+  },
+  {
+    relativePath: ".tmp/marketplaces/thoth-agents",
+    kind: "snapshot",
+    marketplaceName: "thoth-agents"
+  },
+  {
+    relativePath: ".tmp/marketplaces/thoth-agents-codex",
+    kind: "snapshot",
+    marketplaceName: "thoth-agents-codex"
+  }
+];
+var MARKETPLACE_TARGET2 = `codex://marketplaces/${MARKETPLACE_NAME2}`;
+var PLUGIN_TARGET2 = `codex://plugins/${PLUGIN_ID2}`;
 function getCodexCommand(args, options = {}) {
   if ((options.platform ?? process.platform) !== "win32") {
     return { command: "codex", args: [...args] };
@@ -3596,10 +3698,153 @@ function parseManagerRecord(content) {
     return null;
   }
 }
-function normalizeMarketplaceSource(value) {
-  return value.trim().replace(/^git@github\.com:/i, "").replace(/^(?:https?|ssh):\/\/(?:git@)?github\.com\//i, "").replace(/^github\.com\//i, "").replace(/\/?\.git\/?$/i, "").replace(/\/$/, "").toLowerCase();
+function normalizeMarketplaceSource2(value) {
+  return value.trim().replace(/#.*$/u, "").replace(/^git@github\.com:/i, "").replace(/^(?:https?|ssh):\/\/(?:git@)?github\.com\//i, "").replace(/^github\.com\//i, "").replace(/\/?\.git\/?$/i, "").replace(/\/$/, "").toLowerCase();
 }
-function marketplaceSources(entry) {
+function lstatIfPresent(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function strictDescendant(base, candidate) {
+  const suffix = relative(base, candidate);
+  return suffix !== "" && suffix !== ".." && !suffix.startsWith(`..${sep}`) && !isAbsolute(suffix);
+}
+function parseObjectFile(path, label) {
+  const file = lstatIfPresent(path);
+  if (!file || file.isSymbolicLink() || !file.isFile()) {
+    throw new Error(`${label} must be a regular non-link file`);
+  }
+  try {
+    const value = JSON.parse(readFileSync6(path, "utf8"));
+    if (!isRecord5(value)) throw new Error("not an object");
+    return value;
+  } catch (error) {
+    throw new Error(
+      `${label} is invalid JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function validateCacheManifest(root) {
+  const productEntries = readdirSync(root, { withFileTypes: true });
+  if (productEntries.length === 0) return;
+  if (productEntries.length !== 1 || productEntries[0]?.name !== PLUGIN_NAME2) {
+    throw new Error(
+      `Legacy cache ${root} contains state outside ${PLUGIN_NAME2}`
+    );
+  }
+  const productRoot = join4(root, PLUGIN_NAME2);
+  const product = lstatIfPresent(productRoot);
+  if (!product || product.isSymbolicLink() || !product.isDirectory()) {
+    throw new Error(`Legacy cache product root ${productRoot} is unsafe`);
+  }
+  const versions = readdirSync(productRoot, { withFileTypes: true });
+  if (versions.length === 0) {
+    throw new Error(`Legacy cache ${root} has no plugin manifest`);
+  }
+  for (const entry of versions) {
+    const versionRoot = join4(productRoot, entry.name);
+    const version = lstatIfPresent(versionRoot);
+    if (!entry.isDirectory() || !version || version.isSymbolicLink() || !version.isDirectory()) {
+      throw new Error(`Legacy cache version root ${versionRoot} is unsafe`);
+    }
+    const manifest = parseObjectFile(
+      join4(versionRoot, ".codex-plugin", "plugin.json"),
+      `Legacy cache manifest for ${versionRoot}`
+    );
+    if (manifest.name !== PLUGIN_NAME2) {
+      throw new Error(
+        `Legacy cache manifest for ${versionRoot} does not identify ${PLUGIN_NAME2}`
+      );
+    }
+  }
+}
+function validateSnapshotManifest(root, marketplaceName) {
+  if (readdirSync(root).length === 0) return;
+  const installation = parseObjectFile(
+    join4(root, ".codex-marketplace-install.json"),
+    `Legacy marketplace receipt for ${marketplaceName}`
+  );
+  if (typeof installation.source !== "string" || normalizeMarketplaceSource2(installation.source) !== normalizeMarketplaceSource2(LEGACY_MARKETPLACE_SOURCE2)) {
+    throw new Error(
+      `Legacy marketplace snapshot ${marketplaceName} has conflicting provenance`
+    );
+  }
+  const marketplace = parseObjectFile(
+    join4(root, ".agents", "plugins", "marketplace.json"),
+    `Legacy marketplace manifest for ${marketplaceName}`
+  );
+  const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+  const pluginNames = plugins.map(
+    (plugin) => isRecord5(plugin) ? plugin.name : null
+  );
+  if (marketplace.name !== marketplaceName || pluginNames.length === 0 || pluginNames.some((name) => name !== PLUGIN_NAME2)) {
+    throw new Error(
+      `Legacy marketplace snapshot ${marketplaceName} does not identify only ${PLUGIN_NAME2}`
+    );
+  }
+}
+function validateLegacyRoot(codexHome, definition, expectedRealPath) {
+  const path = resolve2(codexHome, ...definition.relativePath.split("/"));
+  if (!strictDescendant(codexHome, path)) {
+    throw new Error(
+      `Legacy cleanup target escapes CODEX_HOME: ${definition.relativePath}`
+    );
+  }
+  const target = lstatIfPresent(path);
+  if (!target) return null;
+  const home = lstatIfPresent(codexHome);
+  if (!home || !home.isDirectory()) {
+    throw new Error(`Resolved CODEX_HOME is not a directory: ${codexHome}`);
+  }
+  let boundary = codexHome;
+  for (const segment of definition.relativePath.split("/")) {
+    boundary = join4(boundary, segment);
+    const value = lstatIfPresent(boundary);
+    if (!value || value.isSymbolicLink() || !value.isDirectory()) {
+      throw new Error(
+        `Legacy cleanup boundary is not a real directory: ${boundary}`
+      );
+    }
+  }
+  const realHome = realpathSync(codexHome);
+  const realPath = realpathSync(path);
+  if (!strictDescendant(realHome, realPath)) {
+    throw new Error(
+      `Legacy cleanup target resolves outside CODEX_HOME: ${definition.relativePath}`
+    );
+  }
+  if (expectedRealPath && realPath !== expectedRealPath) {
+    throw new Error(
+      `Legacy cleanup target changed after preflight: ${definition.relativePath}`
+    );
+  }
+  if (definition.kind === "cache") validateCacheManifest(path);
+  else validateSnapshotManifest(path, definition.marketplaceName);
+  return {
+    kind: definition.kind,
+    marketplaceName: definition.marketplaceName,
+    path,
+    realPath,
+    relativePath: definition.relativePath
+  };
+}
+function preflightLegacyRoots(codexHomeInput) {
+  if (typeof codexHomeInput !== "string" || codexHomeInput.trim() === "") {
+    throw new Error("CODEX_HOME could not be resolved");
+  }
+  const codexHome = resolve2(codexHomeInput);
+  const roots = LEGACY_ROOTS.map(
+    (definition) => validateLegacyRoot(codexHome, definition)
+  ).filter((root) => root !== null);
+  return { codexHome, roots };
+}
+function marketplaceSources2(entry) {
   const sources = [entry.repo, entry.source];
   if (isRecord5(entry.marketplaceSource)) {
     sources.push(entry.marketplaceSource.repo, entry.marketplaceSource.source);
@@ -3609,13 +3854,16 @@ function marketplaceSources(entry) {
   );
 }
 function isCanonicalMarketplace2(entry) {
-  if (entry.name !== MARKETPLACE_NAME2) return false;
-  const canonical = MARKETPLACE_SOURCE2.toLowerCase();
-  return marketplaceSources(entry).some(
-    (source) => normalizeMarketplaceSource(source) === canonical
+  return isMarketplaceIdentity2(entry, MARKETPLACE_NAME2);
+}
+function isMarketplaceIdentity2(entry, name, source = MARKETPLACE_SOURCE2) {
+  if (entry.name !== name) return false;
+  const canonical = normalizeMarketplaceSource2(source);
+  return marketplaceSources2(entry).some(
+    (source2) => normalizeMarketplaceSource2(source2) === canonical
   );
 }
-function inspectCodexManager(executor, cwd) {
+function inspectCodexManager(executor, cwd, expectedVersion) {
   const marketplaceResult = executor(
     "codex",
     ["plugin", "marketplace", "list", "--json"],
@@ -3635,6 +3883,9 @@ function inspectCodexManager(executor, cwd) {
       ready: false,
       marketplace: "unknown",
       plugin: "unknown",
+      legacyPluginIds: [],
+      legacyMarketplaceNames: [],
+      legacyMarketplaceConflicts: [],
       diagnostics
     };
   }
@@ -3650,9 +3901,35 @@ function inspectCodexManager(executor, cwd) {
       ready: false,
       marketplace: "unknown",
       plugin: "unknown",
+      legacyPluginIds: [],
+      legacyMarketplaceNames: [],
+      legacyMarketplaceConflicts: [],
       diagnostics
     };
   }
+  const legacyMarketplaceNames = LEGACY_MARKETPLACE_NAMES2.filter(
+    (name) => marketplaces.some(
+      (entry) => isMarketplaceIdentity2(entry, name, LEGACY_MARKETPLACE_SOURCE2)
+    )
+  );
+  const legacyMarketplaceConflicts = LEGACY_MARKETPLACE_NAMES2.filter(
+    (name) => marketplaces.some(
+      (entry) => entry.name === name && !isMarketplaceIdentity2(entry, name, LEGACY_MARKETPLACE_SOURCE2)
+    )
+  );
+  const legacyPluginIds = LEGACY_PLUGIN_IDS2.filter(
+    (pluginId) => installedPlugins.some((entry) => entry.pluginId === pluginId)
+  );
+  if (legacyPluginIds.length > 0 || legacyMarketplaceNames.length > 0) {
+    diagnostics.push(
+      "Legacy Codex thoth-agents state was detected; cleanup is planned only after the central plugin is verified."
+    );
+  }
+  if (legacyMarketplaceConflicts.length > 0) {
+    diagnostics.push(
+      `Legacy Codex marketplace provenance conflicts were found for ${legacyMarketplaceConflicts.join(", ")}; no manager mutation will be attempted.`
+    );
+  }
   const namedMarketplaces = marketplaces.filter(
     (entry) => entry.name === MARKETPLACE_NAME2
   );
@@ -3662,31 +3939,81 @@ function inspectCodexManager(executor, cwd) {
   }
   if (marketplace === "conflict") {
     diagnostics.push(
-      "A Codex marketplace named thoth-agents is registered from a different source; resolve it through Codex before retrying."
+      "A Codex marketplace named thoth-plugins is registered from a different source; resolve it through Codex before retrying."
     );
   }
   const matchingPlugins = installedPlugins.filter(
     (entry) => entry.pluginId === PLUGIN_ID2
   );
   let plugin = "absent";
-  if (matchingPlugins.some((entry) => entry.enabled === true)) {
+  if (matchingPlugins.some(
+    (entry) => entry.enabled === true && entry.version === expectedVersion
+  )) {
     plugin = "installed";
+  } else if (matchingPlugins.some((entry) => entry.enabled === true)) {
+    plugin = "outdated";
   } else if (matchingPlugins.length > 0) {
     plugin = "disabled";
   }
   return {
-    ready: marketplace !== "conflict",
+    ready: marketplace !== "conflict" && legacyMarketplaceConflicts.length === 0,
     marketplace,
     plugin,
+    legacyPluginIds,
+    legacyMarketplaceNames,
+    legacyMarketplaceConflicts,
     diagnostics
   };
 }
+function centralPluginVerified(inspection) {
+  return inspection.ready && inspection.marketplace === "installed" && inspection.plugin === "installed";
+}
+function legacyManagerClean(inspection) {
+  return inspection.legacyPluginIds.length === 0 && inspection.legacyMarketplaceNames.length === 0;
+}
+function legacyRootsAbsent(codexHome) {
+  return LEGACY_ROOTS.every(
+    ({ relativePath }) => !lstatIfPresent(resolve2(codexHome, ...relativePath.split("/")))
+  );
+}
+function legacyPluginCommandItem(pluginId, projectRoot) {
+  return {
+    action: "remove-legacy-plugin",
+    targetPath: `codex://plugins/${pluginId}`,
+    description: `Remove the registered legacy Codex plugin ${pluginId}.`,
+    command: {
+      executable: "codex",
+      args: ["plugin", "remove", pluginId, "--json"],
+      cwd: projectRoot
+    }
+  };
+}
+function legacyMarketplaceCommandItem(marketplaceName, projectRoot) {
+  return {
+    action: "remove-legacy-marketplace",
+    targetPath: `codex://marketplaces/${marketplaceName}`,
+    description: `Remove the registered legacy Codex marketplace ${marketplaceName}.`,
+    command: {
+      executable: "codex",
+      args: ["plugin", "marketplace", "remove", marketplaceName, "--json"],
+      cwd: projectRoot
+    }
+  };
+}
+function legacyRootPlanItem(root) {
+  return {
+    action: "remove-legacy-root",
+    targetPath: root.path,
+    description: `Remove the preflight-approved legacy Codex root ${root.relativePath}.`,
+    cleanupRoot: root
+  };
+}
 function commandItem2(action, projectRoot) {
   if (action === "register-marketplace") {
     return {
       action,
       targetPath: MARKETPLACE_TARGET2,
-      description: "Register the package-owned thoth-agents Codex marketplace.",
+      description: "Register the central Thoth Codex marketplace.",
       command: {
         executable: "codex",
         args: ["plugin", "marketplace", "add", MARKETPLACE_SOURCE2, "--json"],
@@ -3707,25 +4034,54 @@ function commandItem2(action, projectRoot) {
 }
 function buildCodexPluginSetupPlan(config) {
   const commandExecutor = config.commandExecutor ?? defaultCommandExecutor3;
-  const inspection = inspectCodexManager(commandExecutor, config.projectRoot);
-  const items = [];
+  const inspection = inspectCodexManager(
+    commandExecutor,
+    config.projectRoot,
+    config.expectedVersion
+  );
+  let cleanupPreflight;
+  let cleanupPreflightError;
   if (inspection.ready) {
+    try {
+      cleanupPreflight = preflightLegacyRoots(
+        getCodexHome({ codexHome: config.codexHome, homeDir: config.homeDir })
+      );
+    } catch (error) {
+      cleanupPreflightError = `Legacy cleanup preflight failed: ${error instanceof Error ? error.message : String(error)}. No manager mutation will be attempted.`;
+    }
+  }
+  const ready = inspection.ready && cleanupPreflightError === void 0;
+  const items = [];
+  if (ready) {
     if (inspection.marketplace === "absent") {
       items.push(commandItem2("register-marketplace", config.projectRoot));
     }
-    if (inspection.plugin === "absent" || inspection.plugin === "disabled") {
+    if (inspection.plugin === "absent" || inspection.plugin === "disabled" || inspection.plugin === "outdated") {
       items.push(commandItem2("install-plugin", config.projectRoot));
     }
+    items.push(
+      ...inspection.legacyPluginIds.map(
+        (pluginId) => legacyPluginCommandItem(pluginId, config.projectRoot)
+      ),
+      ...inspection.legacyMarketplaceNames.map(
+        (marketplaceName) => legacyMarketplaceCommandItem(marketplaceName, config.projectRoot)
+      ),
+      ...cleanupPreflight?.roots.map(legacyRootPlanItem) ?? []
+    );
   }
   return {
+    codexHome: cleanupPreflight?.codexHome ?? getCodexHome({ codexHome: config.codexHome, homeDir: config.homeDir }),
     dryRun: config.dryRun === true,
+    expectedVersion: config.expectedVersion,
     items,
-    ready: inspection.ready,
+    ready,
     projectRoot: config.projectRoot,
     commandExecutor,
     diagnostics: [
       ...inspection.diagnostics,
-      "Codex installs thoth-agents from EremesNG/thoth-agents through its native plugin manager and owns the cached plugin files.",
+      ...cleanupPreflightError ? [cleanupPreflightError] : [],
+      "Codex installs thoth-agents from the central thoth-plugins marketplace through its native plugin manager, while the thoth-agents repository remains the pinned plugin source.",
+      "Close every Codex process before applying legacy cleanup; process-name detection is not a portable or race-free safety boundary.",
       "Restart Codex after installation; use /plugins to inspect marketplace and plugin state."
     ]
   };
@@ -3749,12 +4105,28 @@ function applyCodexPluginSetup(plan) {
     };
   }
   if (plan.dryRun) return { success: true, changed, diagnostics };
-  for (const item of plan.items) {
-    const result = plan.commandExecutor(
-      item.command.executable,
-      item.command.args,
-      { cwd: item.command.cwd }
-    );
+  const installationItems = plan.items.filter(
+    (item) => item.action === "register-marketplace" || item.action === "install-plugin"
+  );
+  const cleanupItems = plan.items.filter(
+    (item) => item.action === "remove-legacy-plugin" || item.action === "remove-legacy-marketplace"
+  );
+  const rootItems = plan.items.filter(
+    (item) => item.action === "remove-legacy-root"
+  );
+  for (const item of installationItems) {
+    const command = item.command;
+    if (!command) {
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: `Codex plugin setup plan item ${item.action} has no command.`
+      };
+    }
+    const result = plan.commandExecutor(command.executable, command.args, {
+      cwd: command.cwd
+    });
     if (result.exitCode !== 0) {
       return {
         success: false,
@@ -3767,10 +4139,11 @@ function applyCodexPluginSetup(plan) {
   }
   const inspection = inspectCodexManager(
     plan.commandExecutor,
-    plan.projectRoot
+    plan.projectRoot,
+    plan.expectedVersion
   );
   diagnostics.push(...inspection.diagnostics);
-  if (inspection.marketplace !== "installed" || inspection.plugin !== "installed") {
+  if (!centralPluginVerified(inspection)) {
     return {
       success: false,
       changed,
@@ -3778,11 +4151,112 @@ function applyCodexPluginSetup(plan) {
       error: "Codex did not verify the expected marketplace and enabled plugin after mutation."
     };
   }
+  for (const item of cleanupItems) {
+    const command = item.command;
+    if (!command) {
+      return {
+        success: false,
+        changed,
+        diagnostics: uniqueMessages3(diagnostics),
+        error: `Codex plugin cleanup plan item ${item.action} has no command.`
+      };
+    }
+    const result = plan.commandExecutor(command.executable, command.args, {
+      cwd: command.cwd
+    });
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        changed,
+        diagnostics: uniqueMessages3(diagnostics),
+        error: `${boundedCommandFailure2(item, result)} Central ${PLUGIN_ID2} remains installed; close Codex and retry.`
+      };
+    }
+    changed.push(item.targetPath);
+  }
+  const managerCleanupInspection = inspectCodexManager(
+    plan.commandExecutor,
+    plan.projectRoot,
+    plan.expectedVersion
+  );
+  diagnostics.push(...managerCleanupInspection.diagnostics);
+  if (!centralPluginVerified(managerCleanupInspection) || !legacyManagerClean(managerCleanupInspection)) {
+    return {
+      success: false,
+      changed,
+      diagnostics: uniqueMessages3(diagnostics),
+      error: `Central ${PLUGIN_ID2} remains installed, but exact legacy manager cleanup did not converge; close Codex and retry.`
+    };
+  }
+  for (const item of rootItems) {
+    const root = item.cleanupRoot;
+    const definition = root ? LEGACY_ROOTS.find(
+      (candidate) => candidate.relativePath === root.relativePath
+    ) : void 0;
+    if (!root || !definition) {
+      return {
+        success: false,
+        changed,
+        diagnostics: uniqueMessages3(diagnostics),
+        error: `Central ${PLUGIN_ID2} remains installed, but the fixed legacy cleanup plan is invalid; close Codex and retry.`
+      };
+    }
+    const exactPath = resolve2(
+      plan.codexHome,
+      ...definition.relativePath.split("/")
+    );
+    if (resolve2(root.path) !== exactPath || resolve2(item.targetPath) !== exactPath || root.kind !== definition.kind || root.marketplaceName !== definition.marketplaceName) {
+      return {
+        success: false,
+        changed,
+        diagnostics: uniqueMessages3(diagnostics),
+        error: `Central ${PLUGIN_ID2} remains installed, but the fixed legacy cleanup target changed; close Codex and retry.`
+      };
+    }
+    if (!lstatIfPresent(exactPath)) continue;
+    try {
+      const validated = validateLegacyRoot(
+        plan.codexHome,
+        definition,
+        root.realPath
+      );
+      if (!validated) continue;
+      rmSync2(validated.path, { recursive: true, force: false });
+      if (lstatIfPresent(validated.path)) {
+        throw new Error(
+          `Legacy cleanup target still exists: ${root.relativePath}`
+        );
+      }
+      changed.push(item.targetPath);
+    } catch (error) {
+      const detail = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").slice(0, 240);
+      return {
+        success: false,
+        changed,
+        diagnostics: uniqueMessages3(diagnostics),
+        error: `Central ${PLUGIN_ID2} remains installed; legacy root cleanup failed${detail ? `: ${detail}` : ""}. Close Codex and retry.`
+      };
+    }
+  }
+  const finalInspection = inspectCodexManager(
+    plan.commandExecutor,
+    plan.projectRoot,
+    plan.expectedVersion
+  );
+  diagnostics.push(...finalInspection.diagnostics);
+  if (!centralPluginVerified(finalInspection) || !legacyManagerClean(finalInspection) || !legacyRootsAbsent(plan.codexHome)) {
+    return {
+      success: false,
+      changed,
+      diagnostics: uniqueMessages3(diagnostics),
+      error: `Central ${PLUGIN_ID2} remains installed, but exact legacy cleanup did not converge; close Codex and retry.`
+    };
+  }
   return { success: true, changed, diagnostics: uniqueMessages3(diagnostics) };
 }
 function formatCodexPluginSetupPlan(plan) {
   const lines = plan.items.map(
-    (item) => `- ${item.action}: ${item.command.executable} ${item.command.args.join(" ")}`
+    (item) => item.command ? `- ${item.action}: ${item.command.executable} ${item.command.args.join(" ")}` : `- ${item.action}: ${item.cleanupRoot?.relativePath ?? item.targetPath}`
   );
   return ["Codex plugin setup plan:", ...lines].join("\n");
 }
@@ -3910,7 +4384,7 @@ function backupForItem(item) {
 function rootBlockState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const content = readFileSync6(item.targetPath, "utf8");
+  const content = readFileSync7(item.targetPath, "utf8");
   if (item.content && content.includes(item.content)) {
     return { state: "installed", observed: "managed root block present" };
   }
@@ -3923,11 +4397,11 @@ function managedModelState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
   try {
-    const parsed = JSON.parse(readFileSync6(item.targetPath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(item.targetPath, "utf8"));
     if (parsed.version !== MANAGED_MODEL_STATE_VERSION || !parsed.models || typeof parsed.models !== "object" || Array.isArray(parsed.models)) {
       return { state: "unknown", observed: "invalid managed model state" };
     }
-    return item.content === readFileSync6(item.targetPath, "utf8") ? { state: "installed", observed: "managed model state current" } : { state: "drift", observed: "managed model state differs" };
+    return item.content === readFileSync7(item.targetPath, "utf8") ? { state: "installed", observed: "managed model state current" } : { state: "drift", observed: "managed model state differs" };
   } catch {
     return { state: "unknown", observed: "unparseable managed model state" };
   }
@@ -3935,7 +4409,7 @@ function managedModelState(item) {
 function userConfigState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const content = readFileSync6(item.targetPath, "utf8");
+  const content = readFileSync7(item.targetPath, "utf8");
   if (/^\s*default_mode_request_user_input\s*=\s*true\b/m.test(content)) {
     return {
       state: "installed",
@@ -3950,7 +4424,7 @@ function userConfigState(item) {
 function contentState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const observed = readFileSync6(item.targetPath, "utf8");
+  const observed = readFileSync7(item.targetPath, "utf8");
   if (item.content === observed)
     return { state: "installed", observed: "current" };
   if (item.role) {
@@ -4117,7 +4591,7 @@ function planItemFromPluginSetup(item) {
       path: item.targetPath,
       label: "Codex native plugin manager target"
     },
-    preview: `${item.command.executable} ${item.command.args.join(" ")}`,
+    preview: item.command ? `${item.command.executable} ${item.command.args.join(" ")}` : `Remove exact preflight-approved Codex root ${item.cleanupRoot?.relativePath ?? item.targetPath}`,
     backup: { required: false, strategy: "external" }
   };
 }
@@ -4215,7 +4689,10 @@ function buildCompleteCodexPlan(action, context2) {
   const packageVersion = resolveVersion();
   const buildPlugin = context2.buildCodexPluginSetupPlan ?? buildCodexPluginSetupPlan;
   const pluginPlan = buildPlugin({
+    codexHome: context2.codexHome,
     dryRun: true,
+    expectedVersion: packageVersion.ok ? packageVersion.version : "0.0.0",
+    homeDir: context2.homeDir,
     projectRoot: context2.cwd,
     commandExecutor: context2.codexPluginCommandExecutor
   });
@@ -4611,7 +5088,7 @@ function applyCodexPlan(plan) {
 // src/cli/operations/opencode.ts
 import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/cli/opencode-effort.ts
 var OPENAI_GPT_RUNTIME_VARIANTS = /* @__PURE__ */ new Set([
@@ -4650,11 +5127,11 @@ import {
   mkdirSync as mkdirSync4,
   mkdtempSync,
   renameSync as renameSync3,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   statSync
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname5, join as join4 } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/harness/core/owned-skills.ts
@@ -4684,8 +5161,8 @@ function getOpenCodeOwnedSkillEntries(options = {}) {
   const homeDir = options.homeDir ?? homedir4();
   return THOTH_OWNED_SKILL_NAMES.map((name) => ({
     name,
-    sourcePath: join4(packageRoot, "skills", name),
-    destinationPath: join4(homeDir, ".config", "opencode", "skills", name)
+    sourcePath: join5(packageRoot, "skills", name),
+    destinationPath: join5(homeDir, ".config", "opencode", "skills", name)
   }));
 }
 function validateCanonicalSkill(entry) {
@@ -4694,7 +5171,7 @@ function validateCanonicalSkill(entry) {
       `Canonical owned skill directory is missing: ${entry.name}`
     );
   }
-  const contractPath = join4(entry.sourcePath, "SKILL.md");
+  const contractPath = join5(entry.sourcePath, "SKILL.md");
   if (!existsSync9(contractPath) || !statSync(contractPath).isFile()) {
     throw new Error(`Canonical owned skill contract is missing: ${entry.name}`);
   }
@@ -4704,21 +5181,21 @@ function installOwnedSkills(skills) {
   if (!firstSkill) return;
   const globalRoot = dirname5(firstSkill.destinationPath);
   mkdirSync4(globalRoot, { recursive: true });
-  const transactionRoot = mkdtempSync(join4(globalRoot, ".thoth-agents-owned-"));
-  const stagedRoot = join4(transactionRoot, "staged");
-  const backupRoot = join4(transactionRoot, "backup");
+  const transactionRoot = mkdtempSync(join5(globalRoot, ".thoth-agents-owned-"));
+  const stagedRoot = join5(transactionRoot, "staged");
+  const backupRoot = join5(transactionRoot, "backup");
   mkdirSync4(stagedRoot, { recursive: true });
   mkdirSync4(backupRoot, { recursive: true });
   try {
     for (const skill of skills) {
-      cpSync(skill.sourcePath, join4(stagedRoot, skill.name), {
+      cpSync(skill.sourcePath, join5(stagedRoot, skill.name), {
         recursive: true,
         force: true
       });
     }
     for (const skill of skills) {
-      const stagedPath = join4(stagedRoot, skill.name);
-      const backupPath = join4(backupRoot, skill.name);
+      const stagedPath = join5(stagedRoot, skill.name);
+      const backupPath = join5(backupRoot, skill.name);
       const hadExistingDestination = existsSync9(skill.destinationPath);
       if (hadExistingDestination) {
         renameSync3(skill.destinationPath, backupPath);
@@ -4727,7 +5204,7 @@ function installOwnedSkills(skills) {
         renameSync3(stagedPath, skill.destinationPath);
       } catch (error) {
         if (existsSync9(skill.destinationPath)) {
-          rmSync2(skill.destinationPath, { recursive: true, force: true });
+          rmSync3(skill.destinationPath, { recursive: true, force: true });
         }
         if (hadExistingDestination && existsSync9(backupPath)) {
           renameSync3(backupPath, skill.destinationPath);
@@ -4735,11 +5212,11 @@ function installOwnedSkills(skills) {
         throw error;
       }
       if (existsSync9(backupPath)) {
-        rmSync2(backupPath, { recursive: true, force: true });
+        rmSync3(backupPath, { recursive: true, force: true });
       }
     }
   } finally {
-    rmSync2(transactionRoot, { recursive: true, force: true });
+    rmSync3(transactionRoot, { recursive: true, force: true });
   }
 }
 function syncOpenCodeOwnedSkills(options = {}) {
@@ -5000,7 +5477,7 @@ function titleCaseSkillName(value) {
   }).join("-");
 }
 function homeDirFromContext(context2) {
-  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join5(context2.cwd, "home") : void 0);
+  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join6(context2.cwd, "home") : void 0);
 }
 function openCodeSkillTargets(context2) {
   const homeDir = homeDirFromContext(context2);
@@ -5024,7 +5501,7 @@ function openCodeSkillTargets(context2) {
   const ownedTargets = getOpenCodeOwnedSkillEntries({
     homeDir
   }).map((skill) => {
-    const path = join5(skill.destinationPath, "SKILL.md");
+    const path = join6(skill.destinationPath, "SKILL.md");
     const installed = existsSync10(path);
     return {
       kind: "skill",
@@ -6407,7 +6884,7 @@ import { execFileSync } from "child_process";
 import {
   existsSync as existsSync11,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   renameSync as renameSync4,
   unlinkSync,
   writeFileSync as writeFileSync4
@@ -6445,7 +6922,7 @@ function resolveModelsDevCachePath(options = {}) {
 function readModelsDevCache(cachePath) {
   if (!existsSync11(cachePath)) return void 0;
   try {
-    const input = JSON.parse(readFileSync7(cachePath, "utf8"));
+    const input = JSON.parse(readFileSync8(cachePath, "utf8"));
     const parsed = modelsDevCacheSchema.safeParse(input);
     return parsed.success ? parsed.data : void 0;
   } catch {
@@ -6780,7 +7257,7 @@ async function getModelOptions(harness) {
 }
 
 // src/cli/tui/operations.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 var context = { cwd: process.cwd() };
 var codexContext = { cwd: process.cwd() };
 var claudeCodeContext = {
@@ -6822,7 +7299,7 @@ function getCodexModelRoles(source = codexContext) {
       const item = plan.items.find(
         (candidate) => candidate.action === "write-role-toml" && candidate.role === role
       );
-      const content = item && existsSync12(item.targetPath) ? readFileSync8(item.targetPath, "utf8") : item?.content;
+      const content = item && existsSync12(item.targetPath) ? readFileSync9(item.targetPath, "utf8") : item?.content;
       const effort = content ? parseRoleTomlEffort(content) : void 0;
       return {
         role,