thoth-agents 0.3.10 → 0.3.12

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

@@ -28,13 +28,14 @@ import {
   isValidPackageVersion,
   loadAgentPrompt,
   parseConfig,
+  renderAgentRoutingDescription,
   renderPromptSection,
   renderRolePrompt,
   resolveExecutingPackageVersion,
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-M2WF46BP.js";
+} from "./chunk-DX4U3AD3.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -120,62 +121,6 @@ function renderConfiguredRolePrompt({
 }
 
 // src/harness/core/memory-governance.ts
-function roleRules(role) {
-  const sharedRules = [
-    "thoth-mem remains an external provider; its installed provider guidance is authoritative for memory operations and thoth-agents does not prescribe the mechanism.",
-    "Provider-dependent use requires parent-scoped authorization with the stable root session identity or explicit unavailable state and project supplied by dispatch.",
-    "The MEMORY authorization is none, recall, or observe: none forbids provider work, recall permits bounded reads, and observe additionally permits one bounded durable observation under the delegated scope.",
-    "Only authorized context may be used, and the delegate must report missing, stale, contradictory, or insufficient context instead of guessing.",
-    "Memory authorization never changes workspace permissions or grants control of root lifecycle and real-user-intent ownership.",
-    "A handoff must keep accepted scope, decisions, permissions, and artifacts plus bounded memory context available to the authorized delegate.",
-    "Completion continuity is a provider-confirmed semantic summary outcome owned by the root.",
-    "Missing capability evidence is reported as degraded or unsupported and never as successful persistence or recovery.",
-    "openspec/ is the canonical SDD store; do not mirror spec.md, plan.md, tasks.md, verification reports, or archive reports into provider memory.",
-    "Do not invent a consumer fallback or silently change the selected persistence mode."
-  ];
-  if (role.name === "orchestrator") {
-    return [
-      ...sharedRules,
-      "The root coordinator owns authorization, root lifecycle, real-user-intent handling, and semantic completion outcomes.",
-      "Dispatch task and authorization context without embedding secrets, raw transcripts, or irrelevant context."
-    ];
-  }
-  if (role.mode === "read-only") {
-    return [
-      ...sharedRules,
-      "For a read-only workspace role, observe may authorize a durable provider observation but does not authorize workspace mutation.",
-      "Root lifecycle ownership never transfers to this delegate."
-    ];
-  }
-  return [
-    ...sharedRules,
-    "For a write-capable workspace role, provider observations still require observe authorization and the delegated parent scope.",
-    "Root lifecycle ownership never transfers to this delegate."
-  ];
-}
-function getRoleMemoryGovernance(role) {
-  return {
-    role: role.name,
-    workspaceMode: role.mode,
-    requiresParentContext: role.name !== "orchestrator",
-    availableAuthorizations: ["none", "recall", "observe"],
-    ownsRootLifecycle: role.name === "orchestrator",
-    rules: roleRules(role)
-  };
-}
-function renderMemoryGovernanceInstructions(role, dialect) {
-  const governance = getRoleMemoryGovernance(role);
-  const harnessRules = dialect ? [
-    `- Harness wording: use ${dialect.renderRoleInvocation("orchestrator")} as the memory owner and \`${dialect.tools.userQuestionTool}\` for blocking memory-context questions.`,
-    `- Progress ownership remains with the coordinator; report memory-governance verification for tracking in ${dialect.tools.progressTool}.`
-  ] : [];
-  return [
-    "External thoth-mem provider memory governance:",
-    ...governance.rules.map((rule) => `- ${rule}`),
-    ...harnessRules,
-    `- Runtime enforcement: ${role.name === "orchestrator" ? "root-owned outcomes" : "instruction-level unless the target harness validates per-agent memory controls"}.`
-  ].join("\n");
-}
 function memoryGovernanceDiagnostics(input) {
   const diagnostics = [];
   if (input.permissionControls !== "supported") {
@@ -448,12 +393,13 @@ var CODEX_SURFACES = [
     target: "permission-control",
     status: "unsupported",
     fields: [
-      "named installed-role selection",
+      "conditional agent_type selection",
+      "role-prefixed fallback",
       "per-role permission enforcement",
       "per-agent tool allow/deny equivalent to OpenCode permissions"
     ],
     diagnosticCode: "codex.permission.memory.enforcement_gap",
-    summary: "Named installed-role selection and per-role permission enforcement are instruction-only because collaboration.spawn_agent has no role selector; OpenCode-style per-agent MCP/tool deny maps are not validated.",
+    summary: "Static packages cannot guarantee active-runtime named-role selection: use collaboration.spawn_agent agent_type when exposed, otherwise the bounded role-prefixed fallback is instruction-only; per-role permission enforcement and OpenCode-style MCP/tool deny maps are not validated.",
     evidence: "Codex approvals/security docs cover sandbox and approval policies, not exact OpenCode per-agent permission maps.",
     fallback: "instruction-only"
   },
@@ -692,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")}`;
@@ -746,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) {
@@ -759,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) {
@@ -772,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) {
@@ -807,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 };
@@ -1109,7 +1087,7 @@ function codexRuntimeGuidance() {
     "- The ambient Codex session is the adaptive root; no orchestrator child TOML is generated.",
     "- Delegate with `collaboration.spawn_agent` only when the root determines that specialization, context isolation, review, or independent parallel work creates a net gain.",
     "- Collaboration tools are direct tools and must not be called from inside `functions.exec`.",
-    "- Use a role-prefixed `task_name` and a self-contained English `message` with scope, anchors, constraints, verification, and the compact return contract. The current collaboration surface has no hard custom-role selector, so role selection remains instruction-level.",
+    "- When the active `collaboration.spawn_agent` schema exposes `agent_type`, set it to the selected canonical role. When it does not, use a role-prefixed `task_name` plus a self-contained bounded envelope; that fallback is instruction-only.",
     "- Keep maximum depth 1: children do not delegate. Use one writer per mutable surface and parallelize only independent work.",
     "- A `collaboration.wait_agent` timeout is nonterminal; inspect `collaboration.list_agents` for the same task before rerouting or interrupting it.",
     "- Use `request_user_input` only for blocking material choices and always omit `autoResolutionMs` entirely.",
@@ -1121,15 +1099,8 @@ function codexRuntimeGuidance() {
 function codexRoleInstructions(role) {
   return [
     "<role-operational-contract>",
-    `- Role: ${role.name}`,
-    `- Mode: ${role.mode}`,
-    `- Scope: ${role.scope}`,
-    `- Responsibility: ${role.responsibility}`,
-    "- Use request_user_input for local blocking decisions.",
     "- Permissions, memory governance, runtime hooks, and provider-per-agent controls are instruction-level unless the active Codex runtime documents stronger enforcement.",
     `- ${role.name} runs as a Codex custom-agent TOML entry; the orchestrator remains the ambient Codex root session, not a generated role TOML.`,
-    ...role.toolGovernance.map((rule) => `- ${rule}`),
-    ...role.verification.map((rule) => `- ${rule}`),
     "</role-operational-contract>"
   ].join("\n");
 }
@@ -1142,8 +1113,7 @@ function roleInstructions(role, config) {
       config,
       model
     }),
-    codexRoleInstructions(role),
-    renderMemoryGovernanceInstructions(role, CODEX_PROMPT_DIALECT)
+    codexRoleInstructions(role)
   ].join("\n\n");
 }
 function renderCodexRootInstructions(config) {
@@ -1189,7 +1159,7 @@ function renderAgentArtifacts({ config }) {
       surfaceId: "project-agent-toml",
       values: {
         name: role.name,
-        description: role.responsibility,
+        description: renderAgentRoutingDescription(role),
         developer_instructions: roleInstructions(role, config),
         ...model ? { model } : {},
         ...effort ? { model_reasoning_effort: effort } : {},
@@ -1825,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.",
@@ -2005,6 +1975,15 @@ var CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS = {
   quick: "haiku",
   deep: "sonnet"
 };
+var CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS = {
+  explorer: "low",
+  quick: "low",
+  designer: "medium",
+  deep: "medium",
+  librarian: "high",
+  oracle: "high"
+};
+var CLAUDE_CODE_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "max"]);
 function isClaudeCodeSubagentName(name) {
   return name in CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS;
 }
@@ -2014,20 +1993,18 @@ function getClaudeCodeAgentModel(role, config) {
   if (override && isClaudeCodeModel(override)) return override;
   return CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS[role.name];
 }
+function getClaudeCodeAgentEffort(role, config) {
+  if (!isClaudeCodeSubagentName(role.name)) return void 0;
+  const configured = config?.agents?.[role.name]?.variant;
+  return configured && CLAUDE_CODE_EFFORTS.has(configured) ? configured : CLAUDE_CODE_SUBAGENT_DEFAULT_EFFORTS[role.name];
+}
 function claudeCodeRoleInstructions(role) {
   return [
     "<role-operational-contract>",
-    `- Role: ${role.name}`,
-    `- Mode: ${role.mode}`,
-    `- Scope: ${role.scope}`,
-    `- Responsibility: ${role.responsibility}`,
-    "- Use AskUserQuestion for local blocking decisions.",
     `- ${role.name} runs as an auto-discovered Claude Code plugin subagent invoked via Agent(subagent_type: ${claudeCodeSubagentType(role.name)}); plugin subagents are namespaced with the plugin name. The orchestrator is the main Claude Code session.`,
     ...role.mode === "read-only" ? [
       "- Write and Edit are denied in frontmatter while all other inherited tools, including MCP tools, remain available."
     ] : [],
-    ...role.toolGovernance.map((rule) => `- ${rule}`),
-    ...role.verification.map((rule) => `- ${rule}`),
     "</role-operational-contract>"
   ].join("\n");
 }
@@ -2040,8 +2017,7 @@ function roleInstructions2(role, config) {
       config,
       model
     }),
-    claudeCodeRoleInstructions(role),
-    renderMemoryGovernanceInstructions(role, CLAUDE_CODE_PROMPT_DIALECT)
+    claudeCodeRoleInstructions(role)
   ].join("\n\n");
 }
 function renderClaudeCodeRootInstructions(config) {
@@ -2111,8 +2087,9 @@ function renderSubagentArtifacts(config) {
   )) {
     const content = renderClaudeCodeSubagent({
       name: role.name,
-      description: role.responsibility,
+      description: renderAgentRoutingDescription(role),
       model: getClaudeCodeAgentModel(role, config),
+      effort: getClaudeCodeAgentEffort(role, config),
       ...role.mode === "read-only" ? { disallowedTools: "Write, Edit" } : {},
       instructions: roleInstructions2(role, config)
     });
@@ -2194,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,
@@ -2226,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(
@@ -2267,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
   );
@@ -2276,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(
@@ -2301,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",
@@ -2309,7 +2320,7 @@ function commandItem(action, scope, projectRoot) {
           "plugin",
           "marketplace",
           "add",
-          MARKETPLACE_SOURCE,
+          MARKETPLACE_INSTALL_SOURCE,
           "--scope",
           scope
         ],
@@ -2383,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."
     ],
@@ -3604,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] };
@@ -3651,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);
@@ -3664,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"],
@@ -3690,6 +3883,9 @@ function inspectCodexManager(executor, cwd) {
       ready: false,
       marketplace: "unknown",
       plugin: "unknown",
+      legacyPluginIds: [],
+      legacyMarketplaceNames: [],
+      legacyMarketplaceConflicts: [],
       diagnostics
     };
   }
@@ -3705,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
   );
@@ -3717,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"],
@@ -3762,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."
     ]
   };
@@ -3804,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,
@@ -3822,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,
@@ -3833,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");
 }
@@ -3965,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" };
   }
@@ -3978,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" };
   }
@@ -3990,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",
@@ -4005,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) {
@@ -4172,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" }
   };
 }
@@ -4270,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
   });
@@ -4666,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([
@@ -4705,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
@@ -4739,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) {
@@ -4749,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}`);
   }
@@ -4759,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);
@@ -4782,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);
@@ -4790,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 = {}) {
@@ -5055,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);
@@ -5079,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",
@@ -6462,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
@@ -6500,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 {
@@ -6714,7 +7136,7 @@ var CODEX_DOCUMENTED_EFFORTS2 = /* @__PURE__ */ new Set([
   "max",
   "ultra"
 ]);
-var CLAUDE_CODE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var CLAUDE_CODE_EFFORTS2 = ["low", "medium", "high", "xhigh", "max"];
 function parseOpenCodeModels(output) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
@@ -6747,7 +7169,7 @@ function writableEfforts(harness, option) {
   }
   if (harness === "claude") {
     return option.efforts.filter(
-      (effort) => CLAUDE_CODE_EFFORTS.includes(effort)
+      (effort) => CLAUDE_CODE_EFFORTS2.includes(effort)
     );
   }
   return option.efforts.filter(
@@ -6798,7 +7220,7 @@ var CLAUDE_CODE_MODEL_OPTIONS = [
   }
 ].map((option) => ({
   ...option,
-  efforts: option.id === "inherit" ? [] : [...CLAUDE_CODE_EFFORTS],
+  efforts: option.id === "inherit" ? [] : [...CLAUDE_CODE_EFFORTS2],
   source: "manual"
 }));
 async function getModelOptions(harness) {
@@ -6835,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 = {
@@ -6877,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,