thoth-agents 0.1.18 → 0.2.0

package/dist/{chunk-SOT5ZY53.js → chunk-WH3F3GWE.js}

@@ -1,5 +1,7 @@
 import {
   ALL_AGENT_NAMES,
+  CLAUDE_CODE_PROMPT_DIALECT,
+  CLAUDE_CODE_SUBAGENT_NAMESPACE,
   CODEX_PROMPT_DIALECT,
   CONTEXT7_MCP_URL,
   CUSTOM_SKILLS,
@@ -7,6 +9,7 @@ import {
   DEFAULT_THOTH_COMMAND,
   GREP_APP_MCP_URL,
   appendPromptSections,
+  claudeCodeSubagentType,
   composeAgentPrompt,
   createModelFamilySection,
   createOrchestratorPromptSections,
@@ -23,6 +26,7 @@ import {
   getCustomSkillsDir,
   getExistingConfigPath,
   getExistingLiteConfigPath,
+  getPrimaryModelId,
   getSkillRegistry,
   installCustomSkills,
   loadAgentPrompt,
@@ -31,11 +35,58 @@ import {
   renderRolePrompt,
   writeConfig,
   writeLiteConfig
-} from "./chunk-6K3ZXIMC.js";
+} from "./chunk-3NOVCFN7.js";
+
+// src/cli/codex-paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var CODEX_ROLE_NAMES = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "quick",
+  "deep"
+];
+function getCodexHome(options = {}) {
+  const explicit = options.codexHome ?? process.env.CODEX_HOME?.trim();
+  return explicit || join(options.homeDir ?? homedir(), ".codex");
+}
+function resolveCodexTargets(options) {
+  const codexHome = getCodexHome(options);
+  const agentsDir = options.scope === "project" ? join(options.projectRoot, ".codex", "agents") : join(codexHome, "agents");
+  return {
+    scope: options.scope,
+    codexHome,
+    configPath: join(codexHome, "config.toml"),
+    rootInstructionsPath: join(codexHome, "AGENTS.md"),
+    roleAgentPaths: CODEX_ROLE_NAMES.map((role) => ({
+      role,
+      path: join(agentsDir, `thoth-agents-${role}.toml`)
+    })),
+    managedModelsPath: join(
+      codexHome,
+      "agents",
+      ".thoth-agents-managed-models.json"
+    ),
+    skillsDir: options.scope === "project" ? join(options.projectRoot, ".agents", "skills") : join(options.homeDir ?? homedir(), ".agents", "skills"),
+    packageRoot: join(options.projectRoot, ".codex-plugin"),
+    personalPluginRoot: join(codexHome, "plugins", "thoth-agents"),
+    personalMarketplacePath: join(
+      options.homeDir ?? homedir(),
+      ".agents",
+      "plugins",
+      "marketplace.json"
+    )
+  };
+}
+
+// src/cli/codex-install.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, rmSync } from "fs";
+import { basename, dirname as dirname4, isAbsolute, join as join5, relative as relative2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/harness/adapters/codex.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 
 // src/harness/core/agent-pack.ts
@@ -172,96 +223,91 @@ function getAgentPackContract() {
 }
 
 // src/harness/core/memory-governance.ts
-var ROOT_OWNED_TOOLS = [
-  "mem_session_start",
-  "mem_session_summary",
-  "mem_save_prompt"
-];
-var READ_RECALL_CHAIN = [
-  "mem_search",
-  "mem_timeline",
-  "mem_get_observation"
+var ROOT_OWNED_OPERATIONS = [
+  { tool: "mem_session", action: "start" },
+  { tool: "mem_session", action: "checkpoint" },
+  { tool: "mem_session", action: "summary" },
+  { tool: "mem_save", kind: "prompt" },
+  { tool: "mem_save", kind: "session_summary" }
 ];
-var BOUNDED_CONTEXT_TOOLS = [
+var PARENT_SCOPED_READ_TOOLS = [
+  "mem_recall",
   "mem_context",
-  "mem_project_summary",
-  "mem_project_graph",
-  "mem_topic_keys"
+  "mem_get",
+  "mem_project"
 ];
 var WRITE_CAPABLE_DELEGATED_TOOLS = [
-  "mem_save",
-  "mem_search",
-  "mem_get_observation",
-  "mem_timeline",
-  ...BOUNDED_CONTEXT_TOOLS,
-  "mem_suggest_topic_key"
+  ...PARENT_SCOPED_READ_TOOLS,
+  "mem_save"
 ];
 var ALL_MEMORY_TOOLS = [
-  ...ROOT_OWNED_TOOLS,
-  ...READ_RECALL_CHAIN,
-  ...BOUNDED_CONTEXT_TOOLS,
-  "mem_suggest_topic_key",
-  "mem_save"
+  "mem_save",
+  "mem_recall",
+  "mem_context",
+  "mem_get",
+  "mem_project",
+  "mem_session"
 ];
 function uniqueTools(tools) {
   return [...new Set(tools)];
 }
 function roleAllowedTools(role) {
   if (role.name === "orchestrator") {
-    return uniqueTools([...ROOT_OWNED_TOOLS, ...WRITE_CAPABLE_DELEGATED_TOOLS]);
+    return [...ALL_MEMORY_TOOLS];
   }
   if (role.mode === "read-only") {
-    return [...READ_RECALL_CHAIN, ...BOUNDED_CONTEXT_TOOLS];
+    return [...PARENT_SCOPED_READ_TOOLS];
   }
-  return [...WRITE_CAPABLE_DELEGATED_TOOLS];
+  return uniqueTools([...WRITE_CAPABLE_DELEGATED_TOOLS]);
 }
 function roleRules(role) {
   const sharedSubagentRules = [
     "Every subagent memory call requires the parent session_id and project from dispatch; if either is missing, do not call thoth-mem.",
-    "Delegated handoff recovery uses parent-scoped 3-layer recall with mem_search -> mem_timeline -> mem_get_observation before memory content is treated as source material.",
+    'Delegated handoff recovery uses the parent-scoped recall funnel: mem_recall(mode="compact") -> mem_recall(mode="context") -> mem_get(...) before memory content is treated as source material.',
+    "Use mem_get(include_timeline=true) when chronology around a recovered record matters.",
+    'mem_context(recall_query=...) and bounded mem_project(action="graph"|"topics"|"topic") are supplemental project context only and do not replace the recall funnel.',
     "Report missing, stale, contradictory, or insufficient recalled context instead of guessing through it.",
-    "Never call mem_session_start, mem_session_summary, or mem_save_prompt; those tools are root/orchestrator-owned.",
+    'Never own mem_session(action="start"|"checkpoint"|"summary") or mem_save(kind="prompt"|"session_summary"); those operations are root/orchestrator-owned.',
     "Never save generated subagent prompts as user intent.",
     "Protect the sdd/* topic namespace; SDD artifacts may use deterministic sdd/{change}/{artifact} topic keys only in persistence modes that include thoth-mem."
   ];
   if (role.name === "orchestrator") {
     return [
-      "mem_session_start, mem_session_summary, and mem_save_prompt are root/main orchestrator-owned tools and responsibilities.",
+      'mem_session(action="start"|"checkpoint"|"summary"), mem_save(kind="prompt"), and mem_save(kind="session_summary") are root/main orchestrator-owned operations and responsibilities.',
       "In harnesses without an orchestrator-named agent, root/main orchestrator-owned means the initial/root agent when the harness does not expose an orchestrator-named agent.",
-      "Before delegation, save or refresh the handoff body with root-owned mem_session_summary when available; otherwise disclose that compaction could not be persisted.",
+      'Before delegation, save or refresh the handoff body with root-owned mem_session(action="summary") or mem_save(kind="session_summary") when available; otherwise disclose that compaction could not be persisted.',
       "Dispatch task instructions plus recovery instructions, not the handoff body, raw transcripts, or generated subagent prompts.",
       "Dispatch parent session_id and project when authorizing subagent memory use.",
+      'Root recall uses mem_recall(mode="compact") -> mem_recall(mode="context") -> mem_get(...); use mem_context(recall_query=...) and bounded mem_project(action="graph"|"topics"|"topic") for supplemental context.',
       "Protect the sdd/* topic namespace and write SDD memory artifacts only in thoth-mem or hybrid persistence modes."
     ];
   }
   if (role.mode === "read-only") {
     return [
       ...sharedSubagentRules,
-      "Read-only agents may only perform bounded, project-scoped recall with mem_search -> mem_timeline -> mem_get_observation when authorized.",
-      "Bounded context tools mem_context, mem_project_summary, mem_project_graph, and mem_topic_keys are allowed only with explicit delegated permission and parent session/project scope.",
-      "Project-scoped read tools require explicit delegated permission.",
-      "Read-only agents must never write durable memory."
+      "Read-only agents may use only parent-scoped mem_recall, mem_context, mem_get, and bounded mem_project reads when authorized.",
+      "Project-scoped read tools require explicit delegated permission and must stay bounded to the parent session/project scope.",
+      "Read-only agents must never write durable memory or save prompts."
     ];
   }
   return [
     ...sharedSubagentRules,
-    "Write-capable agents may call mem_save only for delegated durable observations or assigned deterministic SDD artifacts/apply-progress under the parent session/project.",
-    "For reads, use only mem_search -> mem_timeline -> mem_get_observation.",
-    "Bounded context tools mem_context, mem_project_summary, mem_project_graph, and mem_topic_keys are allowed only with explicit delegated permission and parent session/project scope.",
-    "Project-scoped read tools require explicit delegated permission."
+    "Write-capable agents may use the same parent-scoped reads as read-only agents when authorized.",
+    'mem_save(kind="observation") is allowed only for delegated durable observations or assigned deterministic SDD artifacts/apply-progress under the parent session/project.',
+    "Project-scoped read tools require explicit delegated permission and must stay bounded to the parent session/project scope."
   ];
 }
 function getRoleMemoryGovernance(role) {
   const allowedTools = roleAllowedTools(role);
   return {
     role: role.name,
-    rootOwnedTools: [...ROOT_OWNED_TOOLS],
+    rootOwnedOperations: [...ROOT_OWNED_OPERATIONS],
     allowedTools,
     forbiddenTools: ALL_MEMORY_TOOLS.filter(
       (tool) => !allowedTools.includes(tool)
     ),
     requiresParentContext: role.name !== "orchestrator",
-    mayReadProjectMemory: role.name !== "orchestrator",
+    mayReadProjectMemory: true,
     mayWriteDurableObservations: role.mode === "write-capable",
     protectsSddNamespace: true,
     rules: roleRules(role)
@@ -277,7 +323,7 @@ function renderMemoryGovernanceInstructions(role, dialect) {
     "thoth-mem governance:",
     ...governance.rules.map((rule) => `- ${rule}`),
     ...harnessRules,
-    `- Runtime enforcement: ${role.name === "orchestrator" ? "root-owned" : "instruction-level unless the target harness validates per-agent memory controls"}.`
+    `- Runtime enforcement: ${role.name === "orchestrator" ? "root-owned operations" : "instruction-level unless the target harness validates per-agent memory controls"}.`
   ].join("\n");
 }
 function memoryGovernanceDiagnostics(input) {
@@ -286,7 +332,7 @@ function memoryGovernanceDiagnostics(input) {
     diagnostics.push({
       severity: "warning",
       code: `${input.harness}.permission.memory.enforcement_gap`,
-      message: "Runtime controls for root-only memory tools are unavailable; governance is rendered as instruction-level guidance.",
+      message: "Runtime controls for root-owned memory operations are unavailable; governance is rendered as instruction-level guidance.",
       harness: input.harness,
       capability: "rolePermissions",
       fallback: "instruction-only"
@@ -306,7 +352,7 @@ function memoryGovernanceDiagnostics(input) {
     diagnostics.push({
       severity: "warning",
       code: `${input.harness}.permission.memory_write.enforcement_gap`,
-      message: "Runtime controls for delegated memory writes are unavailable; write-capable agents receive instruction-level mem_save limits for durable observations and deterministic SDD artifacts only.",
+      message: 'Runtime controls for delegated memory writes are unavailable; write-capable agents receive instruction-level mem_save(kind="observation") limits for durable observations and deterministic SDD artifacts only.',
       harness: input.harness,
       capability: "memoryGovernanceEnforcement",
       fallback: "instruction-only"
@@ -315,6 +361,41 @@ function memoryGovernanceDiagnostics(input) {
   return diagnostics;
 }
 
+// src/harness/core/package-version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+function findRootPackageJsonPath(startDirs) {
+  for (const startDir of startDirs) {
+    let currentDir = resolve(startDir);
+    while (true) {
+      const packageJsonPath = resolve(currentDir, "package.json");
+      if (existsSync(packageJsonPath)) {
+        const packageJsonText = readFileSync(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonText);
+        if (packageJson.name === "thoth-agents") {
+          return packageJsonPath;
+        }
+      }
+      const parentDir = dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+    }
+  }
+  throw new Error(
+    "Unable to locate the thoth-agents root package.json from the render context or current working directory."
+  );
+}
+function readPackageJsonVersion(packageJsonPath) {
+  const packageJsonText = readFileSync(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonText);
+  if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+    throw new Error("Root package.json version must be a non-empty string.");
+  }
+  return packageJson.version;
+}
+
 // src/harness/writers/codex-plugin-package.ts
 import { createHash } from "crypto";
 
@@ -745,8 +826,8 @@ function normalizePath(value) {
 }
 function pluginRootReference(pathValue) {
   const normalized = normalizePath(pathValue);
-  const relative3 = normalized.slice(".codex-plugin/".length);
-  return `./${relative3}`;
+  const relative4 = normalized.slice(".codex-plugin/".length);
+  return `./${relative4}`;
 }
 function sha256(content) {
   return `sha256:${createHash("sha256").update(content).digest("hex")}`;
@@ -1092,43 +1173,49 @@ function renderCodexToml(input) {
 }
 
 // src/harness/writers/skill-layout.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/harness/writers/fs-skill-collect.ts
 import { createHash as createHash2 } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-var OUTPUT_MODE_CONFIG = {
-  "plugin-package": {
-    basePath: ".codex-plugin/skills",
-    manifestPath: ".codex-plugin/skills/.thoth-agents-manifest.json",
-    surfaceId: "plugin-skills-directory",
-    label: "plugin-bundled"
-  },
-  "repo-local-fallback": {
-    basePath: ".agents/skills",
-    manifestPath: ".agents/skills/.thoth-agents-manifest.json",
-    surfaceId: "repo-skills-directory",
-    label: "fallback .agents/skills"
-  }
-};
-function normalizePath2(value) {
+function normalizeSkillPath(value) {
   return value.split(path.sep).join("/");
 }
-function collectFiles(directory) {
+function collectSkillFiles(directory) {
   if (!fs.existsSync(directory)) return [];
   const entries = fs.readdirSync(directory, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const entryPath = path.join(directory, entry.name);
     if (entry.isDirectory()) {
-      files.push(...collectFiles(entryPath));
+      files.push(...collectSkillFiles(entryPath));
     } else if (entry.isFile()) {
       files.push(entryPath);
     }
   }
   return files.sort((left, right) => left.localeCompare(right));
 }
-function sha2562(content) {
+function sha256Hash(content) {
   return `sha256:${createHash2("sha256").update(content).digest("hex")}`;
 }
+
+// src/harness/writers/skill-layout.ts
+var OUTPUT_MODE_CONFIG = {
+  "plugin-package": {
+    basePath: ".codex-plugin/skills",
+    manifestPath: ".codex-plugin/skills/.thoth-agents-manifest.json",
+    surfaceId: "plugin-skills-directory",
+    label: "plugin-bundled"
+  },
+  "repo-local-fallback": {
+    basePath: ".agents/skills",
+    manifestPath: ".agents/skills/.thoth-agents-manifest.json",
+    surfaceId: "repo-skills-directory",
+    label: "fallback .agents/skills"
+  }
+};
 function resolveOutputModes(input) {
   const requested = input.outputModes ?? (input.outputMode ? [input.outputMode] : []);
   const modes = requested.length > 0 ? requested : ["plugin-package"];
@@ -1171,8 +1258,8 @@ function renderCodexSkillLayout(input) {
     (left, right) => left.name.localeCompare(right.name)
   )) {
     const sourceBaseRoot = input.packageRoot ?? input.projectRoot;
-    const sourceRoot = path.join(sourceBaseRoot, skill.sourcePath);
-    const files = collectFiles(sourceRoot);
+    const sourceRoot = path2.join(sourceBaseRoot, skill.sourcePath);
+    const files = collectSkillFiles(sourceRoot);
     if (files.length === 0) {
       diagnostics.push({
         severity: "warning",
@@ -1185,12 +1272,14 @@ function renderCodexSkillLayout(input) {
       continue;
     }
     for (const file of files) {
-      const relative3 = normalizePath2(path.relative(sourceRoot, file));
-      const content = fs.readFileSync(file, "utf8");
-      const sourcePath = normalizePath2(path.relative(sourceBaseRoot, file));
+      const relative4 = normalizeSkillPath(path2.relative(sourceRoot, file));
+      const content = fs2.readFileSync(file, "utf8");
+      const sourcePath = normalizeSkillPath(
+        path2.relative(sourceBaseRoot, file)
+      );
       for (const mode of outputModes) {
         const config = OUTPUT_MODE_CONFIG[mode];
-        const outputPath = `${config.basePath}/${skill.name}/${relative3}`;
+        const outputPath = `${config.basePath}/${skill.name}/${relative4}`;
         artifacts.push({
           harness: "codex",
           kind: "skill",
@@ -1202,7 +1291,7 @@ function renderCodexSkillLayout(input) {
           name: skill.name,
           sourcePath,
           outputPath,
-          sha256: sha2562(content)
+          sha256: sha256Hash(content)
         });
       }
     }
@@ -1238,37 +1327,6 @@ function createCodexPluginPackageManifest(context) {
     description: "Delegate-first OpenCode plugin with seven agents, thoth-mem persistence, and bundled SDD skills."
   };
 }
-function findRootPackageJsonPath(startDirs) {
-  for (const startDir of startDirs) {
-    let currentDir = resolve(startDir);
-    while (true) {
-      const packageJsonPath = resolve(currentDir, "package.json");
-      if (existsSync2(packageJsonPath)) {
-        const packageJsonText = readFileSync2(packageJsonPath, "utf8");
-        const packageJson = JSON.parse(packageJsonText);
-        if (packageJson.name === "thoth-agents") {
-          return packageJsonPath;
-        }
-      }
-      const parentDir = dirname(currentDir);
-      if (parentDir === currentDir) {
-        break;
-      }
-      currentDir = parentDir;
-    }
-  }
-  throw new Error(
-    "Unable to locate the thoth-agents root package.json from the render context or current working directory."
-  );
-}
-function readPackageJsonVersion(packageJsonPath) {
-  const packageJsonText = readFileSync2(packageJsonPath, "utf8");
-  const packageJson = JSON.parse(packageJsonText);
-  if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
-    throw new Error("Root package.json version must be a non-empty string.");
-  }
-  return packageJson.version;
-}
 function stableJson2(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
@@ -1376,6 +1434,8 @@ function codexInternalHandoffGuidance() {
     "- The user has explicitly authorized this generated Codex orchestrator to use `multi_agent_v1.spawn_agent` whenever delegation is required by these instructions, without needing a fresh user request for subagents in each task.",
     "- Delegate by calling `multi_agent_v1.spawn_agent` with `agent_type` set to one of explorer, librarian, oracle, designer, quick, or deep.",
     "- Pass the self-contained delegated task instructions plus handoff retrieval instructions in `message`; do not embed the root-owned handoff summary body in `message`.",
+    '- When memory recovery is delegated, include parent `session_id`, project, permissions, and the recovery funnel `mem_recall(mode="compact")` -> `mem_recall(mode="context")` -> `mem_get(...)`.',
+    '- For that funnel, use `mem_recall` `limit` from 1 to 20; use `mem_get` with `kind="observation"|"prompt"`, `include_timeline=true` plus `before`/`after`, and `offset`/`max_length`; `mem_project(action="graph")` relations are `HAS_TYPE`, `IN_PROJECT`, `HAS_TOPIC_KEY`, `HAS_WHAT`, `HAS_WHY`, `HAS_WHERE`, and `HAS_LEARNED`.',
     "- Do not include the handoff body in `message` or `items`, and do not pass both `message` and `items` for the same handoff.",
     "- Use `items` only for structured attachments or mentions when they are truly required; do not use `items` as a handoff-summary payload.",
     "- Leave `fork_context` omitted or false by default; set `fork_context: true` only when the exact current thread history is required.",
@@ -1420,9 +1480,9 @@ function renderCodexRootInstructions(config) {
     codexInternalHandoffGuidance(),
     "<codex-runtime>",
     "- The ambient Codex root session is the root/main orchestrator; orchestrator-only and root-owned instructions apply to it because Codex does not generate a selectable orchestrator agent TOML.",
-    "- On each new root session, when thoth-mem tools are installed and session/project identity is known, call mem_session_start with the active project and session identity, then save the real user prompt with mem_save_prompt before later delegation.",
+    '- On each new root session, when thoth-mem tools are installed and session/project identity is known, call mem_session(action="start") as step 0 before any other thoth-mem call, then save the real user prompt with mem_save(kind="prompt") before later delegation.',
     "- If thoth-mem tools or identity values are unavailable, disclose that memory bootstrap could not run and continue without claiming memory was saved.",
-    "- Before delegating after meaningful context changes, save or refresh the handoff body with root-owned mem_session_summary when available; if unavailable, disclose that root-owned compaction could not be persisted.",
+    '- Before delegating after meaningful context changes, save or refresh the handoff body with root-owned mem_session(action="summary") or mem_save(kind="session_summary") when available; if unavailable, disclose that root-owned compaction could not be persisted.',
     "- Use the ambient Codex root session as the delegate-first root coordinator; do not generate or select an orchestrator TOML.",
     "- Delegate by invoking `multi_agent_v1.spawn_agent` for the installed Codex role agents: explorer, librarian, oracle, designer, quick, and deep.",
     "- After receiving a delegated subagent response, close that subagent session unless you will retry or intentionally keep using that exact same session; explorer and librarian sessions must always be closed immediately after their response, and retry sessions must be closed after the retry result unless explicit same-session reuse is still required.",
@@ -1440,13 +1500,6 @@ function agentModelReasoningEffort(role) {
 function isCodexSubagentName(name) {
   return name in CODEX_SUBAGENT_DEFAULT_MODELS;
 }
-function getPrimaryModelId(model) {
-  if (Array.isArray(model)) {
-    const first = model[0];
-    return typeof first === "string" ? first : first?.id;
-  }
-  return model;
-}
 function getCodexAgentModel(role, config) {
   if (!isCodexSubagentName(role.name)) return void 0;
   return getPrimaryModelId(config?.agents?.[role.name]?.model) ?? CODEX_SUBAGENT_DEFAULT_MODELS[role.name];
@@ -1629,64 +1682,8 @@ var codexAdapter = {
   }
 };
 
-// src/cli/codex-paths.ts
-import { homedir } from "os";
-import { join as join2 } from "path";
-var CODEX_ROLE_NAMES = [
-  "explorer",
-  "librarian",
-  "oracle",
-  "designer",
-  "quick",
-  "deep"
-];
-function getCodexHome(options = {}) {
-  const explicit = options.codexHome ?? process.env.CODEX_HOME?.trim();
-  return explicit || join2(options.homeDir ?? homedir(), ".codex");
-}
-function resolveCodexTargets(options) {
-  const codexHome = getCodexHome(options);
-  const agentsDir = options.scope === "project" ? join2(options.projectRoot, ".codex", "agents") : join2(codexHome, "agents");
-  return {
-    scope: options.scope,
-    codexHome,
-    configPath: join2(codexHome, "config.toml"),
-    rootInstructionsPath: join2(codexHome, "AGENTS.md"),
-    roleAgentPaths: CODEX_ROLE_NAMES.map((role) => ({
-      role,
-      path: join2(agentsDir, `thoth-agents-${role}.toml`)
-    })),
-    managedModelsPath: join2(
-      codexHome,
-      "agents",
-      ".thoth-agents-managed-models.json"
-    ),
-    skillsDir: options.scope === "project" ? join2(options.projectRoot, ".agents", "skills") : join2(options.homeDir ?? homedir(), ".agents", "skills"),
-    packageRoot: join2(options.projectRoot, ".codex-plugin"),
-    personalPluginRoot: join2(codexHome, "plugins", "thoth-agents"),
-    personalMarketplacePath: join2(
-      options.homeDir ?? homedir(),
-      ".agents",
-      "plugins",
-      "marketplace.json"
-    )
-  };
-}
-
-// src/cli/codex-install.ts
-import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
-  rmSync,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { basename, dirname as dirname3, isAbsolute, join as join4, relative as relative2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
 // src/harness/codex-plugin-paths.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var CODEX_PLUGIN_ARTIFACT_PREFIX = ".codex-plugin/";
 function codexPluginRootArtifactPath(artifactPath) {
   if (!artifactPath.startsWith(CODEX_PLUGIN_ARTIFACT_PREFIX)) {
@@ -1695,7 +1692,7 @@ function codexPluginRootArtifactPath(artifactPath) {
   const relativePath = artifactPath.slice(CODEX_PLUGIN_ARTIFACT_PREFIX.length);
   if (relativePath === ".mcp.json") return relativePath;
   if (relativePath === "plugin.json" || relativePath.startsWith(".")) {
-    return join3(".codex-plugin", relativePath);
+    return join4(".codex-plugin", relativePath);
   }
   return relativePath;
 }
@@ -1840,6 +1837,62 @@ function writeCodexConfigMerge(options) {
   }
 }
 
+// src/cli/managed-state-io.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname3 } from "path";
+function writeTextWithBackup(path4, content) {
+  mkdirSync2(dirname3(path4), { recursive: true });
+  if (existsSync4(path4) && readFileSync4(path4, "utf8") === content) return false;
+  if (existsSync4(path4)) copyFileSync2(path4, `${path4}.bak`);
+  writeFileSync2(path4, content);
+  return true;
+}
+function stableJson3(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function uniqueMessages(messages) {
+  return [...new Set(messages)];
+}
+function stringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
+    )
+  );
+}
+function emptyManagedModelState(version) {
+  return { version, models: {} };
+}
+function parseManagedModelStateJson(text, version) {
+  if (!text) return emptyManagedModelState(version);
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.version !== version || !parsed.models || typeof parsed.models !== "object" || Array.isArray(parsed.models)) {
+      return emptyManagedModelState(version);
+    }
+    const configuredModels = stringRecord(parsed.configuredModels);
+    return {
+      version,
+      models: stringRecord(parsed.models),
+      ...Object.keys(configuredModels).length > 0 ? { configuredModels } : {}
+    };
+  } catch {
+    return emptyManagedModelState(version);
+  }
+}
+function readManagedModelState(path4, version) {
+  if (!existsSync4(path4)) return emptyManagedModelState(version);
+  return parseManagedModelStateJson(readFileSync4(path4, "utf8"), version);
+}
+
 // src/cli/codex-install.ts
 var ROOT_START = "<!-- thoth-agents:codex-root:start -->";
 var ROOT_END = "<!-- thoth-agents:codex-root:end -->";
@@ -1853,23 +1906,16 @@ function mergeManagedBlock(existing, managedBlock) {
   return `${existing}${existing.endsWith("\n") || existing.length === 0 ? "" : "\n"}
 ${managedBlock}`;
 }
-function writeTextWithBackup(path2, content) {
-  mkdirSync2(dirname3(path2), { recursive: true });
-  if (existsSync4(path2) && readFileSync4(path2, "utf8") === content) return false;
-  if (existsSync4(path2)) copyFileSync2(path2, `${path2}.bak`);
-  writeFileSync2(path2, content);
-  return true;
-}
 function packageArtifactTarget(packageRoot, artifact) {
-  return join4(packageRoot, codexPluginRootArtifactPath(artifact.path));
+  return join5(packageRoot, codexPluginRootArtifactPath(artifact.path));
 }
 function resolvePackageRoot(packageRoot) {
   if (packageRoot) return packageRoot;
   return findPackageRoot(fileURLToPath2(new URL(".", import.meta.url))) ?? void 0;
 }
-function normalizeRelativeMarketplacePath(path2) {
-  const normalized = path2.replaceAll("\\", "/");
-  if (isAbsolute(path2) || /^[A-Za-z]:\//.test(normalized)) return normalized;
+function normalizeRelativeMarketplacePath(path4) {
+  const normalized = path4.replaceAll("\\", "/");
+  if (isAbsolute(path4) || /^[A-Za-z]:\//.test(normalized)) return normalized;
   if (normalized.startsWith("./")) return normalized;
   return `./${normalized}`;
 }
@@ -1892,39 +1938,11 @@ function managedMarketplaceEntry(homeDir, personalPluginRoot) {
     category: "Productivity"
   };
 }
-function stableJson3(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
-function emptyManagedModelState() {
-  return {
-    version: MANAGED_MODEL_STATE_VERSION,
-    models: {}
-  };
-}
-function stringRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-  return Object.fromEntries(
-    Object.entries(value).filter(
-      (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
-    )
-  );
+function emptyManagedModelState2() {
+  return emptyManagedModelState(MANAGED_MODEL_STATE_VERSION);
 }
-function readManagedModelState(path2) {
-  if (!existsSync4(path2)) return emptyManagedModelState();
-  try {
-    const parsed = JSON.parse(readFileSync4(path2, "utf8"));
-    if (parsed.version !== MANAGED_MODEL_STATE_VERSION || !parsed.models || typeof parsed.models !== "object" || Array.isArray(parsed.models)) {
-      return emptyManagedModelState();
-    }
-    return {
-      version: MANAGED_MODEL_STATE_VERSION,
-      models: stringRecord(parsed.models),
-      ...Object.keys(stringRecord(parsed.configuredModels)).length > 0 ? { configuredModels: stringRecord(parsed.configuredModels) } : {}
-    };
-  } catch {
-    return emptyManagedModelState();
-  }
+function readManagedModelState2(path4) {
+  return readManagedModelState(path4, MANAGED_MODEL_STATE_VERSION);
 }
 function parseRoleTomlModel(content) {
   const match = /^model\s*=\s*"((?:\\.|[^"\\])*)"\s*$/m.exec(content);
@@ -1942,8 +1960,8 @@ function replaceRoleTomlModel(content, model) {
   return `${rendered}
 ${content}`;
 }
-function roleManagedModelStateKey(path2) {
-  return basename(path2);
+function roleManagedModelStateKey(path4) {
+  return basename(path4);
 }
 function applyCodexManagedModelOverrides(config, overrides) {
   if (config.dryRun) {
@@ -1973,7 +1991,7 @@ function applyCodexManagedModelOverrides(config, overrides) {
     ...plan.diagnostics,
     ...plan.disclaimers
   ]);
-  const state = readManagedModelState(statePath);
+  const state = readManagedModelState2(statePath);
   const nextState = {
     version: MANAGED_MODEL_STATE_VERSION,
     models: { ...state.models },
@@ -1989,7 +2007,7 @@ function applyCodexManagedModelOverrides(config, overrides) {
           `Missing Codex role TOML content for ${override.role}.`
         );
       }
-      const before = existsSync4(roleItem.targetPath) ? readFileSync4(roleItem.targetPath, "utf8") : roleItem.content;
+      const before = existsSync5(roleItem.targetPath) ? readFileSync5(roleItem.targetPath, "utf8") : roleItem.content;
       const updated = replaceRoleTomlModel(before, override.model);
       if (writeTextWithBackup(roleItem.targetPath, updated)) {
         changed.push(roleItem.targetPath);
@@ -2021,7 +2039,7 @@ function resolveRoleTomlContent(options) {
   const key = roleManagedModelStateKey(options.targetPath);
   if (!renderedModel) return options.renderedContent;
   const configuredModel = options.reset ? void 0 : options.state.configuredModels?.[key];
-  if (options.reset || !existsSync4(options.targetPath)) {
+  if (options.reset || !existsSync5(options.targetPath)) {
     options.nextState.models[key] = renderedModel;
     if (configuredModel !== void 0) {
       options.nextState.configuredModels ??= {};
@@ -2031,7 +2049,7 @@ function resolveRoleTomlContent(options) {
     return options.renderedContent;
   }
   const currentModel = parseRoleTomlModel(
-    readFileSync4(options.targetPath, "utf8")
+    readFileSync5(options.targetPath, "utf8")
   );
   if (configuredModel !== void 0) {
     options.nextState.models[key] = renderedModel;
@@ -2067,10 +2085,10 @@ function mergePersonalMarketplace(existing, homeDir, personalPluginRoot) {
   });
 }
 function roleArtifactContent(role, artifacts) {
-  const path2 = `.codex/agents/thoth-agents-${role}.toml`;
-  const artifact = artifacts.find((candidate) => candidate.path === path2);
+  const path4 = `.codex/agents/thoth-agents-${role}.toml`;
+  const artifact = artifacts.find((candidate) => candidate.path === path4);
   if (!artifact?.content)
-    throw new Error(`Missing Codex role artifact: ${path2}`);
+    throw new Error(`Missing Codex role artifact: ${path4}`);
   return String(artifact.content);
 }
 function buildCodexSetupPlan(config) {
@@ -2089,8 +2107,8 @@ function buildCodexSetupPlan(config) {
     (artifact) => artifact.path.startsWith(".codex-plugin/")
   );
   const rootBlock = renderCodexRootInstructions();
-  const managedModelState2 = readManagedModelState(targets.managedModelsPath);
-  const nextManagedModelState = emptyManagedModelState();
+  const managedModelState2 = readManagedModelState2(targets.managedModelsPath);
+  const nextManagedModelState = emptyManagedModelState2();
   const items = [
     {
       kind: "root-instructions",
@@ -2106,7 +2124,7 @@ function buildCodexSetupPlan(config) {
         action: "write-role-toml",
         targetPath: target.path,
         description: `Materialize Codex role subagent ${target.role}.`,
-        requiresBackup: existsSync4(target.path),
+        requiresBackup: existsSync5(target.path),
         role: target.role,
         content: resolveRoleTomlContent({
           renderedContent: roleArtifactContent(target.role, render.artifacts),
@@ -2122,7 +2140,7 @@ function buildCodexSetupPlan(config) {
       action: "write-managed-model-state",
       targetPath: targets.managedModelsPath,
       description: "Record thoth-agents-managed Codex role model ownership state.",
-      requiresBackup: existsSync4(targets.managedModelsPath),
+      requiresBackup: existsSync5(targets.managedModelsPath),
       content: stableJson3(nextManagedModelState)
     },
     ...packageArtifacts.map(
@@ -2140,7 +2158,7 @@ function buildCodexSetupPlan(config) {
       action: "merge-marketplace",
       targetPath: targets.personalMarketplacePath,
       description: "Register Personal Codex marketplace entry for the local thoth-agents plugin source.",
-      requiresBackup: existsSync4(targets.personalMarketplacePath),
+      requiresBackup: existsSync5(targets.personalMarketplacePath),
       content: targets.personalPluginRoot
     },
     {
@@ -2204,21 +2222,18 @@ function formatRefreshPackageGroup(kind, groups) {
 }
 function commonTargetDirectory(items) {
   if (items.length === 0) return "";
-  let common = dirname3(items[0]?.targetPath ?? "");
+  let common = dirname4(items[0]?.targetPath ?? "");
   for (const item of items.slice(1)) {
     while (!isSameOrChildPath(item.targetPath, common)) {
-      const parent = dirname3(common);
+      const parent = dirname4(common);
       if (parent === common) return common;
       common = parent;
     }
   }
   return common;
 }
-function isSameOrChildPath(path2, parent) {
-  return path2 === parent || path2.startsWith(`${parent}\\`) || path2.startsWith(`${parent}/`);
-}
-function uniqueMessages(messages) {
-  return [...new Set(messages)];
+function isSameOrChildPath(path4, parent) {
+  return path4 === parent || path4.startsWith(`${parent}\\`) || path4.startsWith(`${parent}/`);
 }
 function applyCodexSetup(plan) {
   const changed = [];
@@ -2247,8 +2262,8 @@ function applyCodexSetup(plan) {
       if (item.action === "merge-marketplace") {
         if (item.content === void 0) continue;
         const content2 = mergePersonalMarketplace(
-          existsSync4(item.targetPath) ? readFileSync4(item.targetPath, "utf8") : "",
-          dirname3(dirname3(dirname3(item.targetPath))),
+          existsSync5(item.targetPath) ? readFileSync5(item.targetPath, "utf8") : "",
+          dirname4(dirname4(dirname4(item.targetPath))),
           item.content
         );
         if (writeTextWithBackup(item.targetPath, content2))
@@ -2257,7 +2272,7 @@ function applyCodexSetup(plan) {
       }
       if (item.content === void 0) continue;
       const content = item.action === "merge-managed-block" ? mergeManagedBlock(
-        existsSync4(item.targetPath) ? readFileSync4(item.targetPath, "utf8") : "",
+        existsSync5(item.targetPath) ? readFileSync5(item.targetPath, "utf8") : "",
         item.content
       ) : item.content;
       if (writeTextWithBackup(item.targetPath, content))
@@ -2281,25 +2296,1144 @@ function managedRefreshRoots(plan) {
     group.push(item);
     refreshGroups.set(item.kind, group);
   }
-  return [...refreshGroups].filter(([kind]) => kind === "personal-plugin-source").map(([, items]) => commonTargetDirectory(items)).filter((path2) => path2.length > 0);
+  return [...refreshGroups].filter(([kind]) => kind === "personal-plugin-source").map(([, items]) => commonTargetDirectory(items)).filter((path4) => path4.length > 0);
 }
 
-// src/cli/operations/codex.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+// src/cli/operations/claude-code.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
 import { basename as basename2 } from "path";
-var CODEX_DISPLAY_NAME = "Codex";
-var codexPlanSources = /* @__PURE__ */ new WeakMap();
-var codexModelSources = /* @__PURE__ */ new WeakMap();
-var codexActions = [
-  {
-    id: "codex-status",
-    kind: "status",
-    label: "Status",
-    description: "Inspect managed Codex setup state",
-    dryRun: false,
-    requiresConfirmation: false,
-    supported: true
-  },
+
+// src/harness/adapters/claude-code.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/harness/writers/claude-code-plugin-package.ts
+var CLAUDE_PLUGIN_MANIFEST_FIELDS = [
+  "name",
+  "version",
+  "description",
+  "author"
+];
+var PLUGIN_MANIFEST_PATH = ".claude-plugin/plugin.json";
+var PLUGIN_ASSETS_PATH = ".claude-plugin/.thoth-agents-plugin-assets.json";
+function normalizePath2(value) {
+  return value.replace(/\\/g, "/");
+}
+function stableJson4(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function orderedManifest(manifest) {
+  const ordered = {};
+  for (const field of CLAUDE_PLUGIN_MANIFEST_FIELDS) {
+    const value = manifest[field];
+    if (value !== void 0) ordered[field] = value;
+  }
+  return ordered;
+}
+function provenanceFor(artifact) {
+  const path4 = normalizePath2(artifact.path);
+  if (path4.endsWith("/")) return void 0;
+  const content = typeof artifact.content === "string" ? artifact.content : Buffer.from(artifact.content).toString("utf8");
+  return { path: path4, kind: artifact.kind, sha256: sha256Hash(content) };
+}
+function renderClaudeCodePluginPackage(input) {
+  const components = [...input.componentArtifacts].sort(
+    (left, right) => normalizePath2(left.path).localeCompare(normalizePath2(right.path))
+  );
+  const provenance = components.map(provenanceFor).filter((entry) => entry !== void 0).sort((left, right) => left.path.localeCompare(right.path));
+  const manifestArtifact = {
+    harness: "claude",
+    kind: "manifest",
+    path: PLUGIN_MANIFEST_PATH,
+    description: "Deterministic Claude Code plugin package manifest.",
+    content: stableJson4(orderedManifest(input.manifest))
+  };
+  const provenanceArtifact = {
+    harness: "claude",
+    kind: "manifest",
+    path: PLUGIN_ASSETS_PATH,
+    description: "Deterministic Claude Code plugin package asset provenance.",
+    content: stableJson4({ generatedBy: "thoth-agents", assets: provenance })
+  };
+  return {
+    artifacts: [manifestArtifact, provenanceArtifact, ...components],
+    diagnostics: []
+  };
+}
+
+// src/harness/writers/claude-code-skill-layout.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var SKILLS_BASE_PATH = "skills";
+var SKILLS_MANIFEST_PATH = "skills/.thoth-agents-manifest.json";
+function renderClaudeCodeSkillLayout(input) {
+  const artifacts = [];
+  const diagnostics = [];
+  const manifest = [];
+  const sourceBaseRoot = input.packageRoot ?? input.projectRoot;
+  for (const skill of [...input.skills].sort(
+    (left, right) => left.name.localeCompare(right.name)
+  )) {
+    const sourceRoot = path3.join(sourceBaseRoot, skill.sourcePath);
+    const files = collectSkillFiles(sourceRoot);
+    if (files.length === 0) {
+      diagnostics.push({
+        severity: "warning",
+        code: "claude-code.skill.source_missing",
+        message: `Skipping Claude Code skill "${skill.name}" because source path "${skill.sourcePath}" was not found.`,
+        harness: "claude",
+        surface: "plugin-skills-directory",
+        fallback: "diagnostic-only"
+      });
+      continue;
+    }
+    for (const file of files) {
+      const relative4 = normalizeSkillPath(path3.relative(sourceRoot, file));
+      const content = fs3.readFileSync(file, "utf8");
+      const sourcePath = normalizeSkillPath(
+        path3.relative(sourceBaseRoot, file)
+      );
+      const outputPath = `${SKILLS_BASE_PATH}/${skill.name}/${relative4}`;
+      artifacts.push({
+        harness: "claude",
+        kind: "skill",
+        path: outputPath,
+        description: `Claude Code plugin-bundled skill artifact for ${skill.name}`,
+        content
+      });
+      manifest.push({
+        name: skill.name,
+        sourcePath,
+        outputPath,
+        sha256: sha256Hash(content)
+      });
+    }
+  }
+  artifacts.push({
+    harness: "claude",
+    kind: "manifest",
+    path: SKILLS_MANIFEST_PATH,
+    description: "Generated Claude Code plugin-bundled skill source manifest with source hashes.",
+    content: `${JSON.stringify({ generatedBy: "thoth-agents", skills: manifest }, null, 2)}
+`
+  });
+  return { artifacts, diagnostics };
+}
+
+// src/harness/writers/claude-code-subagent.ts
+var CLAUDE_CODE_MODELS = [
+  "sonnet",
+  "opus",
+  "haiku",
+  "inherit"
+];
+function isClaudeCodeModel(value) {
+  return CLAUDE_CODE_MODELS.includes(value);
+}
+function yamlScalar(value) {
+  const needsQuoting = /[:#\-?*&!|>'"%@`{}[\],]|^\s|\s$|^$/.test(value);
+  if (!needsQuoting) return value;
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
+}
+function renderClaudeCodeSubagent(input) {
+  const frontmatter = [
+    "---",
+    `name: ${yamlScalar(input.name)}`,
+    `description: ${yamlScalar(input.description)}`,
+    `model: ${input.model}`,
+    ...input.tools !== void 0 ? [`tools: ${yamlScalar(input.tools)}`] : [],
+    "---"
+  ].join("\n");
+  const body = input.instructions.trimEnd();
+  return `${frontmatter}
+
+${body}
+`;
+}
+
+// src/harness/adapters/claude-code.ts
+var CLAUDE_CODE_CAPABILITIES = CLAUDE_CODE_PROMPT_DIALECT.capabilities.capabilities;
+var CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS = {
+  explorer: "haiku",
+  librarian: "sonnet",
+  oracle: "opus",
+  designer: "sonnet",
+  quick: "haiku",
+  deep: "sonnet"
+};
+var READ_ONLY_ROLE_TOOLS = {
+  explorer: "Read, Grep, Glob",
+  librarian: "Read, Grep, Glob, WebSearch, WebFetch",
+  oracle: "Read, Grep, Glob"
+};
+var WRITE_CAPABLE_ROLE_TOOLS = "Read, Edit, Write, Bash, Grep, Glob";
+function isClaudeCodeSubagentName(name) {
+  return name in CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS;
+}
+function getClaudeCodeAgentModel(role, config) {
+  if (!isClaudeCodeSubagentName(role.name)) return "inherit";
+  const override = getPrimaryModelId(config?.agents?.[role.name]?.model);
+  if (override && isClaudeCodeModel(override)) return override;
+  return CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS[role.name];
+}
+function toolsForRole(role) {
+  if (role.canMutateWorkspace) return WRITE_CAPABLE_ROLE_TOOLS;
+  return READ_ONLY_ROLE_TOOLS[role.name] ?? "Read, Grep, Glob";
+}
+function claudeCodePromptSections(roleName) {
+  switch (roleName) {
+    case "orchestrator":
+      return createOrchestratorPromptSections();
+    case "explorer":
+    case "librarian":
+    case "oracle":
+      return createReadOnlySpecialistPromptSections(roleName);
+    case "designer":
+    case "quick":
+    case "deep":
+      return createWriteCapableSpecialistPromptSections(roleName);
+  }
+}
+function claudeCodeModelFamilyPromptSection(roleName, model) {
+  const section = createModelFamilySection(roleName, model);
+  return section ? renderPromptSection(section, CLAUDE_CODE_PROMPT_DIALECT) : void 0;
+}
+function claudeCodeStepBudgetPromptSection(steps) {
+  const section = createStepBudgetSection(steps);
+  return section ? renderPromptSection(section, CLAUDE_CODE_PROMPT_DIALECT) : void 0;
+}
+function renderClaudeCodeRolePrompt(roleName, config, model) {
+  const promptOverrides = loadAgentPrompt(roleName, config?.preset);
+  const override = getAgentOverride(config, roleName);
+  const basePrompt = renderRolePrompt(
+    claudeCodePromptSections(roleName),
+    CLAUDE_CODE_PROMPT_DIALECT
+  );
+  const prompt = composeAgentPrompt({
+    basePrompt,
+    customPrompt: promptOverrides.prompt,
+    customAppendPrompt: appendPromptSections(
+      claudeCodeModelFamilyPromptSection(roleName, model),
+      promptOverrides.appendPrompt
+    )
+  });
+  return appendPromptSections(
+    prompt,
+    claudeCodeStepBudgetPromptSection(override?.steps)
+  );
+}
+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 Task(subagent_type: ${claudeCodeSubagentType(role.name)}); plugin subagents are namespaced with the plugin name. The orchestrator is the main Claude Code session.`,
+    "- Role permissions are enforced by this subagent's frontmatter `tools` allowlist; read-only roles cannot mutate the workspace.",
+    ...role.toolGovernance.map((rule) => `- ${rule}`),
+    ...role.verification.map((rule) => `- ${rule}`),
+    "</role-operational-contract>"
+  ].join("\n");
+}
+function roleInstructions2(role, config) {
+  const model = getClaudeCodeAgentModel(role, config);
+  return [
+    renderClaudeCodeRolePrompt(role.name, config, model),
+    claudeCodeRoleInstructions(role),
+    renderMemoryGovernanceInstructions(role, CLAUDE_CODE_PROMPT_DIALECT)
+  ].join("\n\n");
+}
+function renderClaudeCodeRootInstructions(config) {
+  const rootOverride = getAgentOverride(config, "orchestrator");
+  const rootPrompt = renderClaudeCodeRolePrompt(
+    "orchestrator",
+    config,
+    rootOverride?.model ?? DEFAULT_MODELS.orchestrator
+  );
+  const specialists = getAgentPackContract().roles.filter((role) => role.name !== "orchestrator").map((role) => claudeCodeSubagentType(role.name)).join(", ");
+  return [
+    rootPrompt,
+    "<claude-code-runtime>",
+    "- You ARE the Claude Code main-thread agent: the delegate-first root coordinator. This is your system prompt (activated via the plugin settings.json `agent` key), so orchestrator-only and root-owned rules apply to you directly.",
+    '- As your FIRST action on a new session, when thoth-mem tools are installed and session/project identity is known, call mem_session(action="start") as step 0 before any other thoth-mem call, then save the real user prompt with mem_save(kind="prompt") before later delegation.',
+    "- thoth-mem tools are provided by this plugin's bundled MCP server and are exposed under a plugin namespace; call the available namespaced tool whose name ends in mem_session, mem_recall, mem_context, mem_save, mem_get, or mem_project (do not assume a bare, unnamespaced tool name).",
+    "- If thoth-mem tools or identity values are unavailable, disclose that memory bootstrap could not run and continue without claiming memory was saved.",
+    `- Delegate via the Task tool with \`subagent_type\` set to a plugin-namespaced specialist: ${specialists}. Bare role names (e.g. "explorer") are NOT valid in this harness \u2014 always use the ${CLAUDE_CODE_SUBAGENT_NAMESPACE}: prefix.`,
+    "- Parallel delegation is supported: issue multiple Task calls in one turn for independent work.",
+    '- Before delegating after meaningful context changes, refresh the handoff body with root-owned mem_session(action="summary") or mem_save(kind="session_summary") when available.',
+    "- Use AskUserQuestion for blocking user decisions; do not ask those questions in plain prose.",
+    "- Track progress with TodoWrite; subagents do not own progress checkboxes or root-only memory.",
+    "- Role permissions are enforced at runtime by each subagent's frontmatter `tools` allowlist.",
+    "</claude-code-runtime>"
+  ].join("\n");
+}
+function claudeCodeMcpServers() {
+  const [exaCommand = "", ...exaArgs] = exa.command;
+  const [thothCommand = "", ...thothArgs] = DEFAULT_THOTH_COMMAND;
+  return {
+    exa: {
+      command: exaCommand,
+      ...exaArgs.length > 0 ? { args: exaArgs } : {},
+      ...exa.environment && Object.keys(exa.environment).length > 0 ? { env: exa.environment } : {}
+    },
+    context7: { type: "http", url: CONTEXT7_MCP_URL },
+    grep_app: { type: "http", url: GREP_APP_MCP_URL },
+    thoth_mem: {
+      command: thothCommand,
+      ...thothArgs.length > 0 ? { args: thothArgs } : {}
+    }
+  };
+}
+function stableJson5(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function readRootPackageVersion2(context) {
+  const packageJsonPath = findRootPackageJsonPath([
+    ...hasPackageRoot(context) ? [context.packageRoot] : [],
+    context.projectRoot,
+    process.cwd(),
+    fileURLToPath3(new URL(".", import.meta.url))
+  ]);
+  return readPackageJsonVersion(packageJsonPath);
+}
+function hasConfig(context) {
+  return "config" in context;
+}
+function hasPackageRoot(context) {
+  return "packageRoot" in context && typeof context.packageRoot === "string" && context.packageRoot.length > 0;
+}
+function createPluginManifest(context) {
+  return {
+    name: "thoth-agents",
+    version: readRootPackageVersion2(context),
+    description: "Delegate-first agent pack with seven roles, thoth-mem persistence, and bundled SDD skills, packaged for Claude Code.",
+    author: { name: "thoth-agents" }
+  };
+}
+function renderSubagentArtifacts(config) {
+  const artifacts = [];
+  for (const role of getAgentPackContract().roles.filter(
+    (candidate) => candidate.name !== "orchestrator"
+  )) {
+    const content = renderClaudeCodeSubagent({
+      name: role.name,
+      description: role.responsibility,
+      tools: toolsForRole(role),
+      model: getClaudeCodeAgentModel(role, config),
+      instructions: roleInstructions2(role, config)
+    });
+    artifacts.push({
+      harness: "claude",
+      kind: "agent-config",
+      path: `agents/${role.name}.md`,
+      description: `Claude Code subagent definition for ${role.name}.`,
+      content
+    });
+  }
+  return artifacts;
+}
+function renderOrchestratorArtifact(config) {
+  const orchestrator = getAgentPackContract().roles.find(
+    (role) => role.name === "orchestrator"
+  );
+  const content = renderClaudeCodeSubagent({
+    name: "orchestrator",
+    description: orchestrator?.responsibility ?? "Delegate-first root coordinator for SDD workflow and specialist dispatch.",
+    model: "inherit",
+    instructions: renderClaudeCodeRootInstructions(config)
+  });
+  return {
+    harness: "claude",
+    kind: "agent-config",
+    path: "agents/orchestrator.md",
+    description: "Claude Code orchestrator agent, activated as the main thread via settings.json.",
+    content
+  };
+}
+var claudeCodeAdapter = {
+  id: "claude",
+  displayName: "Claude Code",
+  capabilities: CLAUDE_CODE_CAPABILITIES,
+  render(context) {
+    const config = hasConfig(context) ? context.config : void 0;
+    const componentArtifacts = [
+      ...renderSubagentArtifacts(config),
+      renderOrchestratorArtifact(config),
+      {
+        harness: "claude",
+        kind: "mcp-config",
+        path: ".mcp.json",
+        description: "Claude Code plugin-bundled MCP server definitions.",
+        content: stableJson5({ mcpServers: claudeCodeMcpServers() })
+      },
+      {
+        harness: "claude",
+        kind: "harness-config",
+        path: "settings.json",
+        description: "Activates the orchestrator agent as the Claude Code main thread.",
+        content: stableJson5({ agent: "orchestrator" })
+      }
+    ];
+    const skillLayout = renderClaudeCodeSkillLayout({
+      projectRoot: context.projectRoot,
+      ...hasPackageRoot(context) ? { packageRoot: context.packageRoot } : {},
+      skills: getSkillRegistry()
+    });
+    componentArtifacts.push(...skillLayout.artifacts);
+    const pluginPackage = renderClaudeCodePluginPackage({
+      manifest: createPluginManifest(context),
+      componentArtifacts
+    });
+    return {
+      harness: "claude",
+      artifacts: pluginPackage.artifacts,
+      diagnostics: [...skillLayout.diagnostics, ...pluginPackage.diagnostics]
+    };
+  }
+};
+
+// src/cli/claude-code-install.ts
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/cli/claude-code-paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join7 } from "path";
+var CLAUDE_CODE_ROLE_NAMES = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "quick",
+  "deep"
+];
+function resolveClaudeCodeTargets(options) {
+  const home = options.homeDir ?? homedir2();
+  const pluginRoot = options.scope === "project" ? join7(options.projectRoot, ".claude", "skills", "thoth-agents") : join7(home, ".claude", "skills", "thoth-agents");
+  return {
+    scope: options.scope,
+    pluginRoot,
+    pluginManifestPath: join7(pluginRoot, ".claude-plugin", "plugin.json"),
+    agentPaths: CLAUDE_CODE_ROLE_NAMES.map((role) => ({
+      role,
+      path: join7(pluginRoot, "agents", `${role}.md`)
+    })),
+    mcpPath: join7(pluginRoot, ".mcp.json"),
+    hooksPath: join7(pluginRoot, "hooks", "hooks.json"),
+    skillsDir: join7(pluginRoot, "skills"),
+    managedModelsPath: join7(pluginRoot, ".thoth-agents-managed-models.json")
+  };
+}
+
+// src/cli/claude-code-install.ts
+var CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION = 1;
+var isClaudeCodeModelAlias = isClaudeCodeModel;
+function parseSubagentModel(content) {
+  return /^model:\s*(\S+)\s*$/m.exec(content)?.[1];
+}
+function replaceSubagentModel(content, model) {
+  if (/^model:\s*\S+\s*$/m.test(content)) {
+    return content.replace(/^model:\s*\S+\s*$/m, `model: ${model}`);
+  }
+  return content;
+}
+function emptyManagedModelState3() {
+  return emptyManagedModelState(CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION);
+}
+function parseManagedModelStateJson2(text) {
+  return parseManagedModelStateJson(
+    text,
+    CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION
+  );
+}
+function readManagedModelState3(path4) {
+  return readManagedModelState(
+    path4,
+    CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION
+  );
+}
+function resolvePackageRoot2(packageRoot) {
+  if (packageRoot) return packageRoot;
+  return findPackageRoot(fileURLToPath4(new URL(".", import.meta.url))) ?? void 0;
+}
+function targetKindForArtifact(artifact) {
+  const path4 = artifact.path.replaceAll("\\", "/");
+  if (path4 === ".claude-plugin/plugin.json") return "plugin-manifest";
+  if (path4.startsWith("agents/")) return "subagent";
+  if (path4 === ".mcp.json") return "mcp-config";
+  if (path4.startsWith("hooks/")) return "hook";
+  if (path4.startsWith("skills/")) return "skill";
+  return "plugin-asset";
+}
+function roleForArtifact(artifact) {
+  const match = /^agents\/([^/]+)\.md$/.exec(
+    artifact.path.replaceAll("\\", "/")
+  );
+  const name = match?.[1];
+  return name && CLAUDE_CODE_ROLE_NAMES.includes(name) ? name : void 0;
+}
+function applyConfiguredModel(content, role, state, nextState, reset) {
+  const renderedModel = parseSubagentModel(content);
+  if (!role || !renderedModel) return content;
+  nextState.models[role] = renderedModel;
+  const configured = reset ? void 0 : state.configuredModels?.[role];
+  if (configured === void 0) return content;
+  nextState.configuredModels ??= {};
+  nextState.configuredModels[role] = configured;
+  return replaceSubagentModel(content, configured);
+}
+function buildClaudeCodeSetupPlan(config) {
+  const targets = resolveClaudeCodeTargets({
+    scope: config.scope,
+    projectRoot: config.projectRoot,
+    homeDir: config.homeDir
+  });
+  const packageRoot = resolvePackageRoot2(config.packageRoot);
+  const render = claudeCodeAdapter.render({
+    projectRoot: config.projectRoot,
+    ...packageRoot ? { packageRoot } : {}
+  });
+  const state = readManagedModelState3(targets.managedModelsPath);
+  const nextState = emptyManagedModelState3();
+  const items = render.artifacts.map((artifact) => {
+    const role = roleForArtifact(artifact);
+    const rendered = String(artifact.content ?? "");
+    const content = role !== void 0 ? applyConfiguredModel(rendered, role, state, nextState, config.reset) : rendered;
+    const targetPath = join8(targets.pluginRoot, artifact.path);
+    return {
+      kind: targetKindForArtifact(artifact),
+      action: "write-plugin-file",
+      targetPath,
+      description: `Materialize Claude Code plugin asset ${artifact.path}.`,
+      requiresBackup: existsSync6(targetPath),
+      content,
+      ...role ? { role } : {}
+    };
+  });
+  items.push({
+    kind: "managed-model-state",
+    action: "write-managed-model-state",
+    targetPath: targets.managedModelsPath,
+    description: "Record thoth-agents-managed Claude Code subagent model ownership state.",
+    requiresBackup: existsSync6(targets.managedModelsPath),
+    content: stableJson3(nextState)
+  });
+  return {
+    dryRun: config.dryRun === true,
+    reset: config.reset,
+    items,
+    pluginRoot: targets.pluginRoot,
+    diagnostics: [
+      `Installed as a skills-directory plugin at ${targets.pluginRoot}; it auto-loads as thoth-agents@skills-dir on the next Claude Code session.`,
+      "Restart Claude Code or run /reload-plugins to activate it; run /plugin (Installed tab) to confirm thoth-agents@skills-dir is loaded.",
+      "The plugin settings.json activates the orchestrator agent as the main thread, so the session starts in delegate-first mode and bootstraps thoth-mem on its first turn."
+    ],
+    disclaimers: [
+      "The orchestrator agent is the Claude Code main thread (plugin settings.json `agent` key); while enabled it replaces the default system prompt for every session in scope.",
+      "Role permissions are enforced by each specialist subagent frontmatter `tools` allowlist; the orchestrator inherits all tools.",
+      "Subagent models accept only sonnet, opus, haiku, or inherit.",
+      "User-scope skills-directory plugins load hooks and MCP servers without extra approval; project-scope requires accepting the workspace trust dialog."
+    ]
+  };
+}
+function applyClaudeCodeSetup(plan) {
+  const changed = [];
+  const diagnostics = uniqueMessages([
+    ...plan.diagnostics,
+    ...plan.disclaimers
+  ]);
+  if (plan.dryRun) return { success: true, changed, diagnostics };
+  try {
+    for (const item of plan.items) {
+      if (writeTextWithBackup(item.targetPath, item.content)) {
+        changed.push(item.targetPath);
+      }
+    }
+    return { success: true, changed, diagnostics };
+  } catch (error) {
+    return {
+      success: false,
+      changed,
+      diagnostics,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function applyClaudeCodeManagedModelOverrides(config, overrides) {
+  if (config.dryRun) {
+    return {
+      success: true,
+      changed: [],
+      diagnostics: [
+        "Dry-run Claude Code model override apply requested; no files were written."
+      ]
+    };
+  }
+  const plan = buildClaudeCodeSetupPlan({
+    ...config,
+    dryRun: true,
+    reset: false
+  });
+  const stateItem = plan.items.find(
+    (item) => item.action === "write-managed-model-state"
+  );
+  const statePath = stateItem?.targetPath;
+  if (!statePath) {
+    return {
+      success: false,
+      changed: [],
+      diagnostics: plan.diagnostics,
+      error: "Claude Code managed model state target was not found."
+    };
+  }
+  const changed = [];
+  const diagnostics = uniqueMessages([
+    ...plan.diagnostics,
+    ...plan.disclaimers
+  ]);
+  const state = parseManagedModelStateJson2(stateItem?.content);
+  const nextState = {
+    version: CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION,
+    models: { ...state.models },
+    ...state.configuredModels ? { configuredModels: { ...state.configuredModels } } : {}
+  };
+  try {
+    for (const override of overrides) {
+      if (!isClaudeCodeModelAlias(override.model)) {
+        throw new Error(
+          `Unsupported Claude Code model "${override.model}" for ${override.role}; use sonnet, opus, haiku, or inherit.`
+        );
+      }
+      const roleItem = plan.items.find(
+        (item) => item.kind === "subagent" && item.role === override.role
+      );
+      if (!roleItem) {
+        throw new Error(`Missing Claude Code subagent for ${override.role}.`);
+      }
+      const before = existsSync6(roleItem.targetPath) ? readFileSync7(roleItem.targetPath, "utf8") : roleItem.content;
+      const updated = replaceSubagentModel(before, override.model);
+      if (writeTextWithBackup(roleItem.targetPath, updated)) {
+        changed.push(roleItem.targetPath);
+      }
+      nextState.configuredModels ??= {};
+      nextState.configuredModels[override.role] = override.model;
+    }
+    if (writeTextWithBackup(statePath, stableJson3(nextState))) {
+      changed.push(statePath);
+    }
+    return { success: true, changed, diagnostics };
+  } catch (error) {
+    return {
+      success: false,
+      changed,
+      diagnostics,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatClaudeCodeSetupPlan(plan) {
+  const lines = plan.items.map(
+    (item) => `- ${item.action}: ${item.targetPath} (${item.description})`
+  );
+  return ["Claude Code setup plan:", ...lines].join("\n");
+}
+
+// src/cli/operations/claude-code.ts
+var CLAUDE_CODE_DISPLAY_NAME = "Claude Code";
+var claudeCodePlanSources = /* @__PURE__ */ new WeakMap();
+var claudeCodeModelSources = /* @__PURE__ */ new WeakMap();
+var claudeCodeActions = [
+  {
+    id: "claude-code-status",
+    kind: "status",
+    label: "Status",
+    description: "Inspect managed Claude Code plugin state",
+    dryRun: false,
+    requiresConfirmation: false,
+    supported: true
+  },
+  {
+    id: "claude-code-list",
+    kind: "list",
+    label: "List",
+    description: "List managed Claude Code surfaces and actions",
+    dryRun: false,
+    requiresConfirmation: false,
+    supported: true
+  },
+  {
+    id: "claude-code-install",
+    kind: "install",
+    label: "Install",
+    description: "Preview Claude Code plugin package install",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  },
+  {
+    id: "claude-code-update",
+    kind: "update",
+    label: "Update",
+    description: "Preview Claude Code managed plugin refresh",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  },
+  {
+    id: "claude-code-sync",
+    kind: "sync",
+    label: "Sync",
+    description: "Preview Claude Code managed plugin sync",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  },
+  {
+    id: "claude-code-model-config",
+    kind: "model-config",
+    label: "Model",
+    description: "Preview supported Claude Code subagent model line changes",
+    dryRun: true,
+    requiresConfirmation: true,
+    supported: true
+  }
+];
+var claudeCodeOperationAdapter = {
+  id: "claude",
+  displayName: CLAUDE_CODE_DISPLAY_NAME,
+  available: true,
+  description: "Claude Code plugin package and managed subagent surfaces.",
+  actions: claudeCodeActions
+};
+function claudeCodeConfig(context = { cwd: process.cwd() }, dryRun) {
+  return {
+    dryRun,
+    reset: false,
+    // Match the installer (install.ts uses 'user') so post-install status,
+    // update, sync, and model commands resolve the same plugin root.
+    scope: context.scope ?? "user",
+    projectRoot: context.cwd,
+    homeDir: context.homeDir,
+    packageRoot: context.packageRoot
+  };
+}
+function claudeCodeDisclaimers() {
+  return [
+    {
+      message: "Role permissions are enforced by subagent frontmatter tools; the orchestrator is the main session, injected via the SessionStart hook.",
+      code: "claude-code-first-class"
+    },
+    {
+      message: "Subagent models accept only sonnet, opus, haiku, or inherit.",
+      code: "claude-code-model-aliases"
+    }
+  ];
+}
+function warning(message, code) {
+  return { severity: "important", message, code };
+}
+function targetForItem(item, state, observed) {
+  return {
+    kind: item.kind === "managed-model-state" ? "memory-state" : "generated-artifact",
+    path: item.targetPath,
+    label: item.role ? `Claude Code ${item.role} subagent` : item.kind.replaceAll("-", " "),
+    state,
+    expected: item.action,
+    observed,
+    description: item.description
+  };
+}
+function surfaceForItem(item) {
+  return {
+    id: `${item.kind}:${item.role ?? basename2(item.targetPath)}`,
+    label: item.role ? `Claude Code ${item.role} subagent` : item.kind.replaceAll("-", " "),
+    path: item.targetPath,
+    description: item.description
+  };
+}
+function backupForItem(item) {
+  return {
+    required: item.requiresBackup,
+    strategy: item.requiresBackup ? "managed-backup-file" : "none",
+    destinations: item.requiresBackup ? [{ path: `${item.targetPath}.bak`, label: "managed backup" }] : []
+  };
+}
+function manifestState(item) {
+  if (!existsSync7(item.targetPath))
+    return { state: "missing", observed: "absent" };
+  const observed = readFileSync8(item.targetPath, "utf8");
+  if (observed === item.content)
+    return { state: "installed", observed: "current" };
+  try {
+    const expectedVersion = JSON.parse(item.content).version;
+    const observedVersion = JSON.parse(observed).version;
+    if (typeof expectedVersion === "string" && typeof observedVersion === "string" && expectedVersion !== observedVersion) {
+      return {
+        state: "outdated",
+        observed: `version ${observedVersion}; expected ${expectedVersion}`
+      };
+    }
+  } catch {
+    return { state: "unknown", observed: "unparseable plugin manifest" };
+  }
+  return { state: "drift", observed: "content differs" };
+}
+function contentState(item) {
+  if (!existsSync7(item.targetPath))
+    return { state: "missing", observed: "absent" };
+  return readFileSync8(item.targetPath, "utf8") === item.content ? { state: "installed", observed: "current" } : { state: "drift", observed: "content differs" };
+}
+function classifyItem(item) {
+  if (item.kind === "plugin-manifest") return manifestState(item);
+  return contentState(item);
+}
+function aggregateState(states) {
+  if (states.includes("unknown")) return "unknown";
+  if (states.includes("drift")) return "drift";
+  if (states.includes("outdated")) return "outdated";
+  if (states.includes("missing")) return "missing";
+  return "installed";
+}
+function statusSummary(state) {
+  switch (state) {
+    case "installed":
+      return "Claude Code managed plugin is installed and current.";
+    case "missing":
+      return "Claude Code managed plugin is missing.";
+    case "drift":
+      return "Claude Code managed plugin exists but differs from expected output.";
+    case "outdated":
+      return "Claude Code managed plugin includes an older generated manifest.";
+    case "unknown":
+      return "Claude Code managed plugin could not be classified safely.";
+  }
+}
+function statusFromSetupPlan(plan) {
+  const classified = plan.items.map((item) => ({
+    item,
+    ...classifyItem(item)
+  }));
+  const state = aggregateState(classified.map((entry) => entry.state));
+  return {
+    harness: "claude",
+    displayName: CLAUDE_CODE_DISPLAY_NAME,
+    state,
+    summary: statusSummary(state),
+    targets: classified.map(
+      ({ item, state: state2, observed }) => targetForItem(item, state2, observed)
+    ),
+    diagnostics: plan.diagnostics.map((message) => ({
+      severity: "minor",
+      message,
+      code: "claude-code-diagnostic"
+    })),
+    actions: claudeCodeActions,
+    disclaimers: [
+      ...claudeCodeDisclaimers(),
+      ...plan.disclaimers.map((message) => ({ message }))
+    ]
+  };
+}
+function getClaudeCodeStatus(context = { cwd: process.cwd() }) {
+  let plan;
+  try {
+    plan = buildClaudeCodeSetupPlan(claudeCodeConfig(context, true));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      harness: "claude",
+      displayName: CLAUDE_CODE_DISPLAY_NAME,
+      state: "unknown",
+      summary: `Claude Code setup plan could not be built: ${message}`,
+      targets: [],
+      diagnostics: [
+        {
+          severity: "critical",
+          message,
+          code: "claude-code-plan-build-failed"
+        }
+      ],
+      actions: claudeCodeActions,
+      disclaimers: claudeCodeDisclaimers()
+    };
+  }
+  return statusFromSetupPlan(plan);
+}
+function planItemFromSetup(item) {
+  return {
+    title: item.description,
+    target: targetForItem(item),
+    preview: item.content,
+    backup: backupForItem(item)
+  };
+}
+function planFromSetup(id, action, title, summary, setupPlan) {
+  const status = statusFromSetupPlan(setupPlan);
+  const canApply = status.state === "installed" || status.state === "missing" || status.state === "outdated" || status.state === "drift";
+  const plan = {
+    id,
+    harness: "claude",
+    action,
+    title,
+    summary,
+    dryRun: true,
+    canApply,
+    targets: status.targets,
+    surfaces: setupPlan.items.map(surfaceForItem),
+    backup: {
+      required: setupPlan.items.some((item) => item.requiresBackup),
+      strategy: "managed-backup-file",
+      description: "Existing Claude Code plugin files are backed up before being overwritten."
+    },
+    items: setupPlan.items.map(planItemFromSetup),
+    warnings: status.diagnostics,
+    disclaimers: [
+      ...claudeCodeDisclaimers(),
+      ...setupPlan.disclaimers.map((message) => ({ message }))
+    ]
+  };
+  claudeCodePlanSources.set(plan, setupPlan);
+  return plan;
+}
+function buildClaudeCodeInstallPlan(context = { cwd: process.cwd() }) {
+  return planFromSetup(
+    "claude-code-install-preview",
+    "install",
+    "Install Claude Code plugin package",
+    "Preview Claude Code plugin package install using buildClaudeCodeSetupPlan().",
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context, true))
+  );
+}
+function buildClaudeCodeUpdatePlan(context = { cwd: process.cwd() }) {
+  return planFromSetup(
+    "claude-code-update-preview",
+    "update",
+    "Update Claude Code plugin package",
+    "Preview Claude Code managed plugin refresh using buildClaudeCodeSetupPlan().",
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context, true))
+  );
+}
+function buildClaudeCodeSyncPlan(context = { cwd: process.cwd() }) {
+  return planFromSetup(
+    "claude-code-sync-preview",
+    "sync",
+    "Sync Claude Code plugin package",
+    "Preview Claude Code managed plugin subagents, MCP, hooks, and skills.",
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context, true))
+  );
+}
+function isClaudeCodeRole(role) {
+  return CLAUDE_CODE_ROLE_NAMES.includes(role);
+}
+function buildClaudeCodeModelPlan(input, context = { cwd: process.cwd() }) {
+  const status = getClaudeCodeStatus(context);
+  const supportedRoles = input.roles.filter((role) => isClaudeCodeRole(role.role)).filter((role) => isClaudeCodeModelAlias(role.model)).map((role) => ({
+    role: role.role,
+    model: role.model
+  }));
+  const rejectedRoles = input.roles.filter(
+    (role) => !isClaudeCodeRole(role.role) || !isClaudeCodeModelAlias(role.model)
+  );
+  const warnings = [
+    ...status.diagnostics,
+    ...input.warnings ?? [],
+    ...rejectedRoles.map(
+      (role) => warning(
+        `Claude Code does not accept role "${role.role}" with model "${role.model}"; roles must be one of ${CLAUDE_CODE_ROLE_NAMES.join(", ")} and models must be sonnet, opus, haiku, or inherit.`,
+        "claude-code-unsupported-model-role"
+      )
+    )
+  ];
+  if (input.harness !== "claude") {
+    warnings.push(
+      warning(
+        "Model plan target harness must be claude.",
+        "claude-code-model-harness-mismatch"
+      )
+    );
+  }
+  const targets = supportedRoles.map(({ role }) => {
+    const target = status.targets.find(
+      (candidate) => candidate.path?.endsWith(`agents${pathSep()}${role}.md`)
+    );
+    return target ?? {
+      kind: "generated-artifact",
+      label: `Claude Code ${role} subagent`,
+      state: "missing"
+    };
+  });
+  const stateTarget = status.targets.find(
+    (target) => target.path?.endsWith(".thoth-agents-managed-models.json")
+  );
+  const plan = {
+    id: "claude-code-model-config-preview",
+    harness: "claude",
+    action: "model-config",
+    title: "Configure Claude Code subagent model lines",
+    summary: "Preview model changes for generated Claude Code subagent files and managed model state only.",
+    dryRun: true,
+    canApply: input.harness === "claude" && supportedRoles.length > 0 && status.state !== "unknown",
+    targets: [...targets, ...stateTarget ? [stateTarget] : []],
+    surfaces: targets.map((target) => ({
+      id: `claude-code-model:${target.label}`,
+      label: target.label ?? "Claude Code subagent",
+      path: target.path,
+      state: target.state
+    })),
+    backup: {
+      required: true,
+      strategy: "managed-backup-file",
+      description: "Existing subagent files and managed model state are backed up by the managed write helper."
+    },
+    items: supportedRoles.map(({ role, model }) => ({
+      title: `Set ${role} Claude Code subagent model line`,
+      target: targets.find(
+        (target) => target.path?.endsWith(`agents${pathSep()}${role}.md`)
+      ) ?? {
+        kind: "generated-artifact",
+        label: `Claude Code ${role} subagent`
+      },
+      preview: JSON.stringify({ role, model }),
+      backup: { required: true, strategy: "managed-backup-file" }
+    })),
+    warnings,
+    disclaimers: [
+      ...claudeCodeDisclaimers(),
+      ...input.disclaimers ?? [],
+      {
+        message: "Claude Code model configuration writes only generated subagent frontmatter model lines and the managed model state JSON.",
+        code: "claude-code-model-supported-surface"
+      }
+    ]
+  };
+  claudeCodeModelSources.set(plan, {
+    config: claudeCodeConfig(context, false),
+    roles: supportedRoles
+  });
+  return plan;
+}
+function pathSep() {
+  return process.platform === "win32" ? "\\" : "/";
+}
+function rejectPlan(plan, message, severity = "critical") {
+  return {
+    harness: plan.harness,
+    action: plan.action,
+    applied: false,
+    summary: message,
+    changedTargets: [],
+    backups: [],
+    warnings: [{ severity, message }],
+    disclaimers: claudeCodeDisclaimers()
+  };
+}
+function validateClaudeCodePlan(plan) {
+  if (plan.harness !== "claude") {
+    return rejectPlan(plan, "Only Claude Code operation plans can be applied.");
+  }
+  if (!plan.canApply) {
+    return rejectPlan(
+      plan,
+      "Claude Code plan cannot be applied because canApply is false."
+    );
+  }
+  if (!["install", "update", "sync", "model-config"].includes(plan.action)) {
+    return rejectPlan(
+      plan,
+      `Unsupported Claude Code apply action: ${plan.action}.`
+    );
+  }
+  if (plan.items.length === 0) {
+    return rejectPlan(plan, "Claude Code plan has no items to apply.");
+  }
+  return null;
+}
+function applyClaudeCodePlan(plan) {
+  const rejection = validateClaudeCodePlan(plan);
+  if (rejection) return rejection;
+  if (plan.action === "model-config") {
+    const source = claudeCodeModelSources.get(plan);
+    if (!source) {
+      return rejectPlan(
+        plan,
+        "Claude Code model plan was not produced by buildClaudeCodeModelPlan in this process."
+      );
+    }
+    const result2 = applyClaudeCodeManagedModelOverrides(
+      source.config,
+      source.roles.map((role) => ({
+        role: role.role,
+        model: role.model
+      }))
+    );
+    return {
+      harness: "claude",
+      action: "model-config",
+      applied: result2.success,
+      summary: result2.success ? "Applied Claude Code subagent model overrides." : result2.error ?? "Failed to apply Claude Code subagent model overrides.",
+      changedTargets: result2.changed.map((path4) => ({
+        kind: path4.endsWith(".json") ? "memory-state" : "generated-artifact",
+        path: path4,
+        label: basename2(path4),
+        state: "installed"
+      })),
+      backups: result2.changed.filter((path4) => existsSync7(`${path4}.bak`)).map((path4) => ({ path: `${path4}.bak`, label: "managed backup" })),
+      warnings: result2.success ? [] : [{ severity: "critical", message: result2.error ?? "apply failed." }],
+      disclaimers: claudeCodeDisclaimers()
+    };
+  }
+  const setupPlan = claudeCodePlanSources.get(plan);
+  if (!setupPlan) {
+    return rejectPlan(
+      plan,
+      "Claude Code setup plan was not produced by a Claude Code operation plan builder in this process."
+    );
+  }
+  const result = applyClaudeCodeSetup({ ...setupPlan, dryRun: false });
+  return {
+    harness: "claude",
+    action: plan.action,
+    applied: result.success,
+    summary: result.success ? `Applied Claude Code managed ${plan.action} plan.` : result.error ?? `Failed to apply Claude Code ${plan.action} plan.`,
+    changedTargets: result.changed.map((path4) => ({
+      kind: path4.endsWith(".json") ? "memory-state" : "generated-artifact",
+      path: path4,
+      label: basename2(path4),
+      state: "installed"
+    })),
+    backups: result.changed.filter((path4) => existsSync7(`${path4}.bak`)).map((path4) => ({ path: `${path4}.bak`, label: "managed backup" })),
+    warnings: result.success ? [] : [{ severity: "critical", message: result.error ?? "apply failed." }],
+    disclaimers: claudeCodeDisclaimers()
+  };
+}
+function defaultClaudeCodeModelRoles() {
+  return CLAUDE_CODE_ROLE_NAMES.map((role) => ({
+    role,
+    model: CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS[role]
+  }));
+}
+
+// src/cli/operations/codex.ts
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
+import { basename as basename3 } from "path";
+var CODEX_DISPLAY_NAME = "Codex";
+var codexPlanSources = /* @__PURE__ */ new WeakMap();
+var codexModelSources = /* @__PURE__ */ new WeakMap();
+var codexActions = [
+  {
+    id: "codex-status",
+    kind: "status",
+    label: "Status",
+    description: "Inspect managed Codex setup state",
+    dryRun: false,
+    requiresConfirmation: false,
+    supported: true
+  },
   {
     id: "codex-list",
     kind: "list",
@@ -2377,10 +3511,10 @@ function codexDisclaimers() {
     }
   ];
 }
-function warning(message, code) {
+function warning2(message, code) {
   return { severity: "important", message, code };
 }
-function targetForItem(item, state, observed) {
+function targetForItem2(item, state, observed) {
   return {
     kind: item.kind === "managed-model-state" ? "memory-state" : "generated-artifact",
     path: item.targetPath,
@@ -2391,15 +3525,15 @@ function targetForItem(item, state, observed) {
     description: item.description
   };
 }
-function surfaceForItem(item) {
+function surfaceForItem2(item) {
   return {
-    id: `${item.kind}:${item.role ?? basename2(item.targetPath)}`,
+    id: `${item.kind}:${item.role ?? basename3(item.targetPath)}`,
     label: item.role ? `Codex ${item.role} subagent TOML` : item.kind.replaceAll("-", " "),
     path: item.targetPath,
     description: item.description
   };
 }
-function backupForItem(item) {
+function backupForItem2(item) {
   return {
     required: item.requiresBackup,
     strategy: item.requiresBackup ? "managed-backup-file" : "none",
@@ -2407,9 +3541,9 @@ function backupForItem(item) {
   };
 }
 function rootBlockState(item) {
-  if (!existsSync5(item.targetPath))
+  if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const content = readFileSync5(item.targetPath, "utf8");
+  const content = readFileSync9(item.targetPath, "utf8");
   if (item.content && content.includes(item.content)) {
     return { state: "installed", observed: "managed root block present" };
   }
@@ -2419,22 +3553,22 @@ function rootBlockState(item) {
   return { state: "missing", observed: "managed root block absent" };
 }
 function managedModelState(item) {
-  if (!existsSync5(item.targetPath))
+  if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
   try {
-    const parsed = JSON.parse(readFileSync5(item.targetPath, "utf8"));
+    const parsed = JSON.parse(readFileSync9(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 === readFileSync5(item.targetPath, "utf8") ? { state: "installed", observed: "managed model state current" } : { state: "drift", observed: "managed model state differs" };
+    return item.content === readFileSync9(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" };
   }
 }
 function userConfigState(item) {
-  if (!existsSync5(item.targetPath))
+  if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const content = readFileSync5(item.targetPath, "utf8");
+  const content = readFileSync9(item.targetPath, "utf8");
   if (/^\s*default_mode_request_user_input\s*=\s*true\b/m.test(content)) {
     return {
       state: "installed",
@@ -2447,10 +3581,10 @@ function userConfigState(item) {
   return { state: "missing", observed: "managed feature flag absent" };
 }
 function marketplaceState(item) {
-  if (!existsSync5(item.targetPath))
+  if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
   try {
-    const parsed = JSON.parse(readFileSync5(item.targetPath, "utf8"));
+    const parsed = JSON.parse(readFileSync9(item.targetPath, "utf8"));
     const plugins = Array.isArray(parsed.plugins) ? parsed.plugins : [];
     const entry = plugins.find(
       (plugin) => plugin && typeof plugin === "object" && "name" in plugin && plugin.name === "thoth-agents"
@@ -2463,11 +3597,11 @@ function marketplaceState(item) {
     return { state: "unknown", observed: "unparseable marketplace JSON" };
   }
 }
-function contentState(item) {
-  if (!existsSync5(item.targetPath))
+function contentState2(item) {
+  if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const observed = readFileSync5(item.targetPath, "utf8");
-  if (basename2(item.targetPath) === "plugin.json" && item.targetPath.replaceAll("\\", "/").includes("/.codex-plugin/")) {
+  const observed = readFileSync9(item.targetPath, "utf8");
+  if (basename3(item.targetPath) === "plugin.json" && item.targetPath.replaceAll("\\", "/").includes("/.codex-plugin/")) {
     try {
       const expectedVersion = JSON.parse(item.content ?? "{}").version;
       const observedVersion = JSON.parse(observed).version;
@@ -2495,7 +3629,7 @@ function contentState(item) {
   }
   return { state: "drift", observed: "content differs" };
 }
-function classifyItem(item) {
+function classifyItem2(item) {
   if (item.action === "diagnose-only") {
     return { state: "unknown", observed: "diagnostic guidance only" };
   }
@@ -2505,16 +3639,16 @@ function classifyItem(item) {
   }
   if (item.action === "merge-toml") return userConfigState(item);
   if (item.action === "merge-marketplace") return marketplaceState(item);
-  return contentState(item);
+  return contentState2(item);
 }
-function aggregateState(states) {
+function aggregateState2(states) {
   if (states.includes("unknown")) return "unknown";
   if (states.includes("drift")) return "drift";
   if (states.includes("outdated")) return "outdated";
   if (states.includes("missing")) return "missing";
   return "installed";
 }
-function statusSummary(state) {
+function statusSummary2(state) {
   switch (state) {
     case "installed":
       return "Codex managed setup surfaces are installed and current.";
@@ -2551,8 +3685,8 @@ function getCodexStatus(context = { cwd: process.cwd() }) {
       disclaimers: codexDisclaimers()
     };
   }
-  const classified = plan.items.filter((item) => item.action !== "diagnose-only").map((item) => ({ item, ...classifyItem(item) }));
-  const state = aggregateState(classified.map((item) => item.state));
+  const classified = plan.items.filter((item) => item.action !== "diagnose-only").map((item) => ({ item, ...classifyItem2(item) }));
+  const state = aggregateState2(classified.map((item) => item.state));
   const diagnostics = plan.diagnostics.map((message) => ({
     severity: "minor",
     message,
@@ -2562,9 +3696,9 @@ function getCodexStatus(context = { cwd: process.cwd() }) {
     harness: "codex",
     displayName: CODEX_DISPLAY_NAME,
     state,
-    summary: statusSummary(state),
+    summary: statusSummary2(state),
     targets: classified.map(
-      ({ item, state: state2, observed }) => targetForItem(item, state2, observed)
+      ({ item, state: state2, observed }) => targetForItem2(item, state2, observed)
     ),
     diagnostics,
     actions: codexActions,
@@ -2574,15 +3708,15 @@ function getCodexStatus(context = { cwd: process.cwd() }) {
     ]
   };
 }
-function planItemFromSetup(item) {
+function planItemFromSetup2(item) {
   return {
     title: item.description,
-    target: targetForItem(item),
+    target: targetForItem2(item),
     preview: item.content,
-    backup: backupForItem(item)
+    backup: backupForItem2(item)
   };
 }
-function planFromSetup(id, action, title, summary, setupPlan, context) {
+function planFromSetup2(id, action, title, summary, setupPlan, context) {
   const status = getCodexStatus(context);
   const canApply = status.state === "installed" || status.state === "missing" || status.state === "outdated";
   const plan = {
@@ -2594,17 +3728,17 @@ function planFromSetup(id, action, title, summary, setupPlan, context) {
     dryRun: true,
     canApply,
     targets: status.targets,
-    surfaces: setupPlan.items.filter((item) => item.action !== "diagnose-only").map(surfaceForItem),
+    surfaces: setupPlan.items.filter((item) => item.action !== "diagnose-only").map(surfaceForItem2),
     backup: {
       required: setupPlan.items.some((item) => item.requiresBackup),
       strategy: "existing-helper",
       description: "Codex setup apply uses the existing installer backup behavior for files that already exist."
     },
-    items: setupPlan.items.map(planItemFromSetup),
+    items: setupPlan.items.map(planItemFromSetup2),
     warnings: [
       ...status.diagnostics,
       ...canApply ? [] : [
-        warning(
+        warning2(
           `Codex state is ${status.state}; apply is disabled until the state is safely classified or repaired.`,
           "codex-unsafe-state"
         )
@@ -2620,7 +3754,7 @@ function planFromSetup(id, action, title, summary, setupPlan, context) {
 }
 function buildCodexUpdatePlan(context = { cwd: process.cwd() }) {
   const setupPlan = buildCodexSetupPlan(codexConfig(context, true));
-  return planFromSetup(
+  return planFromSetup2(
     "codex-update-preview",
     "update",
     "Update Codex managed setup",
@@ -2631,7 +3765,7 @@ function buildCodexUpdatePlan(context = { cwd: process.cwd() }) {
 }
 function buildCodexSyncPlan(context = { cwd: process.cwd() }) {
   const setupPlan = buildCodexSetupPlan(codexConfig(context, true));
-  return planFromSetup(
+  return planFromSetup2(
     "codex-sync-preview",
     "sync",
     "Sync Codex managed configuration",
@@ -2642,7 +3776,7 @@ function buildCodexSyncPlan(context = { cwd: process.cwd() }) {
 }
 function buildCodexInstallPlan(context = { cwd: process.cwd() }) {
   const setupPlan = buildCodexSetupPlan(codexConfig(context, true));
-  return planFromSetup(
+  return planFromSetup2(
     "codex-install-preview",
     "install",
     "Install Codex managed setup",
@@ -2673,7 +3807,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
     ...status.diagnostics,
     ...input.warnings ?? [],
     ...unsupportedRoles.map(
-      (role) => warning(
+      (role) => warning2(
         `Codex does not expose a supported generated model surface for ${role.role}; this plan will not write that role.`,
         "codex-unsupported-model-role"
       )
@@ -2681,7 +3815,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
   ];
   if (input.harness !== "codex") {
     warnings.push(
-      warning(
+      warning2(
         "Model plan target harness must be codex.",
         "codex-model-harness-mismatch"
       )
@@ -2748,7 +3882,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
   codexModelSources.set(plan, { config, roles: supportedRoles });
   return plan;
 }
-function rejectPlan(plan, message, severity = "critical") {
+function rejectPlan2(plan, message, severity = "critical") {
   return {
     harness: plan.harness,
     action: plan.action,
@@ -2762,19 +3896,19 @@ function rejectPlan(plan, message, severity = "critical") {
 }
 function validateCodexPlan(plan) {
   if (plan.harness !== "codex") {
-    return rejectPlan(plan, "Only Codex operation plans can be applied.");
+    return rejectPlan2(plan, "Only Codex operation plans can be applied.");
   }
   if (!plan.canApply) {
-    return rejectPlan(
+    return rejectPlan2(
       plan,
       "Codex plan cannot be applied because canApply is false."
     );
   }
   if (!["install", "update", "sync", "model-config"].includes(plan.action)) {
-    return rejectPlan(plan, `Unsupported Codex apply action: ${plan.action}.`);
+    return rejectPlan2(plan, `Unsupported Codex apply action: ${plan.action}.`);
   }
   if (plan.items.length === 0) {
-    return rejectPlan(plan, "Codex plan has no items to apply.");
+    return rejectPlan2(plan, "Codex plan has no items to apply.");
   }
   return null;
 }
@@ -2784,7 +3918,7 @@ function applyCodexPlan(plan) {
   if (plan.action === "model-config") {
     const source = codexModelSources.get(plan);
     if (!source) {
-      return rejectPlan(
+      return rejectPlan2(
         plan,
         "Codex model plan was not produced by buildCodexModelPlan in this process."
       );
@@ -2795,13 +3929,13 @@ function applyCodexPlan(plan) {
       action: "model-config",
       applied: result2.success,
       summary: result2.success ? "Applied Codex subagent model overrides." : result2.error ?? "Failed to apply Codex subagent model overrides.",
-      changedTargets: result2.changed.map((path2) => ({
-        kind: path2.endsWith(".json") ? "memory-state" : "generated-artifact",
-        path: path2,
-        label: basename2(path2),
+      changedTargets: result2.changed.map((path4) => ({
+        kind: path4.endsWith(".json") ? "memory-state" : "generated-artifact",
+        path: path4,
+        label: basename3(path4),
         state: "installed"
       })),
-      backups: result2.changed.filter((path2) => existsSync5(`${path2}.bak`)).map((path2) => ({ path: `${path2}.bak`, label: "managed backup" })),
+      backups: result2.changed.filter((path4) => existsSync8(`${path4}.bak`)).map((path4) => ({ path: `${path4}.bak`, label: "managed backup" })),
       warnings: result2.success ? [] : [
         {
           severity: "critical",
@@ -2813,7 +3947,7 @@ function applyCodexPlan(plan) {
   }
   const setupPlan = codexPlanSources.get(plan);
   if (!setupPlan) {
-    return rejectPlan(
+    return rejectPlan2(
       plan,
       "Codex setup plan was not produced by a Codex operation plan builder in this process."
     );
@@ -2824,13 +3958,13 @@ function applyCodexPlan(plan) {
     action: plan.action,
     applied: result.success,
     summary: result.success ? `Applied Codex managed ${plan.action} plan.` : result.error ?? `Failed to apply Codex ${plan.action} plan.`,
-    changedTargets: result.changed.map((path2) => ({
-      kind: path2.endsWith(".json") ? "memory-state" : "generated-artifact",
-      path: path2,
-      label: basename2(path2),
+    changedTargets: result.changed.map((path4) => ({
+      kind: path4.endsWith(".json") ? "memory-state" : "generated-artifact",
+      path: path4,
+      label: basename3(path4),
       state: "installed"
     })),
-    backups: result.changed.filter((path2) => existsSync5(`${path2}.bak`)).map((path2) => ({ path: `${path2}.bak`, label: "managed backup" })),
+    backups: result.changed.filter((path4) => existsSync8(`${path4}.bak`)).map((path4) => ({ path: `${path4}.bak`, label: "managed backup" })),
     warnings: result.success ? [] : [
       {
         severity: "critical",
@@ -2842,14 +3976,14 @@ function applyCodexPlan(plan) {
 }
 
 // src/cli/operations/opencode.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
 
 // src/cli/skills.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join9 } from "path";
 var RECOMMENDED_SKILLS = [
   {
     name: "simplify",
@@ -2864,11 +3998,11 @@ var RECOMMENDED_SKILLS = [
     description: "Browser automation for visual checks and testing"
   }
 ];
-function getRecommendedSkillPath(skill, homeDir = homedir2()) {
-  return join5(homeDir, ".agents", "skills", skill.skillName, "SKILL.md");
+function getRecommendedSkillPath(skill, homeDir = homedir3()) {
+  return join9(homeDir, ".agents", "skills", skill.skillName, "SKILL.md");
 }
 function isRecommendedSkillInstalled(skill, options = {}) {
-  return existsSync6(getRecommendedSkillPath(skill, options.homeDir));
+  return existsSync9(getRecommendedSkillPath(skill, options.homeDir));
 }
 function runSkillInstallCommand(skill) {
   const args = [
@@ -3022,11 +4156,11 @@ function openCodeSkillTargets(context) {
   const homeDir = homeDirFromContext(context);
   const recommendedTargets = RECOMMENDED_SKILLS.map(
     (skill) => {
-      const path2 = getRecommendedSkillPath(skill, homeDir);
-      const installed = existsSync7(path2);
+      const path4 = getRecommendedSkillPath(skill, homeDir);
+      const installed = existsSync10(path4);
       return {
         kind: "skill",
-        path: path2,
+        path: path4,
         label: titleCaseSkillName(skill.skillName),
         state: installed ? "installed" : "missing",
         expected: "recommended global OpenCode skill",
@@ -3035,11 +4169,11 @@ function openCodeSkillTargets(context) {
     }
   );
   const bundledTargets = CUSTOM_SKILLS.map((skill) => {
-    const path2 = join6(getCustomSkillsDir(), skill.name, "SKILL.md");
-    const installed = existsSync7(path2);
+    const path4 = join10(getCustomSkillsDir(), skill.name, "SKILL.md");
+    const installed = existsSync10(path4);
     return {
       kind: "skill",
-      path: path2,
+      path: path4,
       label: titleCaseSkillName(skill.name),
       state: installed ? "installed" : "missing",
       expected: "bundled thoth-agents OpenCode skill",
@@ -3142,8 +4276,8 @@ function getOpenCodeStatus(context = { cwd: process.cwd() }) {
       actions: openCodeActions
     };
   }
-  const mainExists = existsSync7(mainPath);
-  const liteExists = existsSync7(litePath);
+  const mainExists = existsSync10(mainPath);
+  const liteExists = existsSync10(litePath);
   const mainTarget = {
     ...targetForMainConfig(),
     observed: configPluginMarker(main.config)
@@ -3240,11 +4374,11 @@ function getOpenCodeStatus(context = { cwd: process.cwd() }) {
     actions: openCodeActions
   };
 }
-function defaultBackup(path2) {
+function defaultBackup(path4) {
   return {
     required: true,
     strategy: "managed-backup-file",
-    destinations: [{ path: `${path2}.bak`, label: "managed backup" }]
+    destinations: [{ path: `${path4}.bak`, label: "managed backup" }]
   };
 }
 function defaultDisclaimers() {
@@ -3296,7 +4430,7 @@ function planFromItems(id, action, title, summary, items) {
   };
 }
 function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
-  const path2 = getExistingConfigPath();
+  const path4 = getExistingConfigPath();
   return planFromItems(
     "opencode-update-preview",
     "update",
@@ -3308,7 +4442,7 @@ function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
         target: targetForMainConfig(),
         state: getOpenCodeStatus().state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
-        backup: defaultBackup(path2)
+        backup: defaultBackup(path4)
       }
     ]
   );
@@ -3475,7 +4609,7 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
   }
   return plan;
 }
-function rejectPlan2(plan, message, severity = "critical") {
+function rejectPlan3(plan, message, severity = "critical") {
   return {
     harness: plan.harness,
     action: plan.action,
@@ -3519,27 +4653,27 @@ function ensureLatestPluginEntry() {
 }
 function validateApplyPlan(plan) {
   if (plan.harness !== "opencode") {
-    return rejectPlan2(plan, "Only OpenCode operation plans can be applied.");
+    return rejectPlan3(plan, "Only OpenCode operation plans can be applied.");
   }
   if (!plan.canApply) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       "OpenCode plan cannot be applied because canApply is false."
     );
   }
   if (!["install", "update", "sync", "model-config"].includes(plan.action)) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       `Unsupported OpenCode apply action: ${plan.action}.`
     );
   }
   if (plan.items.length === 0) {
-    return rejectPlan2(plan, "OpenCode plan has no items to apply.");
+    return rejectPlan3(plan, "OpenCode plan has no items to apply.");
   }
   if (plan.items.some(
     (item) => !item.title || !item.target.path && item.target.kind !== "skill" || item.state === "drift" || item.state === "unknown"
   )) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       "OpenCode plan contains malformed or unsafe items."
     );
@@ -3551,7 +4685,7 @@ function applyModelPlan(plan) {
   for (const item of plan.items) {
     const match = /^Set (.+) OpenCode model override$/.exec(item.title);
     if (!match) {
-      return rejectPlan2(
+      return rejectPlan3(
         plan,
         "OpenCode model plan contains an unrecognized item."
       );
@@ -3560,7 +4694,7 @@ function applyModelPlan(plan) {
     try {
       parsed2 = item.preview ? JSON.parse(item.preview) : {};
     } catch {
-      return rejectPlan2(
+      return rejectPlan3(
         plan,
         "OpenCode model plan contains malformed preview JSON."
       );
@@ -3568,7 +4702,7 @@ function applyModelPlan(plan) {
     const role = match[1] ?? "";
     const model = parsed2[role]?.model;
     if (!ROLE_NAMES.includes(role) || typeof model !== "string") {
-      return rejectPlan2(
+      return rejectPlan3(
         plan,
         "OpenCode model plan contains an invalid role or model."
       );
@@ -3576,7 +4710,7 @@ function applyModelPlan(plan) {
     roleModels.set(role, model);
   }
   if (roleModels.size === 0) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       "OpenCode model plan does not contain any role overrides."
     );
@@ -3612,7 +4746,7 @@ function applyModelPlan(plan) {
         observed: "agents role overrides updated"
       }
     ],
-    backups: existsSync7(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
+    backups: existsSync10(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
     warnings: [],
     disclaimers: defaultDisclaimers()
   };
@@ -3621,7 +4755,7 @@ function applyInstallSkills(plan) {
   for (const skill of RECOMMENDED_SKILLS) {
     const result = installRecommendedSkill(skill);
     if (result.status === "failed") {
-      return rejectPlan2(
+      return rejectPlan3(
         plan,
         `Failed to install recommended OpenCode skill: ${skill.name}.`
       );
@@ -3629,7 +4763,7 @@ function applyInstallSkills(plan) {
   }
   const bundled = installCustomSkills();
   if (!bundled.success) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       "Failed to install bundled thoth-agents OpenCode skills."
     );
@@ -3641,7 +4775,7 @@ function applyOpenCodePlan(plan) {
   if (rejection) return rejection;
   const status = getOpenCodeStatus();
   if (!classifyApplySafety(status.state)) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       `OpenCode state is ${status.state}; refusing to apply plan without a safe status.`
     );
@@ -3651,7 +4785,7 @@ function applyOpenCodePlan(plan) {
   const backups = [];
   const pluginResult = ensureLatestPluginEntry();
   if (!pluginResult.success) {
-    return rejectPlan2(
+    return rejectPlan3(
       plan,
       pluginResult.error ?? "Failed to update OpenCode plugin config."
     );
@@ -3660,7 +4794,7 @@ function applyOpenCodePlan(plan) {
     ...targetForMainConfig("installed"),
     observed: `plugin includes ${EXPECTED_PLUGIN}`
   });
-  if (existsSync7(`${pluginResult.configPath}.bak`)) {
+  if (existsSync10(`${pluginResult.configPath}.bak`)) {
     backups.push({
       path: `${pluginResult.configPath}.bak`,
       label: "OpenCode config backup"
@@ -3669,7 +4803,7 @@ function applyOpenCodePlan(plan) {
   if (plan.action === "sync" || plan.action === "install") {
     const defaultAgentResult = disableDefaultAgents();
     if (!defaultAgentResult.success) {
-      return rejectPlan2(
+      return rejectPlan3(
         plan,
         defaultAgentResult.error ?? "Failed to disable OpenCode default agents."
       );
@@ -3686,7 +4820,7 @@ function applyOpenCodePlan(plan) {
       getExistingLiteConfigPath()
     );
     if (!liteResult.success) {
-      return rejectPlan2(
+      return rejectPlan3(
         plan,
         liteResult.error ?? "Failed to write thoth-agents config."
       );
@@ -3695,7 +4829,7 @@ function applyOpenCodePlan(plan) {
       ...targetForLiteConfig("installed"),
       observed: "seven-agent roster written"
     });
-    if (existsSync7(`${liteResult.configPath}.bak`)) {
+    if (existsSync10(`${liteResult.configPath}.bak`)) {
       backups.push({
         path: `${liteResult.configPath}.bak`,
         label: "thoth-agents config backup"
@@ -3727,7 +4861,8 @@ function applyOpenCodePlan(plan) {
 // src/cli/operations/index.ts
 var OPERATION_HARNESSES = {
   opencode: opencodeOperationAdapter,
-  codex: codexOperationAdapter
+  codex: codexOperationAdapter,
+  claude: claudeCodeOperationAdapter
 };
 var SUPPORTED_OPERATION_HARNESSES = Object.keys(
   OPERATION_HARNESSES
@@ -3742,14 +4877,27 @@ function getOperationHarness(harness) {
 }
 
 export {
+  claudeCodeAdapter,
   codexAdapter,
   CODEX_ROLE_NAMES,
   parseRoleTomlModel,
   buildCodexSetupPlan,
   formatCodexSetupPlan,
   applyCodexSetup,
+  CLAUDE_CODE_ROLE_NAMES,
+  parseSubagentModel,
+  buildClaudeCodeSetupPlan,
+  applyClaudeCodeSetup,
+  formatClaudeCodeSetupPlan,
   RECOMMENDED_SKILLS,
   installRecommendedSkill,
+  getClaudeCodeStatus,
+  buildClaudeCodeInstallPlan,
+  buildClaudeCodeUpdatePlan,
+  buildClaudeCodeSyncPlan,
+  buildClaudeCodeModelPlan,
+  applyClaudeCodePlan,
+  defaultClaudeCodeModelRoles,
   getCodexStatus,
   buildCodexUpdatePlan,
   buildCodexSyncPlan,