thoth-agents 0.1.19 → 0.2.0

package/dist/cli/claude-code-install.d.ts

@@ -0,0 +1,53 @@
+import { type ClaudeCodeModel, isClaudeCodeModel } from '../harness/writers/claude-code-subagent';
+import type { ClaudeCodeInstallScope, ClaudeCodeResolvedTargets, ClaudeCodeRoleName } from './claude-code-paths';
+import { type ManagedModelState } from './managed-state-io';
+export { CLAUDE_CODE_ROLE_NAMES } from './claude-code-paths';
+export declare const CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION = 1;
+export declare const CLAUDE_CODE_MODEL_ALIASES: readonly ["sonnet", "opus", "haiku", "inherit"];
+export type ClaudeCodeSetupAction = 'write-plugin-file' | 'write-managed-model-state';
+export type ClaudeCodeTargetKind = 'plugin-manifest' | 'subagent' | 'mcp-config' | 'hook' | 'skill' | 'plugin-asset' | 'managed-model-state';
+export interface ClaudeCodeInstallConfig {
+    dryRun?: boolean;
+    reset: boolean;
+    scope: ClaudeCodeInstallScope;
+    projectRoot: string;
+    homeDir?: string;
+    packageRoot?: string;
+}
+export interface ClaudeCodeSetupPlanItem {
+    kind: ClaudeCodeTargetKind;
+    action: ClaudeCodeSetupAction;
+    targetPath: string;
+    description: string;
+    requiresBackup: boolean;
+    content: string;
+    role?: ClaudeCodeRoleName;
+}
+export interface ClaudeCodeSetupPlan {
+    dryRun: boolean;
+    reset: boolean;
+    items: ClaudeCodeSetupPlanItem[];
+    diagnostics: string[];
+    disclaimers: string[];
+    pluginRoot: string;
+}
+export interface ClaudeCodeApplyResult {
+    success: boolean;
+    changed: string[];
+    diagnostics: string[];
+    error?: string;
+}
+export interface ClaudeCodeManagedModelOverride {
+    role: ClaudeCodeRoleName;
+    model: ClaudeCodeModel;
+}
+export declare const isClaudeCodeModelAlias: typeof isClaudeCodeModel;
+export declare function parseSubagentModel(content: string): string | undefined;
+export declare function replaceSubagentModel(content: string, model: string): string;
+export declare function parseManagedModelStateJson(text: string | undefined): ManagedModelState;
+export declare function readManagedModelState(path: string): ManagedModelState;
+export declare function buildClaudeCodeSetupPlan(config: ClaudeCodeInstallConfig): ClaudeCodeSetupPlan;
+export declare function applyClaudeCodeSetup(plan: ClaudeCodeSetupPlan): ClaudeCodeApplyResult;
+export declare function applyClaudeCodeManagedModelOverrides(config: ClaudeCodeInstallConfig, overrides: ClaudeCodeManagedModelOverride[]): ClaudeCodeApplyResult;
+export declare function formatClaudeCodeSetupPlan(plan: ClaudeCodeSetupPlan): string;
+export type { ClaudeCodeResolvedTargets };

package/dist/cli/claude-code-paths.d.ts

@@ -0,0 +1,31 @@
+export type ClaudeCodeInstallScope = 'project' | 'user';
+export type ClaudeCodeRoleName = 'explorer' | 'librarian' | 'oracle' | 'designer' | 'quick' | 'deep';
+export declare const CLAUDE_CODE_ROLE_NAMES: readonly ["explorer", "librarian", "oracle", "designer", "quick", "deep"];
+export interface ClaudeCodeTargetResolverOptions {
+    scope: ClaudeCodeInstallScope;
+    projectRoot: string;
+    homeDir?: string;
+}
+export interface ClaudeCodeResolvedTargets {
+    scope: ClaudeCodeInstallScope;
+    pluginRoot: string;
+    pluginManifestPath: string;
+    agentPaths: {
+        role: ClaudeCodeRoleName;
+        path: string;
+    }[];
+    mcpPath: string;
+    hooksPath: string;
+    skillsDir: string;
+    managedModelsPath: string;
+}
+/**
+ * Resolve the on-disk Claude Code plugin package targets. Claude Code plugins
+ * installed as a "skills-directory plugin": a folder under a Claude Code skills
+ * directory (`~/.claude/skills/<name>` for user scope, `<project>/.claude/skills/<name>`
+ * for project scope) that contains `.claude-plugin/plugin.json` is auto-loaded
+ * as `<name>@skills-dir` on the next session — no marketplace, no install step,
+ * discovered in place rather than copied to the `~/.claude/plugins/cache`.
+ * Only `plugin.json` sits in `.claude-plugin/`; components are plugin-root siblings.
+ */
+export declare function resolveClaudeCodeTargets(options: ClaudeCodeTargetResolverOptions): ClaudeCodeResolvedTargets;

package/dist/cli/codex-install.d.ts

@@ -1,4 +1,5 @@
 import type { CodexInstallScope, CodexRoleName } from './codex-paths';
+import { type ManagedModelState } from './managed-state-io';
 export { CODEX_ROLE_NAMES } from './codex-paths';
 export type CodexSetupAction = 'merge-managed-block' | 'write-role-toml' | 'write-managed-model-state' | 'refresh-package' | 'merge-marketplace' | 'merge-toml' | 'diagnose-only';
 export type CodexTargetKind = 'root-instructions' | 'role-subagent-toml' | 'managed-model-state' | 'user-config' | 'plugin-package' | 'personal-plugin-source' | 'personal-marketplace' | 'diagnostic';
@@ -37,11 +38,6 @@ export interface CodexApplyResult {
     error?: string;
 }
 export declare const MANAGED_MODEL_STATE_VERSION = 1;
-interface ManagedModelState {
-    version: typeof MANAGED_MODEL_STATE_VERSION;
-    models: Record<string, string>;
-    configuredModels?: Record<string, string>;
-}
 export declare function readManagedModelState(path: string): ManagedModelState;
 export declare function parseRoleTomlModel(content: string): string | undefined;
 export declare function replaceRoleTomlModel(content: string, model: string): string;

package/dist/cli/commands.d.ts

@@ -5,5 +5,5 @@ export declare function formatHarnessList(harnesses: readonly OperationHarnessMe
 export declare function formatOperationPlan(plan: OperationPlan): string;
 export declare function formatOperationApplyResult(result: OperationApplyResult): string;
 export declare function printHelp(): void;
-export declare function printCodexGeneration(args: GenerateArgs): number;
+export declare function printHarnessGeneration(args: GenerateArgs): number;
 export declare function runCliCommand(parsed: CliParseResult): Promise<number>;

package/dist/cli/index.js

@@ -2,15 +2,22 @@
 import {
   getOpenCodePath,
   getOpenCodeVersion,
-  isOpenCodeInstalled
-} from "../chunk-DYGVRAMS.js";
+  isOpenCodeInstalled,
+  opencodeAdapter
+} from "../chunk-4WYCZ5Z7.js";
 import {
   CODEX_ROLE_NAMES,
   RECOMMENDED_SKILLS,
   SUPPORTED_OPERATION_HARNESSES,
+  applyClaudeCodePlan,
+  applyClaudeCodeSetup,
   applyCodexPlan,
   applyCodexSetup,
   applyOpenCodePlan,
+  buildClaudeCodeModelPlan,
+  buildClaudeCodeSetupPlan,
+  buildClaudeCodeSyncPlan,
+  buildClaudeCodeUpdatePlan,
   buildCodexModelPlan,
   buildCodexSetupPlan,
   buildCodexSyncPlan,
@@ -18,14 +25,18 @@ import {
   buildOpenCodeModelPlan,
   buildOpenCodeSyncPlan,
   buildOpenCodeUpdatePlan,
+  claudeCodeAdapter,
   codexAdapter,
+  defaultClaudeCodeModelRoles,
+  formatClaudeCodeSetupPlan,
   formatCodexSetupPlan,
+  getClaudeCodeStatus,
   getCodexStatus,
   getOpenCodeStatus,
   getOperationHarness,
   installRecommendedSkill,
   listOperationHarnesses
-} from "../chunk-7CTSLCEU.js";
+} from "../chunk-WH3F3GWE.js";
 import {
   ALL_AGENT_NAMES,
   CUSTOM_SKILLS,
@@ -37,11 +48,22 @@ import {
   getExistingLiteConfigPath,
   installCustomSkills,
   writeLiteConfig
-} from "../chunk-2SGSRR6L.js";
+} from "../chunk-3NOVCFN7.js";
 
 // src/cli/index.ts
 import { pathToFileURL } from "url";
 
+// src/harness/registry.ts
+var HARNESS_ADAPTERS = {
+  opencode: opencodeAdapter,
+  codex: codexAdapter,
+  claude: claudeCodeAdapter
+};
+var SUPPORTED_HARNESSES = Object.keys(HARNESS_ADAPTERS);
+function getHarnessAdapter(harness) {
+  return HARNESS_ADAPTERS[harness];
+}
+
 // src/cli/install.ts
 import { existsSync } from "fs";
 import { homedir } from "os";
@@ -311,6 +333,26 @@ async function install(args) {
     );
     return 0;
   }
+  if (config.agent === "claude") {
+    const plan = buildClaudeCodeSetupPlan({
+      dryRun: config.dryRun,
+      reset: config.reset,
+      scope: "user",
+      projectRoot: cwd(),
+      homeDir: homedir()
+    });
+    console.log(formatClaudeCodeSetupPlan(plan));
+    const result = applyClaudeCodeSetup(plan);
+    for (const diagnostic of result.diagnostics) printInfo(diagnostic);
+    if (!result.success) {
+      printError(`Claude Code install failed: ${result.error}`);
+      return 1;
+    }
+    printSuccess(
+      config.dryRun ? "Claude Code dry-run complete; no files written" : "Claude Code plugin installed as thoth-agents@skills-dir (restart Claude Code or run /reload-plugins to activate)"
+    );
+    return 0;
+  }
   return runInstall(config);
 }
 
@@ -446,7 +488,7 @@ Usage: thoth-agents [COMMAND] [OPTIONS]
 
 Commands:
   (no command)          Open the interactive TUI in a TTY; fall back to OpenCode install in CI/non-TTY
-  install               Install OpenCode or Codex agent assets
+  install               Install OpenCode, Codex, or Claude Code agent assets
   generate              Generate harness-specific artifacts
   status                Show managed install status
   list                  List managed surfaces and actions
@@ -460,11 +502,13 @@ Options:
   --no-tui               Non-interactive mode
   --dry-run              Simulate install without writing files
   --reset                Repair managed installer-owned targets
-  --agent=opencode|codex Select OpenCode plugin install (default) or Codex agent-pack setup
+  --agent=opencode|codex|claude
+                         Select OpenCode plugin install (default), Codex agent-pack, or Claude Code plugin setup
+  --harness=...          Select harness for status/update/sync/model (opencode|codex|claude)
   -h, --help             Show this help message
 
 Generate options:
-  --harness=codex        Explicitly select Codex artifact generation
+  --harness=codex|claude  Select Codex or Claude Code artifact generation
   --output-root=PATH     Override generation root metadata
 
 OpenCode plugin config and the npm binary are separate surfaces.
@@ -490,10 +534,13 @@ Examples:
   pnpm dlx thoth-agents@latest install --agent=opencode
   pnpm dlx thoth-agents@latest install --agent=codex
   pnpm dlx thoth-agents@latest install --agent=codex --dry-run
+  pnpm dlx thoth-agents@latest install --agent=claude
+  pnpm dlx thoth-agents@latest install --agent=claude --dry-run
   pnpm dlx thoth-agents install --no-tui --tmux=no --skills=yes
   pnpm dlx thoth-agents install --dry-run
   pnpm dlx thoth-agents install --reset
   pnpm dlx thoth-agents generate --harness=codex --dry-run
+  pnpm dlx thoth-agents generate --harness=claude --dry-run
 `);
 }
 function operationContext() {
@@ -505,9 +552,11 @@ function selectedHarness(args, fallback = "opencode") {
 function statusReports(args) {
   const harnesses = args.all || !args.harness ? SUPPORTED_OPERATION_HARNESSES : [args.harness];
   const context = operationContext();
-  return harnesses.map(
-    (harness) => harness === "opencode" ? getOpenCodeStatus(context) : getCodexStatus(context)
-  );
+  return harnesses.map((harness) => {
+    if (harness === "opencode") return getOpenCodeStatus(context);
+    if (harness === "claude") return getClaudeCodeStatus(context);
+    return getCodexStatus(context);
+  });
 }
 function buildOperationPlan(command, args) {
   const harness = selectedHarness(args);
@@ -515,6 +564,9 @@ function buildOperationPlan(command, args) {
   if (harness === "opencode") {
     return command === "update" ? buildOpenCodeUpdatePlan(context) : buildOpenCodeSyncPlan(context);
   }
+  if (harness === "claude") {
+    return command === "update" ? buildClaudeCodeUpdatePlan(context) : buildClaudeCodeSyncPlan(context);
+  }
   return command === "update" ? buildCodexUpdatePlan(context) : buildCodexSyncPlan(context);
 }
 function defaultModelRoles(harness) {
@@ -524,6 +576,9 @@ function defaultModelRoles(harness) {
       model: "openai/gpt-5.4-mini"
     }));
   }
+  if (harness === "claude") {
+    return defaultClaudeCodeModelRoles();
+  }
   return ALL_AGENT_NAMES.map((role) => ({
     role,
     model: DEFAULT_MODELS[role] ?? "openai/gpt-5.4"
@@ -553,10 +608,14 @@ function buildModelPlan(args) {
     dryRun: true,
     roles: modelRoles(harness, args.roles)
   };
-  return harness === "opencode" ? buildOpenCodeModelPlan(input, context) : buildCodexModelPlan(input, context);
+  if (harness === "opencode") return buildOpenCodeModelPlan(input, context);
+  if (harness === "claude") return buildClaudeCodeModelPlan(input, context);
+  return buildCodexModelPlan(input, context);
 }
 function applyOperationPlan(plan) {
-  return plan.harness === "opencode" ? applyOpenCodePlan(plan) : applyCodexPlan(plan);
+  if (plan.harness === "opencode") return applyOpenCodePlan(plan);
+  if (plan.harness === "claude") return applyClaudeCodePlan(plan);
+  return applyCodexPlan(plan);
 }
 function printPlanOrApply(plan, args) {
   if (args.apply && args.dryRun) {
@@ -586,19 +645,18 @@ function runOperationCommand(command, args) {
   if (!plan) return printModelGuidance();
   return printPlanOrApply(plan, args);
 }
-function printCodexGeneration(args) {
+function printHarnessGeneration(args) {
   if (!args.dryRun) {
-    console.error(
-      "Codex generation is dry-run only in this MVP. Pass --dry-run."
-    );
+    console.error("Generation is dry-run only in this MVP. Pass --dry-run.");
     return 1;
   }
-  const result = codexAdapter.render({
+  const adapter = getHarnessAdapter(args.harness);
+  const result = adapter.render({
     projectRoot: process.cwd(),
     options: {
       dryRun: true,
       outputRoot: args.outputRoot,
-      targetHarness: "codex"
+      targetHarness: args.harness
     }
   });
   console.log(JSON.stringify(result, null, 2));
@@ -609,7 +667,7 @@ async function runCliCommand(parsed) {
     return install(parsed.installArgs);
   }
   if (parsed.command === "generate") {
-    return printCodexGeneration(parsed.generateArgs);
+    return printHarnessGeneration(parsed.generateArgs);
   }
   if (parsed.command === "help") {
     printHelp();
@@ -678,9 +736,9 @@ function parseBooleanArg(name, value) {
   return value;
 }
 function parseOperationHarness(value) {
-  if (value !== "opencode" && value !== "codex") {
+  if (value !== "opencode" && value !== "codex" && value !== "claude") {
     throw new Error(
-      `Unsupported operation harness: ${value}. Supported harnesses: opencode, codex.`
+      `Unsupported operation harness: ${value}. Supported harnesses: opencode, codex, claude.`
     );
   }
   return value;
@@ -772,9 +830,9 @@ function parseInstallArgs(args) {
       result.reset = true;
     } else if (arg.startsWith("--agent=")) {
       const agent = arg.split("=")[1];
-      if (agent !== "opencode" && agent !== "codex") {
+      if (agent !== "opencode" && agent !== "codex" && agent !== "claude") {
         throw new Error(
-          `Unsupported install agent: ${agent}. Supported agents: opencode, codex.`
+          `Unsupported install agent: ${agent}. Supported agents: opencode, codex, claude.`
         );
       }
       result.agent = agent;
@@ -789,10 +847,10 @@ function parseGenerateArgs(args) {
   for (const arg of args) {
     if (arg.startsWith("--harness=")) {
       const harness = arg.split("=")[1];
-      if (harness !== "codex") {
+      if (harness !== "codex" && harness !== "claude") {
         return {
           command: "error",
-          message: `Unsupported generate harness: ${harness}.`
+          message: `Unsupported generate harness: ${harness}. Supported harnesses: codex, claude.`
         };
       }
       result.harness = harness;
@@ -802,10 +860,10 @@ function parseGenerateArgs(args) {
       result.outputRoot = arg.split("=")[1];
     }
   }
-  if (result.harness !== "codex") {
+  if (result.harness !== "codex" && result.harness !== "claude") {
     return {
       command: "error",
-      message: "Codex generation requires --harness=codex."
+      message: "Generation requires --harness=codex or --harness=claude."
     };
   }
   return {

package/dist/cli/managed-state-io.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Harness-agnostic helpers shared by the Codex and Claude Code installers for
+ * managed file writes and managed-model-state JSON bookkeeping.
+ */
+export declare function writeTextWithBackup(path: string, content: string): boolean;
+export declare function stableJson(value: unknown): string;
+export declare function uniqueMessages(messages: string[]): string[];
+export declare function stringRecord(value: unknown): Record<string, string>;
+export interface ManagedModelState {
+    version: number;
+    models: Record<string, string>;
+    configuredModels?: Record<string, string>;
+}
+export declare function emptyManagedModelState(version: number): ManagedModelState;
+export declare function parseManagedModelStateJson(text: string | undefined, version: number): ManagedModelState;
+export declare function readManagedModelState(path: string, version: number): ManagedModelState;

package/dist/cli/operations/claude-code.d.ts

@@ -0,0 +1,21 @@
+import type { ClaudeCodeInstallScope } from '../claude-code-paths';
+import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
+export interface ClaudeCodeOperationContext extends OperationContext {
+    scope?: ClaudeCodeInstallScope;
+    homeDir?: string;
+    packageRoot?: string;
+}
+export declare const claudeCodeOperationAdapter: {
+    readonly id: "claude";
+    readonly displayName: "Claude Code";
+    readonly available: true;
+    readonly description: "Claude Code plugin package and managed subagent surfaces.";
+    readonly actions: HarnessAction[];
+};
+export declare function getClaudeCodeStatus(context?: ClaudeCodeOperationContext): HarnessStatusReport;
+export declare function buildClaudeCodeInstallPlan(context?: ClaudeCodeOperationContext): OperationPlan;
+export declare function buildClaudeCodeUpdatePlan(context?: ClaudeCodeOperationContext): OperationPlan;
+export declare function buildClaudeCodeSyncPlan(context?: ClaudeCodeOperationContext): OperationPlan;
+export declare function buildClaudeCodeModelPlan(input: ModelConfigInput, context?: ClaudeCodeOperationContext): OperationPlan;
+export declare function applyClaudeCodePlan(plan: OperationPlan): OperationApplyResult;
+export declare function defaultClaudeCodeModelRoles(): ModelRoleInput[];

package/dist/cli/tui/index.js

@@ -1,7 +1,14 @@
 import {
+  CLAUDE_CODE_ROLE_NAMES,
   CODEX_ROLE_NAMES,
+  applyClaudeCodePlan,
   applyCodexPlan,
   applyOpenCodePlan,
+  buildClaudeCodeInstallPlan,
+  buildClaudeCodeModelPlan,
+  buildClaudeCodeSetupPlan,
+  buildClaudeCodeSyncPlan,
+  buildClaudeCodeUpdatePlan,
   buildCodexInstallPlan,
   buildCodexModelPlan,
   buildCodexSetupPlan,
@@ -11,17 +18,20 @@ import {
   buildOpenCodeModelPlan,
   buildOpenCodeSyncPlan,
   buildOpenCodeUpdatePlan,
+  defaultClaudeCodeModelRoles,
+  getClaudeCodeStatus,
   getCodexStatus,
   getOpenCodeStatus,
   listOperationHarnesses,
-  parseRoleTomlModel
-} from "../../chunk-7CTSLCEU.js";
+  parseRoleTomlModel,
+  parseSubagentModel
+} from "../../chunk-WH3F3GWE.js";
 import {
   ALL_AGENT_NAMES,
   DEFAULT_MODELS,
   getExistingLiteConfigPath,
   parseConfig
-} from "../../chunk-2SGSRR6L.js";
+} from "../../chunk-3NOVCFN7.js";
 
 // src/cli/tui/index.tsx
 import { render } from "ink";
@@ -173,7 +183,7 @@ function ModelScreen({
   actions
 }) {
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: harness === "codex" ? "Codex writes generated subagent model lines only." : "OpenCode writes role model overrides in thoth-agents config." }),
+    /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: harness === "codex" ? "Codex writes generated subagent model lines only." : harness === "claude" ? "Claude Code writes subagent frontmatter model lines (sonnet, opus, haiku, inherit)." : "OpenCode writes role model overrides in thoth-agents config." }),
     harness === "codex" ? CODEX_MODEL_CATALOG_NOTE.map((note) => /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: note }, note)) : null,
     roles.map((role, index) => /* @__PURE__ */ jsxs4(
       Text4,
@@ -575,8 +585,19 @@ function getModelsDevCatalog() {
     return [];
   }
 }
+var CLAUDE_CODE_MODEL_OPTIONS = [
+  { id: "sonnet", label: "sonnet", provider: "anthropic" },
+  { id: "opus", label: "opus", provider: "anthropic" },
+  { id: "haiku", label: "haiku", provider: "anthropic" },
+  {
+    id: "inherit",
+    label: "inherit (main session model)",
+    provider: "anthropic"
+  }
+];
 function getModelOptions(harness) {
   if (harness === "codex") return getModelsDevCatalog();
+  if (harness === "claude") return CLAUDE_CODE_MODEL_OPTIONS;
   try {
     const invocation = getOpenCodeModelsInvocation();
     const output = execFileSync(
@@ -593,6 +614,10 @@ function getModelOptions(harness) {
 // src/cli/tui/operations.ts
 var context = { cwd: process.cwd() };
 var codexContext = { cwd: process.cwd() };
+var claudeCodeContext = {
+  cwd: process.cwd(),
+  scope: "user"
+};
 var opencodeModelRoles = ALL_AGENT_NAMES.map(
   (role) => ({
     role,
@@ -636,6 +661,27 @@ function getCodexModelRoles(source = codexContext) {
     return codexModelRoles.map((role) => ({ ...role }));
   }
 }
+function getClaudeCodeModelRoles(source = claudeCodeContext) {
+  try {
+    const plan = buildClaudeCodeSetupPlan({
+      dryRun: true,
+      reset: false,
+      scope: source.scope ?? "user",
+      projectRoot: source.cwd,
+      homeDir: source.homeDir,
+      packageRoot: source.packageRoot
+    });
+    return CLAUDE_CODE_ROLE_NAMES.map((role) => {
+      const item = plan.items.find(
+        (candidate) => candidate.kind === "subagent" && candidate.role === role
+      );
+      const model = item?.content ? parseSubagentModel(item.content) : void 0;
+      return { role, model: model ?? "inherit" };
+    });
+  } catch {
+    return defaultClaudeCodeModelRoles();
+  }
+}
 function readRoleModel(config, role) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return void 0;
@@ -659,14 +705,31 @@ function getOpenCodeModelRoles() {
   }));
 }
 function buildTuiModelPlan(harness, roles) {
-  return harness === "opencode" ? buildOpenCodeModelPlan({ harness, dryRun: true, roles }, context) : buildCodexModelPlan({ harness, dryRun: true, roles }, codexContext);
+  if (harness === "opencode") {
+    return buildOpenCodeModelPlan({ harness, dryRun: true, roles }, context);
+  }
+  if (harness === "claude") {
+    return buildClaudeCodeModelPlan(
+      { harness, dryRun: true, roles },
+      claudeCodeContext
+    );
+  }
+  return buildCodexModelPlan({ harness, dryRun: true, roles }, codexContext);
 }
 var defaultTuiOperations = {
   status(harness) {
-    return harness === "opencode" ? getOpenCodeStatus(context) : getCodexStatus(codexContext);
+    if (harness === "opencode") return getOpenCodeStatus(context);
+    if (harness === "claude") {
+      return getClaudeCodeStatus(claudeCodeContext);
+    }
+    return getCodexStatus(codexContext);
   },
   modelRoles(harness) {
-    return harness === "opencode" ? getOpenCodeModelRoles() : getCodexModelRoles(codexContext);
+    if (harness === "opencode") return getOpenCodeModelRoles();
+    if (harness === "claude") {
+      return getClaudeCodeModelRoles(claudeCodeContext);
+    }
+    return getCodexModelRoles(codexContext);
   },
   modelOptions(harness) {
     return getModelOptions(harness);
@@ -678,6 +741,19 @@ var defaultTuiOperations = {
       if (action === "sync") return buildOpenCodeSyncPlan(context);
       return buildTuiModelPlan(harness, getOpenCodeModelRoles());
     }
+    if (harness === "claude") {
+      if (action === "install") {
+        return buildClaudeCodeInstallPlan(claudeCodeContext);
+      }
+      if (action === "update") {
+        return buildClaudeCodeUpdatePlan(claudeCodeContext);
+      }
+      if (action === "sync") return buildClaudeCodeSyncPlan(claudeCodeContext);
+      return buildTuiModelPlan(
+        harness,
+        getClaudeCodeModelRoles(claudeCodeContext)
+      );
+    }
     if (action === "install") return buildCodexInstallPlan(codexContext);
     if (action === "update") return buildCodexUpdatePlan(codexContext);
     if (action === "sync") return buildCodexSyncPlan(codexContext);
@@ -687,7 +763,9 @@ var defaultTuiOperations = {
     return buildTuiModelPlan(harness, roles);
   },
   apply(plan) {
-    return plan.harness === "opencode" ? applyOpenCodePlan(plan) : applyCodexPlan(plan);
+    if (plan.harness === "opencode") return applyOpenCodePlan(plan);
+    if (plan.harness === "claude") return applyClaudeCodePlan(plan);
+    return applyCodexPlan(plan);
   }
 };
 
@@ -1185,7 +1263,7 @@ function App({
       /* @__PURE__ */ jsx8(
         Header,
         {
-          title: `${modelHarness === "codex" ? "Codex" : "OpenCode"} Models`,
+          title: `${modelHarness === "codex" ? "Codex" : modelHarness === "claude" ? "Claude Code" : "OpenCode"} Models`,
           subtitle: "Enter edits a role. Dirty rows are marked with *."
         }
       ),

package/dist/cli/tui/operations.d.ts

@@ -1,4 +1,5 @@
 import type { HarnessId } from '../../harness/types';
+import { type ClaudeCodeOperationContext } from '../operations/claude-code';
 import { type CodexOperationContext } from '../operations/codex';
 import type { HarnessStatusReport, ModelRoleInput, OperationApplyResult, OperationPlan } from '../operations/types';
 import { type ModelOption } from './model-catalog';
@@ -14,5 +15,6 @@ export interface TuiOperations {
 export declare const opencodeModelRoles: ModelRoleInput[];
 export declare const codexModelRoles: ModelRoleInput[];
 export declare function getCodexModelRoles(source?: CodexOperationContext): ModelRoleInput[];
+export declare function getClaudeCodeModelRoles(source?: ClaudeCodeOperationContext): ModelRoleInput[];
 export declare function getOpenCodeModelRoles(): ModelRoleInput[];
 export declare const defaultTuiOperations: TuiOperations;

package/dist/cli/types.d.ts

@@ -1,5 +1,5 @@
 export type BooleanArg = 'yes' | 'no';
-export type InstallAgent = 'opencode' | 'codex';
+export type InstallAgent = 'opencode' | 'codex' | 'claude';
 export interface InstallArgs {
     tui: boolean;
     agent?: InstallAgent;
@@ -9,11 +9,11 @@ export interface InstallArgs {
     reset?: boolean;
 }
 export interface GenerateArgs {
-    harness: 'codex';
+    harness: 'codex' | 'claude';
     dryRun?: boolean;
     outputRoot?: string;
 }
-export type OperationHarnessArg = 'opencode' | 'codex';
+export type OperationHarnessArg = 'opencode' | 'codex' | 'claude';
 export interface CliModelRoleArg {
     role: string;
     model: string;

package/dist/config/index.d.ts

@@ -2,4 +2,4 @@ export * from './constants';
 export { loadAgentPrompt, loadPluginConfig } from './loader';
 export type { ThothConfig } from './schema';
 export * from './schema';
-export { getAgentOverride } from './utils';
+export { getAgentOverride, getPrimaryModelId } from './utils';

package/dist/config/schema.d.ts

@@ -143,6 +143,12 @@ export declare const CodexGenerationConfigSchema: z.ZodObject<{
     dryRun: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type CodexGenerationConfig = z.infer<typeof CodexGenerationConfigSchema>;
+export declare const ClaudeCodeGenerationConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    outputRoot: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ClaudeCodeGenerationConfig = z.infer<typeof ClaudeCodeGenerationConfigSchema>;
 export declare const FailoverConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     timeoutMs: z.ZodDefault<z.ZodNumber>;
@@ -275,6 +281,11 @@ export declare const PluginConfigSchema: z.ZodObject<{
         outputRoot: z.ZodOptional<z.ZodString>;
         dryRun: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    claudeCode: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        outputRoot: z.ZodOptional<z.ZodString>;
+        dryRun: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PluginConfig = z.infer<typeof PluginConfigSchema>;
 export type { AgentName } from './constants';