thoth-agents 0.2.11 → 0.3.0

package/dist/{chunk-ASKXWU6E.js → chunk-2MZ5C2RN.js}

@@ -5,31 +5,25 @@ import {
   CODEX_PROMPT_DIALECT,
   CONFIRMED_OPENAI_SUBAGENT_PRESET,
   CONTEXT7_MCP_URL,
-  CUSTOM_SKILLS,
   DEFAULT_MODELS,
-  DEFAULT_THOTH_COMMAND,
   GREP_APP_MCP_URL,
   appendPromptSections,
-  checkCustomSkillsNeedUpdate,
   claudeCodeSubagentType,
   composeAgentPrompt,
   createModelFamilySection,
-  createOrchestratorPromptSections,
-  createReadOnlySpecialistPromptSections,
+  createRolePromptSections,
   createStepBudgetSection,
-  createWriteCapableSpecialistPromptSections,
   ensureConfigDir,
   exa,
-  findPackageRoot,
   generateLiteConfig,
   getAgentOverride,
-  getCustomSkillsDir,
+  getAgentPackContract,
+  getDefaultOpenCodeModel,
+  getDefaultOpenCodeVariant,
   getExistingConfigPath,
   getExistingLiteConfigPath,
   getOpenCodeManagedModelStatePath,
   getPrimaryModelId,
-  getSkillRegistry,
-  installCustomSkills,
   loadAgentPrompt,
   parseConfig,
   renderPromptSection,
@@ -37,7 +31,7 @@ import {
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-OZE7JVGS.js";
+} from "./chunk-XO74DXBZ.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -72,14 +66,7 @@ function resolveCodexTargets(options) {
       ".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"
-    )
+    packageRoot: join(options.projectRoot, ".codex-plugin")
   };
 }
 
@@ -96,234 +83,80 @@ function isExplicitEffort(selection) {
 }
 
 // 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 { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { basename } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/harness/adapters/codex.ts
 import { fileURLToPath } from "url";
 
-// src/harness/core/agent-pack.ts
-var AGENT_ROLES = [
-  {
-    name: "orchestrator",
-    mode: "primary-non-mutating",
-    dispatch: "root-coordinator",
-    canMutateWorkspace: false,
-    scope: "coordination, routing, decisions, progress, and root memory",
-    responsibility: "Delegate-first coordinator for SDD workflow, specialist dispatch, and root-session memory ownership.",
-    toolGovernance: [
-      "delegates inspection, writing, debugging, and verification",
-      "owns question prompts and root-session memory",
-      "does not perform inline workspace implementation"
-    ],
-    verification: [
-      "routes verification to specialists",
-      "summarizes evidence from changed files, diagnostics, and tests"
-    ]
-  },
-  {
-    name: "explorer",
-    mode: "read-only",
-    dispatch: "task",
-    canMutateWorkspace: false,
-    scope: "local repository discovery",
-    responsibility: "Find workspace facts fast and return paths, lines, symbols, constraints, edit targets, and conclusions.",
-    toolGovernance: [
-      "read/search/code-navigation tools only",
-      "no durable memory writes",
-      "no task delegation or progress ownership"
-    ],
-    verification: ["reports confidence, anchors, unchecked areas, and gaps"]
-  },
-  {
-    name: "librarian",
-    mode: "read-only",
-    dispatch: "task",
-    canMutateWorkspace: false,
-    scope: "external research plus local confirmation when needed",
-    responsibility: "Gather authoritative external evidence and distinguish official docs from examples.",
-    toolGovernance: [
-      "research and read-only local confirmation tools",
-      "no workspace mutation",
-      "no durable memory writes"
-    ],
-    verification: ["sources every substantive external claim with a URL"]
-  },
-  {
-    name: "oracle",
-    mode: "read-only",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: false,
-    scope: "advice, diagnosis, architecture, code review, and plan review",
-    responsibility: "Provide strategic technical guidance anchored to evidence and review SDD plans.",
-    toolGovernance: [
-      "read-only analysis and review",
-      "no implementation; may perform read-only SDD plan review and verification review, but does not persist artifacts",
-      "no task delegation"
-    ],
-    verification: ["separates observations, risks, and recommendations"]
-  },
-  {
-    name: "designer",
-    mode: "write-capable",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: true,
-    scope: "UI/UX decisions, implementation, and visual verification",
-    responsibility: "Own user-facing implementation choices and visual QA for UI work.",
-    toolGovernance: [
-      "may edit focused UI/UX files",
-      "owns screenshots and visual QA",
-      "does not delegate or own SDD progress"
-    ],
-    verification: ["includes visual verification status when applicable"]
-  },
-  {
-    name: "quick",
-    mode: "write-capable",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: true,
-    scope: "fast bounded implementation",
-    responsibility: "Implement well-defined narrow or mechanical changes with focused verification.",
-    toolGovernance: [
-      "may edit bounded targets",
-      "does not perform broad rediscovery",
-      "does not delegate or own SDD progress"
-    ],
-    verification: ["runs the smallest sufficient focused check"]
-  },
-  {
-    name: "deep",
-    mode: "write-capable",
-    dispatch: "synchronous-task-only",
-    canMutateWorkspace: true,
-    scope: "thorough implementation and verification",
-    responsibility: "Handle correctness-critical, multi-file, or edge-case-heavy changes with full local context analysis.",
-    toolGovernance: [
-      "may edit implementation and tests",
-      "validates shared behavior against related code and call sites",
-      "does not delegate or own SDD progress"
-    ],
-    verification: ["does not skip verification and reports edge-case evidence"]
-  }
-];
-var DELEGATE_FIRST_RULES = [
-  "The orchestrator coordinates, decides, asks blocking questions, and delegates evidence or action.",
-  "Explorer, librarian, and oracle remain read-only specialists.",
-  "Designer, quick, and deep are write-capable leaf agents with synchronous task dispatch.",
-  "Subagents return findings, diffs, verification, and blockers rather than raw file dumps.",
-  "No leaf agent owns SDD progress checkboxes or orchestrator-only memory."
-];
-var VERIFICATION_PROTOCOL = [
-  "Completion reports include changed files and verification evidence.",
-  "Behavior changes require the smallest sufficient automated check or an explicitly documented check.",
-  "Visual changes require designer-owned visual QA when feasible."
-];
-var AGENT_PACK_CONTRACT = {
-  roles: [...AGENT_ROLES],
-  delegateFirstRules: [...DELEGATE_FIRST_RULES],
-  verificationProtocol: [...VERIFICATION_PROTOCOL]
-};
-function getAgentPackContract() {
-  return {
-    roles: AGENT_PACK_CONTRACT.roles.map((role) => ({
-      ...role,
-      toolGovernance: [...role.toolGovernance],
-      verification: [...role.verification]
-    })),
-    delegateFirstRules: [...AGENT_PACK_CONTRACT.delegateFirstRules],
-    verificationProtocol: [...AGENT_PACK_CONTRACT.verificationProtocol]
-  };
+// src/agents/configured-role-prompt.ts
+function renderConfiguredRolePrompt({
+  role,
+  dialect,
+  config,
+  model
+}) {
+  const promptOverrides = loadAgentPrompt(role, config?.preset);
+  const override = getAgentOverride(config, role);
+  const modelSection = createModelFamilySection(role, model);
+  const stepSection = createStepBudgetSection(override?.steps);
+  const basePrompt = renderRolePrompt(createRolePromptSections(role), dialect);
+  const prompt = composeAgentPrompt({
+    basePrompt,
+    customPrompt: promptOverrides.prompt,
+    customAppendPrompt: appendPromptSections(
+      modelSection ? renderPromptSection(modelSection, dialect) : void 0,
+      promptOverrides.appendPrompt
+    )
+  });
+  return appendPromptSections(
+    prompt,
+    stepSection ? renderPromptSection(stepSection, dialect) : void 0
+  );
 }
 
 // src/harness/core/memory-governance.ts
-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 PARENT_SCOPED_READ_TOOLS = [
-  "mem_recall",
-  "mem_context",
-  "mem_get",
-  "mem_project"
-];
-var WRITE_CAPABLE_DELEGATED_TOOLS = [
-  ...PARENT_SCOPED_READ_TOOLS,
-  "mem_save"
-];
-var ALL_MEMORY_TOOLS = [
-  "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 [...ALL_MEMORY_TOOLS];
-  }
-  if (role.mode === "read-only") {
-    return [...PARENT_SCOPED_READ_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 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 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."
+  const sharedRules = [
+    "thoth-mem remains an external provider; its installed provider guidance is authoritative for memory operations and thoth-agents does not prescribe the mechanism.",
+    "Provider-dependent use requires parent-scoped authorization with the stable root session identity or explicit unavailable state and project supplied by dispatch.",
+    "The MEMORY authorization is none, recall, or observe: none forbids provider work, recall permits bounded reads, and observe additionally permits one bounded durable observation under the delegated scope.",
+    "Only authorized context may be used, and the delegate must report missing, stale, contradictory, or insufficient context instead of guessing.",
+    "Memory authorization never changes workspace permissions or grants control of root lifecycle and real-user-intent ownership.",
+    "A handoff must keep accepted scope, decisions, permissions, and artifacts plus bounded memory context available to the authorized delegate.",
+    "Completion continuity is a provider-confirmed semantic summary outcome owned by the root.",
+    "Missing capability evidence is reported as degraded or unsupported and never as successful persistence or recovery.",
+    "openspec/ is the canonical SDD store; do not mirror spec.md, plan.md, tasks.md, verification reports, or archive reports into provider memory.",
+    "Do not invent a consumer fallback or silently change the selected persistence mode."
   ];
   if (role.name === "orchestrator") {
     return [
-      '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(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."
+      ...sharedRules,
+      "The root coordinator owns authorization, root lifecycle, real-user-intent handling, and semantic completion outcomes.",
+      "Dispatch task and authorization context without embedding secrets, raw transcripts, or irrelevant context."
     ];
   }
   if (role.mode === "read-only") {
     return [
-      ...sharedSubagentRules,
-      "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."
+      ...sharedRules,
+      "For a read-only workspace role, observe may authorize a durable provider observation but does not authorize workspace mutation.",
+      "Root lifecycle ownership never transfers to this delegate."
     ];
   }
   return [
-    ...sharedSubagentRules,
-    "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."
+    ...sharedRules,
+    "For a write-capable workspace role, provider observations still require observe authorization and the delegated parent scope.",
+    "Root lifecycle ownership never transfers to this delegate."
   ];
 }
 function getRoleMemoryGovernance(role) {
-  const allowedTools = roleAllowedTools(role);
   return {
     role: role.name,
-    rootOwnedOperations: [...ROOT_OWNED_OPERATIONS],
-    allowedTools,
-    forbiddenTools: ALL_MEMORY_TOOLS.filter(
-      (tool) => !allowedTools.includes(tool)
-    ),
+    workspaceMode: role.mode,
     requiresParentContext: role.name !== "orchestrator",
-    mayReadProjectMemory: true,
-    mayWriteDurableObservations: role.mode === "write-capable",
-    protectsSddNamespace: true,
+    availableAuthorizations: ["none", "recall", "observe"],
+    ownsRootLifecycle: role.name === "orchestrator",
     rules: roleRules(role)
   };
 }
@@ -334,10 +167,10 @@ function renderMemoryGovernanceInstructions(role, dialect) {
     `- Progress ownership remains with the coordinator; report memory-governance verification for tracking in ${dialect.tools.progressTool}.`
   ] : [];
   return [
-    "thoth-mem governance:",
+    "External thoth-mem provider memory governance:",
     ...governance.rules.map((rule) => `- ${rule}`),
     ...harnessRules,
-    `- Runtime enforcement: ${role.name === "orchestrator" ? "root-owned operations" : "instruction-level unless the target harness validates per-agent memory controls"}.`
+    `- Runtime enforcement: ${role.name === "orchestrator" ? "root-owned outcomes" : "instruction-level unless the target harness validates per-agent memory controls"}.`
   ].join("\n");
 }
 function memoryGovernanceDiagnostics(input) {
@@ -346,7 +179,7 @@ function memoryGovernanceDiagnostics(input) {
     diagnostics.push({
       severity: "warning",
       code: `${input.harness}.permission.memory.enforcement_gap`,
-      message: "Runtime controls for root-owned memory operations are unavailable; governance is rendered as instruction-level guidance.",
+      message: "Runtime controls for provider authorization are unavailable; instruction-level guidance must report capability as degraded or unsupported rather than treating instruction text as runtime support.",
       harness: input.harness,
       capability: "rolePermissions",
       fallback: "instruction-only"
@@ -356,7 +189,7 @@ function memoryGovernanceDiagnostics(input) {
     diagnostics.push({
       severity: input.parentContextInjection === "unknown" ? "error" : "warning",
       code: `${input.harness}.context.parent_injection.unvalidated`,
-      message: "Parent session_id/project injection is not runtime-enforced; subagents must be instructed not to use memory without explicit dispatch context and handoff recovery instructions.",
+      message: "Parent-scoped authorization is not runtime-enforced; provider-backed continuity is degraded or unsupported without evidenced authorized context.",
       harness: input.harness,
       capability: "parentContextInjection",
       fallback: "instruction-only"
@@ -366,7 +199,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(kind="observation") limits for durable observations and deterministic SDD artifacts only.',
+      message: "Runtime controls for delegated provider writes are unavailable; report the outcome as degraded or unsupported unless caller-supplied evidence proves success.",
       harness: input.harness,
       capability: "memoryGovernanceEnforcement",
       fallback: "instruction-only"
@@ -590,10 +423,10 @@ var CODEX_SURFACES = [
     target: "mcp-config",
     status: "validated",
     artifactKind: "mcp-config",
-    path: ".codex-plugin/.mcp.json",
-    fields: ["mcpServers", "./.mcp.json"],
+    path: ".codex-plugin/codex.mcp.json",
+    fields: ["mcpServers", "./codex.mcp.json"],
     diagnosticCode: "codex.surface.plugin_mcp_json.validated",
-    summary: "Codex plugin packages can bundle MCP server definitions in plugin-root .mcp.json.",
+    summary: "Codex plugin packages can reference bundled MCP server definitions from the plugin root.",
     evidence: "OpenAI Codex plugin docs describe bundled .mcp.json server definitions referenced from plugin.json using plugin-root relative paths."
   },
   {
@@ -843,10 +676,21 @@ var PLUGIN_MANIFEST_SURFACE_ID = "plugin-manifest-json";
 function normalizePath(value) {
   return value.replace(/\\/g, "/");
 }
+function stripProviderMcp(content) {
+  if (content === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.mcpServers) return content;
+    const { thoth_mem: _provider, ...mcpServers } = parsed.mcpServers;
+    return stableJson({ ...parsed, mcpServers });
+  } catch {
+    return content;
+  }
+}
 function pluginRootReference(pathValue) {
   const normalized = normalizePath(pathValue);
-  const relative4 = normalized.slice(".codex-plugin/".length);
-  return `./${relative4}`;
+  const relative = normalized.slice(".codex-plugin/".length);
+  return `./${relative}`;
 }
 function sha256(content) {
   return `sha256:${createHash("sha256").update(content).digest("hex")}`;
@@ -886,9 +730,9 @@ function artifactKindForSurface(surfaceId) {
   if (surfaceId === "plugin-mcp-json") return "mcp-config";
   return surfaceId === "plugin-hooks-json" ? "hook-config" : "skill";
 }
-function codexHookPackageDiagnostic(code, message) {
+function codexHookPackageDiagnostic(code, message, severity = "warning") {
   return {
-    severity: "warning",
+    severity,
     code,
     message,
     harness: "codex",
@@ -919,7 +763,8 @@ function renderHookDefinitions(hookDefinitions) {
     diagnostics.push(
       codexHookPackageDiagnostic(
         "codex.plugin.hooks.none_packaged",
-        "No Codex plugin hooks were packaged because no hook definitions passed existing Codex hook validation."
+        "No Codex plugin hooks were packaged because no hook definitions passed existing Codex hook validation.",
+        "info"
       )
     );
     return { diagnostics };
@@ -1050,7 +895,8 @@ function renderCodexPluginPackage(input) {
     if (asset.surfaceId === "plugin-hooks-json" && !hookContent.content) {
       continue;
     }
-    const assetContent = hookContent.content ?? asset.content;
+    const rawAssetContent = hookContent.content ?? asset.content;
+    const assetContent = asset.surfaceId === "plugin-mcp-json" ? stripProviderMcp(rawAssetContent) : rawAssetContent;
     const reference = pluginRootReference(assetPath);
     manifest[asset.manifestField] = reference;
     if (assetContent !== void 0 && !assetPath.endsWith("/")) {
@@ -1119,6 +965,13 @@ function renderField(key, value) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function stripProviderMcpValues(surfaceId, values) {
+  if (surfaceId !== "mcp-server-config") return values;
+  const servers = values.mcp_servers;
+  if (!isRecord2(servers)) return values;
+  const { thoth_mem: _provider, ...mcpServers } = servers;
+  return { ...values, mcp_servers: mcpServers };
+}
 function fieldOrder(fields, keys) {
   const orderedRoots = fields.map((field) => field.split(".")[0]);
   return [...keys].sort((left, right) => {
@@ -1161,8 +1014,9 @@ function renderCodexToml(input) {
   const diagnostics = [];
   const lines = [];
   const tables = [];
-  for (const key of fieldOrder(fields, Object.keys(input.values))) {
-    const value = input.values[key];
+  const values = stripProviderMcpValues(input.surfaceId, input.values);
+  for (const key of fieldOrder(fields, Object.keys(values))) {
+    const value = values[key];
     if (!isAllowedRoot(fields, key)) {
       diagnostics.push({
         severity: "warning",
@@ -1191,144 +1045,6 @@ 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";
-function normalizeSkillPath(value) {
-  return value.split(path.sep).join("/");
-}
-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(...collectSkillFiles(entryPath));
-    } else if (entry.isFile()) {
-      files.push(entryPath);
-    }
-  }
-  return files.sort((left, right) => left.localeCompare(right));
-}
-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"];
-  return [...new Set(modes)];
-}
-function duplicateScopeDiagnostic(skillNames, surfaceId) {
-  if (skillNames.length === 0) return void 0;
-  return {
-    severity: "warning",
-    code: "codex.skill.duplicate_scope_precedence_unverified",
-    message: `Codex skills are selected for both plugin-bundled and fallback .agents/skills scopes: ${skillNames.join(", ")}. Plugin-bundled skills are the intended primary package content, but runtime precedence with fallback scopes is unresolved and must be validated before relying on ordering.`,
-    harness: "codex",
-    surface: surfaceId,
-    fallback: "diagnostic-only"
-  };
-}
-function renderCodexSkillLayout(input) {
-  const surface = assertCodexSurfaceCanGenerate(input.surfaceId);
-  if (!surface.ok) {
-    return { artifacts: [], diagnostics: [surface.diagnostic] };
-  }
-  const artifacts = [];
-  const diagnostics = [];
-  const outputModes = resolveOutputModes(input);
-  for (const mode of outputModes) {
-    const modeSurface = assertCodexSurfaceCanGenerate(
-      OUTPUT_MODE_CONFIG[mode].surfaceId
-    );
-    if (!modeSurface.ok) diagnostics.push(modeSurface.diagnostic);
-  }
-  const duplicateDiagnostic = duplicateScopeDiagnostic(
-    outputModes.length > 1 ? input.skills.map((skill) => skill.name).sort() : [],
-    input.surfaceId
-  );
-  if (duplicateDiagnostic) diagnostics.push(duplicateDiagnostic);
-  const manifests = new Map(
-    outputModes.map((mode) => [mode, []])
-  );
-  for (const skill of [...input.skills].sort(
-    (left, right) => left.name.localeCompare(right.name)
-  )) {
-    const sourceBaseRoot = input.packageRoot ?? input.projectRoot;
-    const sourceRoot = path2.join(sourceBaseRoot, skill.sourcePath);
-    const files = collectSkillFiles(sourceRoot);
-    if (files.length === 0) {
-      diagnostics.push({
-        severity: "warning",
-        code: "codex.skill.source_missing",
-        message: `Skipping Codex skill "${skill.name}" because source path "${skill.sourcePath}" was not found.`,
-        harness: "codex",
-        surface: input.surfaceId,
-        fallback: "diagnostic-only"
-      });
-      continue;
-    }
-    for (const file of files) {
-      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}/${relative4}`;
-        artifacts.push({
-          harness: "codex",
-          kind: "skill",
-          path: outputPath,
-          description: `Codex ${config.label} skill artifact for ${skill.name}`,
-          content
-        });
-        manifests.get(mode)?.push({
-          name: skill.name,
-          sourcePath,
-          outputPath,
-          sha256: sha256Hash(content)
-        });
-      }
-    }
-  }
-  for (const mode of outputModes) {
-    const config = OUTPUT_MODE_CONFIG[mode];
-    artifacts.push({
-      harness: "codex",
-      kind: "manifest",
-      path: config.manifestPath,
-      description: `Generated Codex ${config.label} skill source manifest with source hashes.`,
-      content: `${JSON.stringify({ generatedBy: "thoth-agents", skills: manifests.get(mode) ?? [] }, null, 2)}
-`
-    });
-  }
-  return { artifacts, diagnostics };
-}
-
 // src/harness/adapters/codex.ts
 function readRootPackageVersion(context2) {
   const packageJsonPath = findRootPackageJsonPath([
@@ -1343,20 +1059,13 @@ function createCodexPluginPackageManifest(context2) {
   return {
     name: "thoth-agents",
     version: readRootPackageVersion(context2),
-    description: "Delegate-first OpenCode plugin with seven agents, thoth-mem persistence, and bundled SDD skills."
+    description: "Bundled Spec Kit-compatible SDD skills and MCP configuration; the seven-role global Codex layer requires thoth-agents CLI setup."
   };
 }
 function stableJson2(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
-function codexCommandConfig(commandParts) {
-  const [command = "", ...args] = commandParts;
-  return {
-    command,
-    ...args.length > 0 ? { args } : {}
-  };
-}
 function codexMcpConfig(config) {
   if ("url" in config) {
     return { url: config.url };
@@ -1372,8 +1081,7 @@ function createCodexBuiltinMcpServers() {
   return {
     exa: codexMcpConfig(exa),
     context7: { url: CONTEXT7_MCP_URL },
-    grep_app: { url: GREP_APP_MCP_URL },
-    thoth_mem: codexCommandConfig(DEFAULT_THOTH_COMMAND)
+    grep_app: { url: GREP_APP_MCP_URL }
   };
 }
 function createCodexBuiltinMcpJsonConfig() {
@@ -1392,65 +1100,19 @@ function isCodexSubagentName(name) {
 var CODEX_ROOT_START = "<!-- thoth-agents:codex-root:start -->";
 var CODEX_ROOT_END = "<!-- thoth-agents:codex-root:end -->";
 var CODEX_CAPABILITIES = CODEX_PROMPT_DIALECT.capabilities.capabilities;
-function codexPromptSections(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 codexModelFamilyPromptSection(roleName, model) {
-  const section = createModelFamilySection(roleName, model);
-  return section ? renderPromptSection(section, CODEX_PROMPT_DIALECT) : void 0;
-}
-function codexStepBudgetPromptSection(steps) {
-  const section = createStepBudgetSection(steps);
-  return section ? renderPromptSection(section, CODEX_PROMPT_DIALECT) : void 0;
-}
-function renderCodexRolePrompt(roleName, config, model) {
-  const promptOverrides = loadAgentPrompt(roleName, config?.preset);
-  const override = getAgentOverride(config, roleName);
-  const basePrompt = renderRolePrompt(
-    codexPromptSections(roleName),
-    CODEX_PROMPT_DIALECT
-  );
-  const prompt = composeAgentPrompt({
-    basePrompt,
-    customPrompt: promptOverrides.prompt,
-    customAppendPrompt: appendPromptSections(
-      codexModelFamilyPromptSection(roleName, model),
-      promptOverrides.appendPrompt
-    )
-  });
-  return appendPromptSections(
-    prompt,
-    codexStepBudgetPromptSection(override?.steps)
-  );
-}
-function codexInternalHandoffGuidance() {
+function codexRuntimeGuidance() {
   return [
-    "<codex-delegation-guidance>",
-    "- The user has explicitly authorized this generated Codex orchestrator to use `collaboration.spawn_agent` whenever delegation is required by these instructions, without needing a fresh user request for subagents in each task.",
+    "<codex-runtime>",
+    "- The ambient Codex session is the adaptive root; no orchestrator child TOML is generated.",
+    "- Delegate with `collaboration.spawn_agent` only when the root determines that specialization, context isolation, review, or independent parallel work creates a net gain.",
     "- Collaboration tools are direct tools and must not be called from inside `functions.exec`.",
-    "- Delegate with `collaboration.spawn_agent` using `task_name`, `message`, and optional `fork_turns`; `fork_turns` must be `none`, `all`, or a positive integer string.",
-    "- Role behavior is carried by `task_name` and `message`; named installed-role selection and hard role/profile enforcement are instruction-level because this surface has no role selector.",
-    "- 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`.",
-    "- `collaboration.wait_agent` waits for mailbox updates. A `collaboration.wait_agent` timeout or silence is nonterminal and remains in progress, so inspect `collaboration.list_agents` with the same task path before deciding what to do next.",
-    "- `collaboration.send_message` delivers a message without triggering a turn; `collaboration.followup_task` triggers a turn when an idle task must continue.",
-    "- Use `collaboration.interrupt_agent` only for explicit cancellation, a deadline, or supersession.",
-    "- Do not invent result payloads or numeric wait, poll, or timeout rules.",
-    "- Memory ownership, handoff recovery, permissions, and prompt-body exclusion are instruction-level unless the active Codex runtime documents stronger enforcement.",
-    "</codex-delegation-guidance>"
+    "- Use a role-prefixed `task_name` and a self-contained English `message` with scope, anchors, constraints, verification, and the compact return contract. The current collaboration surface has no hard custom-role selector, so role selection remains instruction-level.",
+    "- Keep maximum depth 1: children do not delegate. Use one writer per mutable surface and parallelize only independent work.",
+    "- A `collaboration.wait_agent` timeout is nonterminal; inspect `collaboration.list_agents` for the same task before rerouting or interrupting it.",
+    "- Use `request_user_input` only for blocking material choices and always omit `autoResolutionMs` entirely.",
+    "- Generated custom-agent TOMLs carry model and sandbox defaults, but permissions and role matching may remain instruction-level in the active host.",
+    "- Installed provider guidance owns memory, persistence, hooks, MCP lifecycle, and recovery mechanics.",
+    "</codex-runtime>"
   ].join("\n");
 }
 function codexRoleInstructions(role) {
@@ -1471,37 +1133,28 @@ function codexRoleInstructions(role) {
 function roleInstructions(role, config) {
   const model = getCodexAgentModel(role, config) ?? DEFAULT_MODELS[role.name];
   return [
-    renderCodexRolePrompt(role.name, config, model),
+    renderConfiguredRolePrompt({
+      role: role.name,
+      dialect: CODEX_PROMPT_DIALECT,
+      config,
+      model
+    }),
     codexRoleInstructions(role),
     renderMemoryGovernanceInstructions(role, CODEX_PROMPT_DIALECT)
   ].join("\n\n");
 }
 function renderCodexRootInstructions(config) {
   const rootOverride = getAgentOverride(config, "orchestrator");
-  const rootPrompt = renderCodexRolePrompt(
-    "orchestrator",
+  const rootPrompt = renderConfiguredRolePrompt({
+    role: "orchestrator",
+    dialect: CODEX_PROMPT_DIALECT,
     config,
-    rootOverride?.model ?? DEFAULT_MODELS.orchestrator
-  );
+    model: rootOverride?.model ?? DEFAULT_MODELS.orchestrator
+  });
   return [
     CODEX_ROOT_START,
     rootPrompt,
-    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, first resolve the stable root session identity from Codex request metadata in this order: `nodeRepl.requestMeta["x-codex-turn-metadata"].session_id`, then `nodeRepl.requestMeta["x-codex-turn-metadata"].thread_id`, then `nodeRepl.requestMeta.threadId`. Do not use `nodeRepl.requestMeta["x-codex-turn-metadata"].turn_id` as the stable session id.',
-    '- `nodeRepl.requestMeta["x-codex-turn-metadata"].turn_id` is per-turn metadata only, not the stable root session id.',
-    "- If `nodeRepl.requestMeta` is not yet visible and `tool_search` is available, load/discover the `node_repl` MCP tool before concluding metadata is unavailable.",
-    '- When thoth-mem tools are installed and stable root session identity is resolved, 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 metadata tooling is unavailable, or the required fields are missing, 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(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 `collaboration.spawn_agent`; use role-prefixed task names and explicit role instructions for the installed Codex role agents: explorer, librarian, oracle, designer, quick, and deep.",
-    "- Use packaged thoth-agents plugin capabilities through Codex plugin, skill, MCP, and hook review surfaces after enabling them with /plugins and /hooks.",
-    "- For blocking user decisions in Codex Default mode, use request_user_input after features.default_mode_request_user_input is enabled; do not ask those questions in plain prose.",
-    "- Whenever the root orchestrator calls `request_user_input`, it MUST NEVER set or pass `autoResolutionMs`; omit the field entirely.",
-    "- Memory governance, role permissions, provider-per-agent controls, and hooks are instruction-level unless the active Codex runtime documents stronger enforcement.",
-    "</codex-runtime>",
+    codexRuntimeGuidance(),
     CODEX_ROOT_END,
     ""
   ].join("\n");
@@ -1578,15 +1231,19 @@ function renderConfigArtifacts() {
         harness: "codex",
         kind: "mcp-config",
         path: ".codex/config.toml",
-        description: "Codex MCP configuration snippet for thoth-mem.",
+        description: "Codex MCP configuration snippet for unrelated integrations.",
         content: mcp.content
       }
     ],
     diagnostics: [...config.diagnostics, ...mcp.diagnostics]
   };
 }
-function capabilityDiagnostics() {
-  const surfaceDiagnostics = getCodexSurfaceRecords().filter((surface) => surface.status !== "validated").map(codexSurfaceDiagnostic);
+function capabilityDiagnostics({
+  includeHooks
+}) {
+  const surfaceDiagnostics = getCodexSurfaceRecords().filter(
+    (surface) => surface.status !== "validated" && (includeHooks || surface.target !== "hook-config")
+  ).map(codexSurfaceDiagnostic);
   const governanceDiagnostics = memoryGovernanceDiagnostics({
     harness: "codex",
     permissionControls: CODEX_CAPABILITIES.rolePermissions,
@@ -1623,9 +1280,6 @@ function hookReadinessDiagnostics() {
     }
   ];
 }
-function resolveSkillOutputModes(context2) {
-  return context2.options?.codexSkillOutputModes ?? ["plugin-package"];
-}
 var codexAdapter = {
   id: "codex",
   displayName: "Codex",
@@ -1634,14 +1288,6 @@ var codexAdapter = {
     const config = hasCodexConfig(context2) ? context2.config : void 0;
     const agentArtifacts = renderAgentArtifacts({ config });
     const configArtifacts = renderConfigArtifacts();
-    const skillOutputModes = resolveSkillOutputModes(context2);
-    const skillLayout = renderCodexSkillLayout({
-      projectRoot: context2.projectRoot,
-      ...hasCodexPackageRoot(context2) ? { packageRoot: context2.packageRoot } : {},
-      skills: getSkillRegistry(),
-      surfaceId: "plugin-skills-directory",
-      outputModes: skillOutputModes
-    });
     const pluginPackage = renderCodexPluginPackage({
       manifest: createCodexPluginPackageManifest(context2),
       assets: [
@@ -1654,60 +1300,39 @@ var codexAdapter = {
         {
           surfaceId: "plugin-mcp-json",
           manifestField: "mcpServers",
-          path: ".codex-plugin/.mcp.json",
+          path: ".codex-plugin/codex.mcp.json",
           description: "Codex plugin-bundled MCP server definitions.",
           content: stableJson2(createCodexBuiltinMcpJsonConfig())
-        },
-        {
-          surfaceId: "plugin-hooks-json",
-          manifestField: "hooks",
-          path: ".codex-plugin/hooks/hooks.json",
-          description: "Codex plugin-bundled hook configuration.",
-          hookDefinitions: []
         }
       ]
     });
+    const hasPackagedHooks = pluginPackage.artifacts.some(
+      (artifact) => artifact.kind === "hook-config"
+    );
     return {
       harness: "codex",
       artifacts: [
         ...agentArtifacts.artifacts,
         ...configArtifacts.artifacts,
-        ...pluginPackage.artifacts,
-        ...skillLayout.artifacts
+        ...pluginPackage.artifacts
       ],
       diagnostics: [
         ...agentArtifacts.diagnostics,
         ...configArtifacts.diagnostics,
         ...pluginPackage.diagnostics,
-        ...skillLayout.diagnostics,
-        ...hookReadinessDiagnostics(),
-        ...capabilityDiagnostics()
+        ...hasPackagedHooks ? hookReadinessDiagnostics() : [],
+        ...capabilityDiagnostics({ includeHooks: hasPackagedHooks })
       ]
     };
   }
 };
 
-// src/harness/codex-plugin-paths.ts
-import { join as join4 } from "path";
-var CODEX_PLUGIN_ARTIFACT_PREFIX = ".codex-plugin/";
-function codexPluginRootArtifactPath(artifactPath) {
-  if (!artifactPath.startsWith(CODEX_PLUGIN_ARTIFACT_PREFIX)) {
-    throw new Error(`Expected Codex plugin artifact path: ${artifactPath}`);
-  }
-  const relativePath = artifactPath.slice(CODEX_PLUGIN_ARTIFACT_PREFIX.length);
-  if (relativePath === ".mcp.json") return relativePath;
-  if (relativePath === "plugin.json" || relativePath.startsWith(".")) {
-    return join4(".codex-plugin", relativePath);
-  }
-  return relativePath;
-}
-
 // src/cli/codex-config-io.ts
 import {
   copyFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync2,
   renameSync,
   writeFileSync
 } from "fs";
@@ -1801,7 +1426,7 @@ function buildCodexManagedConfigPatch(content, options) {
 }
 function writeCodexConfigMerge(options) {
   try {
-    const before = existsSync3(options.configPath) ? readFileSync3(options.configPath, "utf8") : "";
+    const before = existsSync2(options.configPath) ? readFileSync2(options.configPath, "utf8") : "";
     const merged = buildCodexManagedConfigPatch(before, {
       pluginId: options.pluginId
     });
@@ -1817,7 +1442,7 @@ function writeCodexConfigMerge(options) {
     }
     mkdirSync(dirname2(options.configPath), { recursive: true });
     const backupPath = `${options.configPath}.bak`;
-    if (existsSync3(options.configPath))
+    if (existsSync2(options.configPath))
       copyFileSync(options.configPath, backupPath);
     const tmpPath = `${options.configPath}.tmp`;
     writeFileSync(tmpPath, merged.content);
@@ -1825,7 +1450,7 @@ function writeCodexConfigMerge(options) {
     return {
       success: true,
       configPath: options.configPath,
-      backupPath: existsSync3(backupPath) ? backupPath : void 0,
+      backupPath: existsSync2(backupPath) ? backupPath : void 0,
       changed,
       diffSummary: merged.diffSummary,
       warnings: merged.warnings
@@ -1845,18 +1470,18 @@ function writeCodexConfigMerge(options) {
 // src/cli/managed-state-io.ts
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync4,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync3,
   writeFileSync as writeFileSync2
 } from "fs";
 import { dirname as dirname3 } from "path";
 import { z } from "zod";
-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);
+function writeTextWithBackup(path, content) {
+  mkdirSync2(dirname3(path), { recursive: true });
+  if (existsSync3(path) && readFileSync3(path, "utf8") === content) return false;
+  if (existsSync3(path)) copyFileSync2(path, `${path}.bak`);
+  writeFileSync2(path, content);
   return true;
 }
 function stableJson3(value) {
@@ -1910,9 +1535,30 @@ function parseManagedModelStateJson(text, version) {
     return emptyManagedModelState(version);
   }
 }
-function readManagedModelState(path4, version) {
-  if (!existsSync4(path4)) return emptyManagedModelState(version);
-  return parseManagedModelStateJson(readFileSync4(path4, "utf8"), version);
+function readManagedModelState(path, version) {
+  if (!existsSync3(path)) return emptyManagedModelState(version);
+  return parseManagedModelStateJson(readFileSync3(path, "utf8"), version);
+}
+
+// src/cli/package-root.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname4, join as join2, parse } from "path";
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  const filesystemRoot = parse(startDir).root;
+  while (true) {
+    if (existsSync4(join2(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    if (currentDir === filesystemRoot) {
+      return null;
+    }
+    const parentDir = dirname4(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
 }
 
 // src/cli/codex-install.ts
@@ -1928,43 +1574,15 @@ function mergeManagedBlock(existing, managedBlock) {
   return `${existing}${existing.endsWith("\n") || existing.length === 0 ? "" : "\n"}
 ${managedBlock}`;
 }
-function packageArtifactTarget(packageRoot, artifact) {
-  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(path4) {
-  const normalized = path4.replaceAll("\\", "/");
-  if (isAbsolute(path4) || /^[A-Za-z]:\//.test(normalized)) return normalized;
-  if (normalized.startsWith("./")) return normalized;
-  return `./${normalized}`;
-}
-function marketplaceSourcePath(homeDir, personalPluginRoot) {
-  return normalizeRelativeMarketplacePath(
-    relative2(homeDir, personalPluginRoot)
-  );
-}
-function managedMarketplaceEntry(homeDir, personalPluginRoot) {
-  return {
-    name: "thoth-agents",
-    source: {
-      source: "local",
-      path: marketplaceSourcePath(homeDir, personalPluginRoot)
-    },
-    policy: {
-      installation: "AVAILABLE",
-      authentication: "ON_INSTALL"
-    },
-    category: "Productivity"
-  };
-}
 function emptyManagedModelState2() {
   return emptyManagedModelState(MANAGED_MODEL_STATE_VERSION);
 }
-function readManagedModelState2(path4) {
-  return readManagedModelState(path4, MANAGED_MODEL_STATE_VERSION);
+function readManagedModelState2(path) {
+  return readManagedModelState(path, MANAGED_MODEL_STATE_VERSION);
 }
 function parseRoleTomlModel(content) {
   const match = /^model\s*=\s*"((?:\\.|[^"\\])*)"\s*$/m.exec(content);
@@ -2002,8 +1620,8 @@ function replaceRoleTomlEffort(content, effort) {
   return `${rendered}
 ${content}`;
 }
-function roleManagedModelStateKey(path4) {
-  return basename(path4);
+function roleManagedModelStateKey(path) {
+  return basename(path);
 }
 function normalizeCodexRuntimeModel(model) {
   const separator = model.indexOf("/");
@@ -2054,7 +1672,7 @@ function applyCodexManagedModelOverrides(config, overrides) {
           `Missing Codex role TOML content for ${override.role}.`
         );
       }
-      const before = existsSync5(roleItem.targetPath) ? readFileSync5(roleItem.targetPath, "utf8") : roleItem.content;
+      const before = existsSync5(roleItem.targetPath) ? readFileSync4(roleItem.targetPath, "utf8") : roleItem.content;
       const model = normalizeCodexRuntimeModel(override.model);
       let updated = replaceRoleTomlModel(before, model);
       if (override.clearEffort) {
@@ -2116,7 +1734,7 @@ function resolveRoleTomlContent(options) {
     }
     return options.renderedContent;
   }
-  const installedContent = readFileSync5(options.targetPath, "utf8");
+  const installedContent = readFileSync4(options.targetPath, "utf8");
   const currentModel = parseRoleTomlModel(installedContent);
   const currentEffort = parseRoleTomlEffort(installedContent);
   if (configuredModel !== void 0) {
@@ -2144,25 +1762,11 @@ function resolveRoleTomlContent(options) {
   options.nextState.models[key] = renderedModel;
   return replaceRoleTomlEffort(options.renderedContent, currentEffort);
 }
-function mergePersonalMarketplace(existing, homeDir, personalPluginRoot) {
-  const parsed = existing.trim() ? JSON.parse(existing) : {};
-  const plugins = Array.isArray(parsed.plugins) ? parsed.plugins : [];
-  const managedEntry = managedMarketplaceEntry(homeDir, personalPluginRoot);
-  const nextPlugins = plugins.filter(
-    (entry) => !(entry && typeof entry === "object" && "name" in entry && entry.name === "thoth-agents")
-  ).concat(managedEntry);
-  return stableJson3({
-    ...parsed,
-    name: typeof parsed.name === "string" ? parsed.name : "personal-marketplace",
-    interface: parsed.interface && typeof parsed.interface === "object" ? parsed.interface : { displayName: "Personal Plugin Marketplace" },
-    plugins: nextPlugins
-  });
-}
 function roleArtifactContent(role, artifacts) {
-  const path4 = `.codex/agents/thoth-agents-${role}.toml`;
-  const artifact = artifacts.find((candidate) => candidate.path === path4);
+  const path = `.codex/agents/thoth-agents-${role}.toml`;
+  const artifact = artifacts.find((candidate) => candidate.path === path);
   if (!artifact?.content)
-    throw new Error(`Missing Codex role artifact: ${path4}`);
+    throw new Error(`Missing Codex role artifact: ${path}`);
   return String(artifact.content);
 }
 function buildCodexSetupPlan(config) {
@@ -2177,9 +1781,6 @@ function buildCodexSetupPlan(config) {
     projectRoot: config.projectRoot,
     ...packageRoot ? { packageRoot } : {}
   });
-  const packageArtifacts = render.artifacts.filter(
-    (artifact) => artifact.path.startsWith(".codex-plugin/")
-  );
   const rootBlock = renderCodexRootInstructions();
   const managedModelState2 = readManagedModelState2(targets.managedModelsPath);
   const nextManagedModelState = emptyManagedModelState2();
@@ -2220,24 +1821,6 @@ function buildCodexSetupPlan(config) {
       requiresBackup: existsSync5(targets.managedModelsPath),
       content: stableJson3(nextManagedModelState)
     },
-    ...packageArtifacts.map(
-      (artifact) => ({
-        kind: "personal-plugin-source",
-        action: "refresh-package",
-        targetPath: packageArtifactTarget(targets.personalPluginRoot, artifact),
-        description: `Refresh Personal Codex plugin source asset ${artifact.path}.`,
-        requiresBackup: false,
-        content: String(artifact.content ?? "")
-      })
-    ),
-    {
-      kind: "personal-marketplace",
-      action: "merge-marketplace",
-      targetPath: targets.personalMarketplacePath,
-      description: "Register Personal Codex marketplace entry for the local thoth-agents plugin source.",
-      requiresBackup: existsSync5(targets.personalMarketplacePath),
-      content: targets.personalPluginRoot
-    },
     {
       kind: "user-config",
       action: "merge-toml",
@@ -2249,7 +1832,7 @@ function buildCodexSetupPlan(config) {
       kind: "diagnostic",
       action: "diagnose-only",
       targetPath: targets.codexHome,
-      description: "Report /plugins, /hooks, precedence, and capability review steps.",
+      description: "Report /plugins, precedence, and consumer capability review steps.",
       requiresBackup: false
     }
   ];
@@ -2260,58 +1843,25 @@ function buildCodexSetupPlan(config) {
     configPath: targets.configPath,
     pluginId: config.pluginId,
     diagnostics: [
-      "Restart Codex, then run /plugins to review and enable the Personal thoth-agents plugin registered through ~/.agents/plugins/marketplace.json.",
-      "Run /hooks to review and trust plugin hooks; features.plugin_hooks does not bypass hook trust review.",
+      "Register the published marketplace with `codex plugin marketplace add EremesNG/thoth-agents`, restart Codex, then open /plugins to install and enable thoth-agents.",
+      "The CLI does not copy a plugin into ~/.codex/plugins or merge ~/.agents/plugins/marketplace.json; Codex owns marketplace snapshots and installed plugin cache state.",
+      "The /hooks surface may show hooks from independently installed plugins; this thoth-agents setup plan does not install provider hooks.",
       "Codex Default mode user-input requests require features.default_mode_request_user_input = true and use the request_user_input tool; other modes may not expose it.",
-      "Higher-precedence Codex config (project, profile, CLI, system, or admin) may override user config feature flags."
+      "Higher-precedence Codex config (project, profile, CLI, system, or admin) may override user config feature flags.",
+      "Provider capability is owned by the external provider and is not established by this thoth-agents setup plan."
     ],
     disclaimers: [
-      "Role permissions, provider-per-agent settings, memory governance, and hook enforcement are instruction-level or user-managed unless documented Codex runtime controls are available.",
-      "Codex v1 reset is managed-only; no broad destructive --force behavior is implemented."
+      "Role permissions and provider-per-agent settings are instruction-level or user-managed unless documented Codex runtime controls are available.",
+      "Codex reset is managed-only; no broad destructive --force behavior is implemented."
     ]
   };
 }
 function formatCodexSetupPlan(plan) {
-  const refreshPackageGroups = /* @__PURE__ */ new Map();
-  for (const item of plan.items) {
-    if (item.action !== "refresh-package") continue;
-    const group = refreshPackageGroups.get(item.kind) ?? [];
-    group.push(item);
-    refreshPackageGroups.set(item.kind, group);
-  }
-  const renderedRefreshKinds = /* @__PURE__ */ new Set();
-  const lines = [];
-  for (const item of plan.items) {
-    if (item.action !== "refresh-package") {
-      lines.push(`- ${item.action}: ${item.targetPath} (${item.description})`);
-      continue;
-    }
-    if (renderedRefreshKinds.has(item.kind)) continue;
-    renderedRefreshKinds.add(item.kind);
-    lines.push(formatRefreshPackageGroup(item.kind, refreshPackageGroups));
-  }
+  const lines = plan.items.map(
+    (item) => `- ${item.action}: ${item.targetPath} (${item.description})`
+  );
   return ["Codex setup plan:", ...lines].join("\n");
 }
-function formatRefreshPackageGroup(kind, groups) {
-  const items = groups.get(kind) ?? [];
-  const description = kind === "personal-plugin-source" ? "Refresh Personal Codex plugin source" : "Refresh documented .codex-plugin package";
-  return `- refresh-package: ${commonTargetDirectory(items)} (${description}, ${items.length} files.)`;
-}
-function commonTargetDirectory(items) {
-  if (items.length === 0) return "";
-  let common = dirname4(items[0]?.targetPath ?? "");
-  for (const item of items.slice(1)) {
-    while (!isSameOrChildPath(item.targetPath, common)) {
-      const parent = dirname4(common);
-      if (parent === common) return common;
-      common = parent;
-    }
-  }
-  return common;
-}
-function isSameOrChildPath(path4, parent) {
-  return path4 === parent || path4.startsWith(`${parent}\\`) || path4.startsWith(`${parent}/`);
-}
 function applyCodexSetup(plan) {
   const changed = [];
   const diagnostics = uniqueMessages([
@@ -2320,9 +1870,6 @@ function applyCodexSetup(plan) {
   ]);
   if (plan.dryRun) return { success: true, changed, diagnostics };
   try {
-    for (const targetPath of managedRefreshRoots(plan)) {
-      rmSync(targetPath, { recursive: true, force: true });
-    }
     for (const item of plan.items) {
       if (item.action === "diagnose-only") continue;
       if (item.action === "merge-toml") {
@@ -2336,20 +1883,9 @@ function applyCodexSetup(plan) {
         if (result.changed) changed.push(item.targetPath);
         continue;
       }
-      if (item.action === "merge-marketplace") {
-        if (item.content === void 0) continue;
-        const content2 = mergePersonalMarketplace(
-          existsSync5(item.targetPath) ? readFileSync5(item.targetPath, "utf8") : "",
-          dirname4(dirname4(dirname4(item.targetPath))),
-          item.content
-        );
-        if (writeTextWithBackup(item.targetPath, content2))
-          changed.push(item.targetPath);
-        continue;
-      }
       if (item.content === void 0) continue;
       const content = item.action === "merge-managed-block" ? mergeManagedBlock(
-        existsSync5(item.targetPath) ? readFileSync5(item.targetPath, "utf8") : "",
+        existsSync5(item.targetPath) ? readFileSync4(item.targetPath, "utf8") : "",
         item.content
       ) : item.content;
       if (writeTextWithBackup(item.targetPath, content))
@@ -2365,25 +1901,15 @@ function applyCodexSetup(plan) {
     };
   }
 }
-function managedRefreshRoots(plan) {
-  const refreshGroups = /* @__PURE__ */ new Map();
-  for (const item of plan.items) {
-    if (item.action !== "refresh-package") continue;
-    const group = refreshGroups.get(item.kind) ?? [];
-    group.push(item);
-    refreshGroups.set(item.kind, group);
-  }
-  return [...refreshGroups].filter(([kind]) => kind === "personal-plugin-source").map(([, items]) => commonTargetDirectory(items)).filter((path4) => path4.length > 0);
-}
 
 // src/cli/operations/claude-code.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "fs";
-import { basename as basename2 } from "path";
+import { existsSync as existsSync7 } from "fs";
 
 // src/harness/adapters/claude-code.ts
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/harness/writers/claude-code-plugin-package.ts
+import { createHash as createHash2 } from "crypto";
 var CLAUDE_PLUGIN_MANIFEST_FIELDS = [
   "name",
   "version",
@@ -2399,6 +1925,21 @@ function stableJson4(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
+function sha256Hash(content) {
+  return `sha256:${createHash2("sha256").update(content).digest("hex")}`;
+}
+function withoutProviderAsset(artifact) {
+  if (!normalizePath2(artifact.path).endsWith(".mcp.json")) return artifact;
+  const content = typeof artifact.content === "string" ? artifact.content : Buffer.from(artifact.content).toString("utf8");
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.mcpServers) return artifact;
+    const { thoth_mem: _provider, ...mcpServers } = parsed.mcpServers;
+    return { ...artifact, content: stableJson4({ ...parsed, mcpServers }) };
+  } catch {
+    return artifact;
+  }
+}
 function orderedManifest(manifest) {
   const ordered = {};
   for (const field of CLAUDE_PLUGIN_MANIFEST_FIELDS) {
@@ -2408,13 +1949,13 @@ function orderedManifest(manifest) {
   return ordered;
 }
 function provenanceFor(artifact) {
-  const path4 = normalizePath2(artifact.path);
-  if (path4.endsWith("/")) return void 0;
+  const path = normalizePath2(artifact.path);
+  if (path.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) };
+  return { path, kind: artifact.kind, sha256: sha256Hash(content) };
 }
 function renderClaudeCodePluginPackage(input) {
-  const components = [...input.componentArtifacts].sort(
+  const components = input.componentArtifacts.map(withoutProviderAsset).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));
@@ -2438,65 +1979,6 @@ function renderClaudeCodePluginPackage(input) {
   };
 }
 
-// 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",
@@ -2521,6 +2003,7 @@ function renderClaudeCodeSubagent(input) {
     `model: ${input.model}`,
     ...input.effort !== void 0 ? [`effort: ${input.effort}`] : [],
     ...input.tools !== void 0 ? [`tools: ${yamlScalar(input.tools)}`] : [],
+    ...input.disallowedTools !== void 0 ? [`disallowedTools: ${yamlScalar(input.disallowedTools)}`] : [],
     "---"
   ].join("\n");
   const body = input.instructions.trimEnd();
@@ -2549,48 +2032,6 @@ function getClaudeCodeAgentModel(role, config) {
   if (override && isClaudeCodeModel(override)) return override;
   return CLAUDE_CODE_SUBAGENT_DEFAULT_MODELS[role.name];
 }
-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>",
@@ -2599,8 +2040,10 @@ function claudeCodeRoleInstructions(role) {
     `- 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.`,
-    "- This subagent inherits ALL of the main thread's tools, including MCP servers (thoth-mem, context7, exa, grep_app); read-only roles (explorer, librarian, oracle) MUST NOT mutate the workspace per this operational contract (instruction-level, not tooling-enforced).",
+    `- ${role.name} runs as an auto-discovered Claude Code plugin subagent invoked via Agent(subagent_type: ${claudeCodeSubagentType(role.name)}); plugin subagents are namespaced with the plugin name. The orchestrator is the main Claude Code session.`,
+    ...role.mode === "read-only" ? [
+      "- Write and Edit are denied in frontmatter while all other inherited tools, including MCP tools, remain available."
+    ] : [],
     ...role.toolGovernance.map((rule) => `- ${rule}`),
     ...role.verification.map((rule) => `- ${rule}`),
     "</role-operational-contract>"
@@ -2609,38 +2052,39 @@ function claudeCodeRoleInstructions(role) {
 function roleInstructions2(role, config) {
   const model = getClaudeCodeAgentModel(role, config);
   return [
-    renderClaudeCodeRolePrompt(role.name, config, model),
+    renderConfiguredRolePrompt({
+      role: role.name,
+      dialect: CLAUDE_CODE_PROMPT_DIALECT,
+      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",
+  const rootPrompt = renderConfiguredRolePrompt({
+    role: "orchestrator",
+    dialect: CLAUDE_CODE_PROMPT_DIALECT,
     config,
-    rootOverride?.model ?? DEFAULT_MODELS.orchestrator
-  );
+    model: 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.",
-    "- Subagents inherit all of your tools (including MCP servers); role permissions are instruction-level, so read-only roles (explorer, librarian, oracle) must not mutate the workspace per their operational contract.",
+    "- You are the Claude Code adaptive root activated by plugin settings.json.",
+    `- Delegate only for net gain through Agent with \`subagent_type\` set to one of these plugin-namespaced specialists: ${specialists}. Always keep the ${CLAUDE_CODE_SUBAGENT_NAMESPACE}: prefix.`,
+    "- Subagents cannot delegate further. Parallelize only independent work and maintain one writer per mutable surface.",
+    "- Read-only roles deny Write and Edit while retaining other inherited tools, including MCP tools. Coordination-agent path scope remains instruction-level.",
+    "- Use AskUserQuestion only for blocking material choices and TodoWrite only for genuine multi-step progress.",
+    "- Installed provider guidance owns memory, persistence, hooks, MCP lifecycle, and recovery mechanics.",
     "</claude-code-runtime>"
   ].join("\n");
 }
 function claudeCodeMcpServers() {
   const [exaCommand = "", ...exaArgs] = exa.command;
-  const [thothCommand = "", ...thothArgs] = DEFAULT_THOTH_COMMAND;
   return {
     exa: {
       command: exaCommand,
@@ -2648,11 +2092,7 @@ function claudeCodeMcpServers() {
       ...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 } : {}
-    }
+    grep_app: { type: "http", url: GREP_APP_MCP_URL }
   };
 }
 function stableJson5(value) {
@@ -2678,7 +2118,7 @@ function createPluginManifest(context2) {
   return {
     name: "thoth-agents",
     version: readRootPackageVersion2(context2),
-    description: "Delegate-first agent pack with seven roles, thoth-mem persistence, and bundled SDD skills, packaged for Claude Code.",
+    description: "Adaptive multi-harness agent pack with seven roles and a runtime-autonomous Spec Kit-compatible SDD bundle for Claude Code.",
     author: { name: "thoth-agents" }
   };
 }
@@ -2691,6 +2131,7 @@ function renderSubagentArtifacts(config) {
       name: role.name,
       description: role.responsibility,
       model: getClaudeCodeAgentModel(role, config),
+      ...role.mode === "read-only" ? { disallowedTools: "Write, Edit" } : {},
       instructions: roleInstructions2(role, config)
     });
     artifacts.push({
@@ -2709,7 +2150,7 @@ function renderOrchestratorArtifact(config) {
   );
   const content = renderClaudeCodeSubagent({
     name: "orchestrator",
-    description: orchestrator?.responsibility ?? "Delegate-first root coordinator for SDD workflow and specialist dispatch.",
+    description: orchestrator?.responsibility ?? "Adaptive root coordinator for direct work, SDD routing, and specialist dispatch.",
     model: "inherit",
     instructions: renderClaudeCodeRootInstructions(config)
   });
@@ -2745,12 +2186,6 @@ var claudeCodeAdapter = {
         content: stableJson5({ agent: "orchestrator" })
       }
     ];
-    const skillLayout = renderClaudeCodeSkillLayout({
-      projectRoot: context2.projectRoot,
-      ...hasPackageRoot(context2) ? { packageRoot: context2.packageRoot } : {},
-      skills: getSkillRegistry()
-    });
-    componentArtifacts.push(...skillLayout.artifacts);
     const pluginPackage = renderClaudeCodePluginPackage({
       manifest: createPluginManifest(context2),
       componentArtifacts
@@ -2758,19 +2193,15 @@ var claudeCodeAdapter = {
     return {
       harness: "claude",
       artifacts: pluginPackage.artifacts,
-      diagnostics: [...skillLayout.diagnostics, ...pluginPackage.diagnostics]
+      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";
+import { spawnSync } from "child_process";
 
 // 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",
@@ -2779,320 +2210,386 @@ var CLAUDE_CODE_ROLE_NAMES = [
   "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");
+
+// src/cli/claude-code-install.ts
+var MARKETPLACE_NAME = "thoth-agents";
+var MARKETPLACE_SOURCE = "EremesNG/thoth-agents";
+var PLUGIN_ID = "thoth-agents@thoth-agents";
+var MARKETPLACE_TARGET = "claude://marketplaces/thoth-agents";
+var PLUGIN_TARGET = "claude://plugins/thoth-agents@thoth-agents";
+function defaultCommandExecutor(command, args, options) {
+  const result = spawnSync(command, [...args], {
+    cwd: options.cwd,
+    encoding: "utf8",
+    shell: false,
+    windowsHide: true
+  });
   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")
+    exitCode: result.status ?? (result.error ? 1 : 0),
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? result.error?.message ?? ""
   };
 }
-
-// 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 isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function replaceSubagentModel(content, model) {
-  if (/^model:\s*\S+\s*$/m.test(content)) {
-    return content.replace(/^model:\s*\S+\s*$/m, `model: ${model}`);
+function parseJsonRecords(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed) && parsed.every(isRecord3)) return parsed;
+    if (isRecord3(parsed)) return [parsed];
+    return null;
+  } catch {
+    return null;
   }
-  return content;
 }
-function parseSubagentEffort(content) {
-  return /^effort:\s*(\S+)\s*$/m.exec(content)?.[1];
-}
-function replaceSubagentEffort(content, effort) {
-  if (effort === void 0) {
-    return content.replace(/^effort:\s*\S+\s*\n/m, "");
+function isCanonicalMarketplace(entry) {
+  if (entry.name !== MARKETPLACE_NAME) return false;
+  if (entry.repo === MARKETPLACE_SOURCE || entry.source === MARKETPLACE_SOURCE) {
+    return true;
   }
-  if (/^effort:\s*\S+\s*$/m.test(content)) {
-    return content.replace(/^effort:\s*\S+\s*$/m, `effort: ${effort}`);
-  }
-  return content.replace(/^(model:\s*\S+\s*)$/m, `$1
-effort: ${effort}`);
-}
-function emptyManagedModelState3() {
-  return emptyManagedModelState(CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION);
+  const source = entry.source;
+  return isRecord3(source) && (source.repo === MARKETPLACE_SOURCE || source.source === MARKETPLACE_SOURCE);
 }
-function parseManagedModelStateJson2(text) {
-  return parseManagedModelStateJson(
-    text,
-    CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION
+function inspectClaudeManager(executor, cwd, scope) {
+  const marketplaceResult = executor(
+    "claude",
+    ["plugin", "marketplace", "list", "--json"],
+    { cwd }
   );
-}
-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 pluginResult = executor("claude", ["plugin", "list", "--json"], {
+    cwd
+  });
+  const diagnostics = [];
+  if (marketplaceResult.exitCode !== 0 || pluginResult.exitCode !== 0) {
+    diagnostics.push(
+      "Claude Code native plugin state could not be inspected; no manager mutation will be attempted."
+    );
+    return {
+      ready: false,
+      marketplace: "unknown",
+      plugin: "unknown",
+      diagnostics
+    };
+  }
+  const marketplaces = parseJsonRecords(marketplaceResult.stdout);
+  const plugins = parseJsonRecords(pluginResult.stdout);
+  if (!marketplaces || !plugins) {
+    diagnostics.push(
+      "Claude Code returned unparseable plugin manager JSON; no manager mutation will be attempted."
+    );
+    return {
+      ready: false,
+      marketplace: "unknown",
+      plugin: "unknown",
+      diagnostics
+    };
+  }
+  const namedMarketplaces = marketplaces.filter(
+    (entry) => entry.name === MARKETPLACE_NAME
   );
-  const name = match?.[1];
-  return name && CLAUDE_CODE_ROLE_NAMES.includes(name) ? name : void 0;
-}
-function applyConfiguredModel(content, targetPath, 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];
-  let updated = content;
-  if (configured !== void 0) {
-    nextState.configuredModels ??= {};
-    nextState.configuredModels[role] = configured;
-    updated = replaceSubagentModel(updated, configured);
-  }
-  const configuredEffort = reset ? void 0 : state.configuredEfforts?.[role];
-  if (configuredEffort !== void 0) {
-    nextState.configuredEfforts ??= {};
-    nextState.configuredEfforts[role] = configuredEffort;
+  let marketplace = "absent";
+  if (namedMarketplaces.length > 0) {
+    marketplace = namedMarketplaces.every(isCanonicalMarketplace) ? "installed" : "conflict";
   }
-  if (!reset && existsSync6(targetPath)) {
-    const installedEffort = parseSubagentEffort(
-      readFileSync7(targetPath, "utf8")
+  if (marketplace === "conflict") {
+    diagnostics.push(
+      "A Claude marketplace named thoth-agents is registered from a different source; resolve it through Claude Code before retrying."
     );
-    updated = replaceSubagentEffort(updated, installedEffort);
   }
-  return updated;
+  const matchingPlugins = plugins.filter(
+    (entry) => entry.id === PLUGIN_ID && entry.scope === scope
+  );
+  let plugin = "absent";
+  if (matchingPlugins.some((entry) => entry.enabled === true)) {
+    plugin = "installed";
+  } else if (matchingPlugins.length > 0) {
+    plugin = "disabled";
+  }
+  return {
+    ready: marketplace !== "conflict",
+    marketplace,
+    plugin,
+    diagnostics
+  };
 }
-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 targetPath = join8(targets.pluginRoot, artifact.path);
-    const content = role !== void 0 ? applyConfiguredModel(
-      rendered,
-      targetPath,
-      role,
-      state,
-      nextState,
-      config.reset
-    ) : rendered;
+function commandItem(action, scope, projectRoot) {
+  if (action === "register-marketplace") {
     return {
-      kind: targetKindForArtifact(artifact),
-      action: "write-plugin-file",
-      targetPath,
-      description: `Materialize Claude Code plugin asset ${artifact.path}.`,
-      requiresBackup: existsSync6(targetPath),
-      content,
-      ...role ? { role } : {}
+      kind: "native-marketplace",
+      action,
+      targetPath: MARKETPLACE_TARGET,
+      description: "Register the package-owned thoth-agents Claude marketplace.",
+      requiresBackup: false,
+      command: {
+        executable: "claude",
+        args: [
+          "plugin",
+          "marketplace",
+          "add",
+          MARKETPLACE_SOURCE,
+          "--scope",
+          scope
+        ],
+        cwd: projectRoot
+      }
     };
-  });
-  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)
-  });
+  }
+  let command = "install";
+  let description = "Install the thoth-agents Claude plugin from its native marketplace.";
+  if (action === "enable-plugin") {
+    command = "enable";
+    description = "Enable the manager-owned thoth-agents Claude plugin.";
+  } else if (action === "update-plugin") {
+    command = "update";
+    description = "Update the manager-owned thoth-agents Claude plugin.";
+  }
+  return {
+    kind: "native-plugin",
+    action,
+    targetPath: PLUGIN_TARGET,
+    description,
+    requiresBackup: false,
+    command: {
+      executable: "claude",
+      args: ["plugin", command, PLUGIN_ID, "--scope", scope],
+      cwd: projectRoot
+    }
+  };
+}
+function buildClaudeCodeSetupPlan(config) {
+  const commandExecutor = config.commandExecutor ?? defaultCommandExecutor;
+  const inspection = inspectClaudeManager(
+    commandExecutor,
+    config.projectRoot,
+    config.scope
+  );
+  const items = [];
+  if (inspection.ready) {
+    if (inspection.marketplace === "absent") {
+      items.push(
+        commandItem("register-marketplace", config.scope, config.projectRoot)
+      );
+    }
+    if (inspection.plugin === "absent") {
+      items.push(
+        commandItem("install-plugin", config.scope, config.projectRoot)
+      );
+    } else if (inspection.plugin === "disabled") {
+      items.push(
+        commandItem("enable-plugin", config.scope, config.projectRoot)
+      );
+      if (config.refresh === true || config.reset) {
+        items.push(
+          commandItem("update-plugin", config.scope, config.projectRoot)
+        );
+      }
+    } else if (config.refresh === true || config.reset) {
+      items.push(
+        commandItem("update-plugin", config.scope, config.projectRoot)
+      );
+    }
+  }
   return {
     dryRun: config.dryRun === true,
     reset: config.reset,
     items,
-    pluginRoot: targets.pluginRoot,
+    pluginRoot: PLUGIN_TARGET,
+    ready: inspection.ready,
+    scope: config.scope,
+    projectRoot: config.projectRoot,
+    commandExecutor,
     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."
+      ...inspection.diagnostics,
+      "Claude Code installs thoth-agents from EremesNG/thoth-agents through its native marketplace and owns the cached plugin files.",
+      "Restart Claude Code or run /reload-plugins after installation; use /plugin to inspect marketplace and plugin state.",
+      "Provider capability is owned by the external provider and is not established by this thoth-agents setup plan."
     ],
     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.",
-      "Every subagent inherits all main-thread tools, including MCP servers; read-only roles must not mutate the workspace per their operational contract (instruction-level, not tooling-enforced).",
-      "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."
+      "The native plugin activates its orchestrator agent as the main thread through plugin-root settings.json.",
+      "Read-only subagents remain instruction/tool-denylist constrained; capability parity with other harnesses is not implied.",
+      "Per-role Claude model rewrites are unavailable because native marketplace cache contents are manager-owned and immutable to thoth-agents."
     ]
   };
 }
+function uniqueMessages2(messages) {
+  return [...new Set(messages)];
+}
+function boundedCommandFailure(item, result) {
+  const detail = result.stderr.trim().replace(/\s+/g, " ").slice(0, 240);
+  return `${item.description} Claude exited with code ${result.exitCode}${detail ? `: ${detail}` : "."}`;
+}
 function applyClaudeCodeSetup(plan) {
   const changed = [];
-  const diagnostics = uniqueMessages([
+  const diagnostics = uniqueMessages2([
     ...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) {
+  if (!plan.ready) {
     return {
       success: false,
       changed,
       diagnostics,
-      error: error instanceof Error ? error.message : String(error)
+      error: "Claude Code native plugin manager state is not safe to mutate."
     };
   }
-}
-function applyClaudeCodeManagedModelOverrides(config, overrides) {
-  if (config.dryRun) {
-    return {
-      success: true,
-      changed: [],
-      diagnostics: [
-        "Dry-run Claude Code model override apply requested; no files were written."
-      ]
-    };
+  if (plan.dryRun) return { success: true, changed, diagnostics };
+  for (const item of plan.items) {
+    const result = plan.commandExecutor(
+      item.command.executable,
+      item.command.args,
+      { cwd: item.command.cwd }
+    );
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        changed,
+        diagnostics,
+        error: boundedCommandFailure(item, result)
+      };
+    }
+    changed.push(item.targetPath);
   }
-  const plan = buildClaudeCodeSetupPlan({
-    ...config,
-    dryRun: true,
-    reset: false
-  });
-  const stateItem = plan.items.find(
-    (item) => item.action === "write-managed-model-state"
+  const inspection = inspectClaudeManager(
+    plan.commandExecutor,
+    plan.projectRoot,
+    plan.scope
   );
-  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 } } : {},
-    ...state.configuredEfforts ? { configuredEfforts: { ...state.configuredEfforts } } : {}
-  };
-  try {
-    for (const override of overrides) {
-      if (!isClaudeCodeModelAlias(override.model) && override.catalogId !== 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;
-      let updated = replaceSubagentModel(before, override.model);
-      if (override.clearEffort) {
-        updated = replaceSubagentEffort(updated, void 0);
-      } else if (override.effort !== void 0) {
-        updated = replaceSubagentEffort(updated, override.effort);
-      }
-      if (writeTextWithBackup(roleItem.targetPath, updated)) {
-        changed.push(roleItem.targetPath);
-      }
-      nextState.configuredModels ??= {};
-      nextState.configuredModels[override.role] = override.model;
-      if (override.clearEffort) {
-        if (nextState.configuredEfforts) {
-          delete nextState.configuredEfforts[override.role];
-        }
-      } else if (override.effort !== void 0) {
-        nextState.configuredEfforts ??= {};
-        nextState.configuredEfforts[override.role] = override.effort;
-      }
-    }
-    if (writeTextWithBackup(statePath, stableJson3(nextState))) {
-      changed.push(statePath);
-    }
-    return { success: true, changed, diagnostics };
-  } catch (error) {
+  diagnostics.push(...inspection.diagnostics);
+  if (inspection.marketplace !== "installed" || inspection.plugin !== "installed") {
     return {
       success: false,
       changed,
-      diagnostics,
-      error: error instanceof Error ? error.message : String(error)
+      diagnostics: uniqueMessages2(diagnostics),
+      error: "Claude Code did not verify the expected marketplace and enabled plugin after mutation."
     };
   }
+  return { success: true, changed, diagnostics: uniqueMessages2(diagnostics) };
 }
 function formatClaudeCodeSetupPlan(plan) {
   const lines = plan.items.map(
-    (item) => `- ${item.action}: ${item.targetPath} (${item.description})`
+    (item) => `- ${item.action}: ${item.command.executable} ${item.command.args.join(" ")}`
   );
   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 CLAUDE_CODE_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
-function resolveClaudeCodeEffort(input) {
-  if (!input.effort || input.effort.kind === "inherit") {
-    return { ok: true, effort: void 0 };
+// src/cli/skills.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var SKILLS_CLI_AGENT = {
+  opencode: "opencode",
+  codex: "codex",
+  claude: "claude-code"
+};
+var GLOBAL_SKILL_ROOT = {
+  opencode: [".config", "opencode", "skills"],
+  codex: [".codex", "skills"],
+  claude: [".claude", "skills"]
+};
+var REQUIRED_SKILLS = [
+  {
+    name: "simplify",
+    repo: "https://github.com/EremesNG/skills",
+    skillName: "simplify",
+    description: "YAGNI code simplification expert"
+  },
+  {
+    name: "tdd",
+    repo: "https://github.com/mattpocock/skills",
+    skillName: "tdd",
+    description: "Test-driven development workflow"
+  },
+  {
+    name: "progressive-context-router",
+    repo: "https://github.com/EremesNG/skills",
+    skillName: "progressive-context-router",
+    description: "Repository instruction and on-demand context routing"
+  },
+  {
+    name: "architectural-grilling",
+    repo: "https://github.com/EremesNG/skills",
+    skillName: "architectural-grilling",
+    description: "Conditional product and architecture decision interview"
   }
-  const effort = input.effort.value;
-  if (!CLAUDE_CODE_EFFORTS.has(effort)) {
-    return {
-      ok: false,
-      code: "claude-code-effort-runtime-unsupported",
-      message: `Claude Code does not support effort ${effort}.`
-    };
+];
+function getRequiredSkillPath(skill, harness, homeDir = homedir2()) {
+  return join3(
+    homeDir,
+    ...GLOBAL_SKILL_ROOT[harness],
+    skill.skillName,
+    "SKILL.md"
+  );
+}
+function isRequiredSkillInstalled(skill, harness, options = {}) {
+  return existsSync6(getRequiredSkillPath(skill, harness, options.homeDir));
+}
+function getRequiredSkillInstallCommand(skill, harness) {
+  return {
+    command: "npx",
+    args: [
+      "skills",
+      "add",
+      skill.repo,
+      "--skill",
+      skill.skillName,
+      "--global",
+      "--agent",
+      SKILLS_CLI_AGENT[harness],
+      "--yes"
+    ]
+  };
+}
+function installRequiredSkill(skill, harness, options = {}) {
+  const skillPath = getRequiredSkillPath(skill, harness, options.homeDir);
+  if (isRequiredSkillInstalled(skill, harness, options)) {
+    return { skill, harness, status: "already-installed", skillPath };
+  }
+  const { command, args } = getRequiredSkillInstallCommand(skill, harness);
+  try {
+    const result = spawnSync2(command, args, { stdio: "inherit" });
+    if (result.status === 0) {
+      return { skill, harness, status: "installed", skillPath };
+    }
+    if (isRequiredSkillInstalled(skill, harness, options)) {
+      return { skill, harness, status: "already-installed", skillPath };
+    }
+    return { skill, harness, status: "failed", skillPath, error: result.error };
+  } catch (error) {
+    return { skill, harness, status: "failed", skillPath, error };
   }
-  if (isClaudeCodeModelAlias(input.model) && input.model !== "inherit") {
-    return { ok: true, effort };
+}
+
+// src/cli/operations/types.ts
+var UNSUPPORTED_PROVIDER_CAPABILITY = {
+  state: "unsupported",
+  source: "none",
+  basis: []
+};
+function classifyProviderCapabilityEvidence(input = {}) {
+  const evidence = input.providerEvidence;
+  if (!evidence) {
+    return { ...UNSUPPORTED_PROVIDER_CAPABILITY, basis: [] };
   }
-  if (input.catalogId === input.model && input.availableEfforts?.includes(effort)) {
-    return { ok: true, effort };
+  const basis = evidence.basis.filter((item) => item.trim().length > 0);
+  const hasDocumentedSource = evidence.source === "provider" || evidence.source === "harness";
+  if (!hasDocumentedSource || basis.length === 0) {
+    return { ...UNSUPPORTED_PROVIDER_CAPABILITY, basis: [] };
   }
-  return {
-    ok: false,
-    code: "claude-code-effort-catalog-unsupported",
-    message: `Effort ${effort} is not supported by ${input.catalogId ?? input.model} in the models.dev catalog.`
-  };
+  return { ...evidence, basis };
 }
+
+// src/cli/operations/claude-code.ts
+var CLAUDE_CODE_DISPLAY_NAME = "Claude Code";
+var claudeCodePlanSources = /* @__PURE__ */ new WeakMap();
+var MODEL_CONFIG_DISABLED_REASON = "Native Claude marketplace cache files are manager-owned; configure packaged agent defaults in the repository and publish a new plugin version.";
 var claudeCodeActions = [
   {
     id: "claude-code-status",
     kind: "status",
     label: "Status",
-    description: "Inspect managed Claude Code plugin state",
+    description: "Inspect native Claude Code marketplace and plugin state",
     dryRun: false,
     requiresConfirmation: false,
     supported: true
@@ -3110,7 +2607,7 @@ var claudeCodeActions = [
     id: "claude-code-install",
     kind: "install",
     label: "Install",
-    description: "Preview Claude Code plugin package install",
+    description: "Preview native Claude marketplace registration and install",
     dryRun: true,
     requiresConfirmation: true,
     supported: true
@@ -3119,7 +2616,7 @@ var claudeCodeActions = [
     id: "claude-code-update",
     kind: "update",
     label: "Update",
-    description: "Preview Claude Code managed plugin refresh",
+    description: "Preview native Claude plugin reconciliation",
     dryRun: true,
     requiresConfirmation: true,
     supported: true
@@ -3128,7 +2625,7 @@ var claudeCodeActions = [
     id: "claude-code-sync",
     kind: "sync",
     label: "Sync",
-    description: "Preview Claude Code managed plugin sync",
+    description: "Preview native Claude plugin and required-skill reconciliation",
     dryRun: true,
     requiresConfirmation: true,
     supported: true
@@ -3137,40 +2634,39 @@ var claudeCodeActions = [
     id: "claude-code-model-config",
     kind: "model-config",
     label: "Model",
-    description: "Preview supported Claude Code subagent model line changes",
+    description: "Claude agent models are package-owned defaults",
     dryRun: true,
-    requiresConfirmation: true,
-    supported: true
+    requiresConfirmation: false,
+    supported: false,
+    disabledReason: MODEL_CONFIG_DISABLED_REASON
   }
 ];
 var claudeCodeOperationAdapter = {
   id: "claude",
   displayName: CLAUDE_CODE_DISPLAY_NAME,
   available: true,
-  description: "Claude Code plugin package and managed subagent surfaces.",
+  description: "Native Claude Code marketplace plugin and required skills.",
   actions: claudeCodeActions
 };
-function claudeCodeConfig(context2 = { cwd: process.cwd() }, dryRun) {
+function claudeCodeConfig(context2 = { cwd: process.cwd() }, dryRun, refresh = false) {
   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: context2.scope ?? "user",
     projectRoot: context2.cwd,
-    homeDir: context2.homeDir,
-    packageRoot: context2.packageRoot
+    commandExecutor: context2.commandExecutor,
+    refresh
   };
 }
 function claudeCodeDisclaimers() {
   return [
     {
-      message: "Subagents inherit all main-thread tools (including MCP servers); read-only roles must not mutate the workspace per their operational contract (instruction-level, not tooling-enforced). The orchestrator is the main session.",
-      code: "claude-code-first-class"
+      message: "Claude Code owns marketplace snapshots and installed plugin cache files; thoth-agents never edits that cache directly.",
+      code: "claude-code-manager-owned-cache"
     },
     {
-      message: "Subagent models accept only sonnet, opus, haiku, or inherit.",
-      code: "claude-code-model-aliases"
+      message: "Read-only roles remain instruction/tool-denylist constrained; the orchestrator is activated as the main plugin agent.",
+      code: "claude-code-first-class"
     }
   ];
 }
@@ -3179,9 +2675,9 @@ function warning(message, code) {
 }
 function targetForItem(item, state, observed) {
   return {
-    kind: item.kind === "managed-model-state" ? "memory-state" : "generated-artifact",
+    kind: "package",
     path: item.targetPath,
-    label: item.role ? `Claude Code ${item.role} subagent` : item.kind.replaceAll("-", " "),
+    label: item.kind === "native-marketplace" ? "Claude Code marketplace" : "Claude Code plugin",
     state,
     expected: item.action,
     observed,
@@ -3190,47 +2686,45 @@ function targetForItem(item, state, observed) {
 }
 function surfaceForItem(item) {
   return {
-    id: `${item.kind}:${item.role ?? basename2(item.targetPath)}`,
-    label: item.role ? `Claude Code ${item.role} subagent` : item.kind.replaceAll("-", " "),
+    id: `${item.kind}:${item.action}`,
+    label: item.kind === "native-marketplace" ? "Claude Code marketplace" : "Claude Code plugin",
     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" };
+function managerTargets(plan) {
+  if (!plan.ready) {
+    return [
+      {
+        kind: "package",
+        path: plan.pluginRoot,
+        label: "Claude Code native plugin",
+        state: "unknown",
+        observed: "native manager state is unsafe to mutate"
+      }
+    ];
   }
-  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);
+  if (plan.items.length === 0) {
+    return [
+      {
+        kind: "package",
+        path: plan.pluginRoot,
+        label: "Claude Code native plugin",
+        state: "installed",
+        expected: "registered marketplace and enabled plugin",
+        observed: "registered and enabled"
+      }
+    ];
+  }
+  return plan.items.map((item) => {
+    if (item.action === "enable-plugin") {
+      return targetForItem(item, "drift", "plugin disabled");
+    }
+    if (item.action === "update-plugin") {
+      return targetForItem(item, "installed", "native update requested");
+    }
+    return targetForItem(item, "missing", "absent");
+  });
 }
 function aggregateState(states) {
   if (states.includes("unknown")) return "unknown";
@@ -3242,36 +2736,81 @@ function aggregateState(states) {
 function statusSummary(state) {
   switch (state) {
     case "installed":
-      return "Claude Code managed plugin is installed and current.";
+      return "Claude Code native plugin and required skills are installed.";
     case "missing":
-      return "Claude Code managed plugin is missing.";
+      return "Claude Code native plugin or required skills are missing.";
     case "drift":
-      return "Claude Code managed plugin exists but differs from expected output.";
+      return "Claude Code native plugin is installed but disabled or incomplete.";
     case "outdated":
-      return "Claude Code managed plugin includes an older generated manifest.";
+      return "Claude Code native plugin is outdated.";
     case "unknown":
-      return "Claude Code managed plugin could not be classified safely.";
+      return "Claude Code native plugin state 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));
+function claudeCodeRequiredSkillStatus(context2) {
+  const targets = REQUIRED_SKILLS.map((skill) => {
+    const path = getRequiredSkillPath(skill, "claude", context2.homeDir);
+    const installed = existsSync7(path);
+    return {
+      kind: "skill",
+      path,
+      label: `Claude Code required skill: ${skill.name}`,
+      state: installed ? "installed" : "missing",
+      expected: "required global Claude Code skill",
+      observed: installed ? "installed" : "missing"
+    };
+  });
+  return {
+    targets,
+    diagnostics: targets.some((target) => target.state === "missing") ? [
+      {
+        severity: "important",
+        code: "claude-code-required-skills-missing",
+        message: "Required Claude Code skills are missing; run install, update, or sync to restore them."
+      }
+    ] : []
+  };
+}
+function claudeCodeRequiredSkillPlanItem() {
+  return {
+    title: "Install required external skills for Claude Code",
+    target: {
+      kind: "skill",
+      label: "Required Claude Code skills",
+      expected: REQUIRED_SKILLS.map(({ name }) => name).join(", ")
+    },
+    preview: JSON.stringify(
+      REQUIRED_SKILLS.map((skill) => ({
+        name: skill.name,
+        ...getRequiredSkillInstallCommand(skill, "claude")
+      })),
+      null,
+      2
+    )
+  };
+}
+function statusFromSetupPlan(plan, context2) {
+  const manager = managerTargets(plan);
+  const requiredSkills = claudeCodeRequiredSkillStatus(context2);
+  const state = aggregateState(
+    [...manager, ...requiredSkills.targets].map(
+      (target) => target.state ?? "unknown"
+    )
+  );
   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"
-    })),
+    targets: [...manager, ...requiredSkills.targets],
+    diagnostics: [
+      ...plan.diagnostics.map((message) => ({
+        severity: "minor",
+        message,
+        code: "claude-code-diagnostic"
+      })),
+      ...requiredSkills.diagnostics
+    ],
     actions: claudeCodeActions,
     disclaimers: [
       ...claudeCodeDisclaimers(),
@@ -3279,10 +2818,14 @@ function statusFromSetupPlan(plan) {
     ]
   };
 }
-function getClaudeCodeStatus(context2 = { cwd: process.cwd() }) {
-  let plan;
+function getClaudeCodeStatus(context2 = { cwd: process.cwd() }, evidence = {}) {
+  const providerCapability = classifyProviderCapabilityEvidence(evidence);
   try {
-    plan = buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true));
+    const plan = buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true));
+    return {
+      ...statusFromSetupPlan(plan, context2),
+      providerCapability
+    };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return {
@@ -3299,22 +2842,24 @@ function getClaudeCodeStatus(context2 = { cwd: process.cwd() }) {
         }
       ],
       actions: claudeCodeActions,
+      providerCapability,
       disclaimers: claudeCodeDisclaimers()
     };
   }
-  return statusFromSetupPlan(plan);
 }
 function planItemFromSetup(item) {
   return {
     title: item.description,
     target: targetForItem(item),
-    preview: item.content,
-    backup: backupForItem(item)
+    preview: `${item.command.executable} ${item.command.args.join(" ")}`,
+    backup: { required: false, strategy: "external" }
   };
 }
-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";
+function planFromSetup(id, action, title, summary, setupPlan, context2) {
+  const status = statusFromSetupPlan(setupPlan, context2);
+  const missingSkills = status.targets.some(
+    (target) => target.kind === "skill" && target.state === "missing"
+  );
   const plan = {
     id,
     harness: "claude",
@@ -3322,161 +2867,100 @@ function planFromSetup(id, action, title, summary, setupPlan) {
     title,
     summary,
     dryRun: true,
-    canApply,
+    canApply: setupPlan.ready && (setupPlan.items.length > 0 || missingSkills),
     targets: status.targets,
-    surfaces: setupPlan.items.map(surfaceForItem),
+    surfaces: setupPlan.items.length > 0 ? setupPlan.items.map(surfaceForItem) : [
+      {
+        id: "native-plugin:installed",
+        label: "Claude Code native plugin",
+        path: setupPlan.pluginRoot,
+        state: setupPlan.ready ? "installed" : "unknown"
+      }
+    ],
     backup: {
-      required: setupPlan.items.some((item) => item.requiresBackup),
-      strategy: "managed-backup-file",
-      description: "Existing Claude Code plugin files are backed up before being overwritten."
+      required: false,
+      strategy: "external",
+      description: "Claude Code owns its marketplace snapshots and plugin cache."
     },
-    items: setupPlan.items.map(planItemFromSetup),
+    items: [
+      ...setupPlan.items.map(planItemFromSetup),
+      claudeCodeRequiredSkillPlanItem()
+    ],
     warnings: status.diagnostics,
     disclaimers: [
       ...claudeCodeDisclaimers(),
       ...setupPlan.disclaimers.map((message) => ({ message }))
     ]
   };
-  claudeCodePlanSources.set(plan, setupPlan);
+  claudeCodePlanSources.set(plan, { setupPlan, context: context2 });
   return plan;
 }
 function buildClaudeCodeInstallPlan(context2 = { 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(context2, true))
+    "Install Claude Code native plugin",
+    "Preview native marketplace registration, plugin installation, and required skills.",
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true)),
+    context2
   );
 }
 function buildClaudeCodeUpdatePlan(context2 = { 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(context2, true))
+    "Reconcile Claude Code native plugin",
+    "Preview native marketplace, enabled-plugin, and required-skill reconciliation.",
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true, true)),
+    context2
   );
 }
 function buildClaudeCodeSyncPlan(context2 = { 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(context2, true))
-  );
-}
-function isClaudeCodeRole(role) {
-  return CLAUDE_CODE_ROLE_NAMES.includes(role);
-}
-function buildClaudeCodeModelPlan(input, context2 = { cwd: process.cwd() }) {
-  const status = getClaudeCodeStatus(context2);
-  const resolvedRoles = input.roles.map((role) => ({
-    role,
-    effort: resolveClaudeCodeEffort(role),
-    validRole: isClaudeCodeRole(role.role),
-    validModel: isClaudeCodeModelAlias(role.model) || role.catalogId === role.model
-  }));
-  const supportedRoles = resolvedRoles.filter((entry) => entry.validRole && entry.validModel && entry.effort.ok).map(({ role, effort }) => ({
-    role: role.role,
-    model: role.model,
-    ...role.catalogId ? { catalogId: role.catalogId } : {},
-    ...effort.ok && effort.effort !== void 0 ? { effort: effort.effort } : {},
-    ...role.effort?.kind === "inherit" ? { clearEffort: true } : {}
-  }));
-  const rejectedRoles = resolvedRoles.filter(
-    (entry) => !entry.validRole || !entry.validModel
-  );
-  const effortErrors = resolvedRoles.filter(
-    (entry) => entry.validRole && entry.validModel && !entry.effort.ok
-  );
-  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"
-      )
-    ),
-    ...effortErrors.map(
-      ({ effort }) => warning(
-        effort.ok ? "Unknown Claude Code effort error." : effort.message,
-        effort.ok ? "claude-code-effort-unknown" : effort.code
-      )
-    )
-  ];
-  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 && effortErrors.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, effort }) => ({
-      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`
+    "Sync Claude Code native plugin",
+    "Preview native marketplace, enabled-plugin, and required-skill reconciliation.",
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true)),
+    context2
+  );
+}
+function buildClaudeCodeModelPlan(input, _context = { cwd: process.cwd() }) {
+  const mismatch = input.harness !== "claude";
+  return {
+    id: "claude-code-model-config-unsupported",
+    harness: "claude",
+    action: "model-config",
+    title: "Claude Code package-owned agent models",
+    summary: MODEL_CONFIG_DISABLED_REASON,
+    dryRun: true,
+    canApply: false,
+    targets: input.target ? [input.target] : [],
+    surfaces: [],
+    backup: { required: false, strategy: "none" },
+    items: input.roles.map((role) => ({
+      title: `Requested ${role.role} Claude Code model`,
+      target: {
+        kind: "package",
+        label: `Claude Code ${role.role} packaged agent`
       },
-      preview: JSON.stringify({ role, model, effort: effort ?? null }),
-      backup: { required: true, strategy: "managed-backup-file" }
+      preview: JSON.stringify({
+        role: role.role,
+        model: role.model,
+        effort: role.effort ?? null,
+        catalogId: role.catalogId ?? null
+      }),
+      backup: { required: false, strategy: "none" }
     })),
-    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"
-      }
-    ]
+    warnings: [
+      ...input.warnings ?? [],
+      warning(
+        mismatch ? "Model plan target harness must be claude." : MODEL_CONFIG_DISABLED_REASON,
+        mismatch ? "claude-code-model-harness-mismatch" : "claude-code-model-cache-owned"
+      )
+    ],
+    disclaimers: [...claudeCodeDisclaimers(), ...input.disclaimers ?? []]
   };
-  claudeCodeModelSources.set(plan, {
-    config: claudeCodeConfig(context2, false),
-    roles: supportedRoles
-  });
-  return plan;
-}
-function pathSep() {
-  return process.platform === "win32" ? "\\" : "/";
 }
 function rejectPlan(plan, message, severity = "critical") {
   return {
@@ -3500,75 +2984,80 @@ function validateClaudeCodePlan(plan) {
       "Claude Code plan cannot be applied because canApply is false."
     );
   }
-  if (!["install", "update", "sync", "model-config"].includes(plan.action)) {
+  if (!["install", "update", "sync"].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,
-        ...role.catalogId ? { catalogId: role.catalogId } : {},
-        ...role.effort ? { effort: role.effort } : {},
-        ...role.clearEffort ? { clearEffort: true } : {}
-      }))
-    );
-    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) {
+  const source = claudeCodePlanSources.get(plan);
+  if (!source) {
     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 });
+  const result = applyClaudeCodeSetup({ ...source.setupPlan, dryRun: false });
+  const requiredSkillWarnings = [];
+  const requiredSkillTargets = [];
+  if (result.success) {
+    for (const skill of REQUIRED_SKILLS) {
+      const installed = installRequiredSkill(skill, "claude", {
+        homeDir: source.context.homeDir
+      });
+      const success2 = installed.status !== "failed";
+      requiredSkillTargets.push({
+        kind: "skill",
+        path: installed.skillPath,
+        label: `Claude Code required skill: ${skill.name}`,
+        state: success2 ? "installed" : "drift",
+        observed: success2 ? installed.status : "installation failed"
+      });
+      if (!success2) {
+        requiredSkillWarnings.push({
+          severity: "critical",
+          code: "claude-code-required-skill-failed",
+          message: `Failed to install required Claude Code skill: ${skill.name}.`
+        });
+      }
+    }
+  }
+  const success = result.success && requiredSkillWarnings.length === 0;
+  let summary = result.error ?? `Failed to apply Claude Code ${plan.action} plan.`;
+  if (success) {
+    summary = `Applied Claude Code native ${plan.action} plan.`;
+  } else if (requiredSkillWarnings.length > 0) {
+    summary = "Claude Code plugin was installed, but required skills failed to install.";
+  }
   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." }],
+    applied: success,
+    summary,
+    changedTargets: [
+      ...result.changed.map((path) => ({
+        kind: "package",
+        path,
+        label: path.includes("/marketplaces/") ? "Claude Code marketplace" : "Claude Code plugin",
+        state: "installed"
+      })),
+      ...requiredSkillTargets
+    ],
+    backups: [],
+    warnings: [
+      ...requiredSkillWarnings,
+      ...result.success ? [] : [
+        {
+          severity: "critical",
+          message: result.error ?? "apply failed."
+        }
+      ]
+    ],
     disclaimers: claudeCodeDisclaimers()
   };
 }
@@ -3580,8 +3069,8 @@ function defaultClaudeCodeModelRoles() {
 }
 
 // src/cli/operations/codex.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9 } from "fs";
-import { basename as basename3 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { basename as basename2 } from "path";
 var CODEX_DISPLAY_NAME = "Codex";
 var codexPlanSources = /* @__PURE__ */ new WeakMap();
 var codexModelSources = /* @__PURE__ */ new WeakMap();
@@ -3667,7 +3156,7 @@ function codexDisclaimers() {
       code: "codex-root-guidance-only"
     },
     {
-      message: "Provider-per-role behavior, hook trust, permissions, and memory governance are instruction-level or user-managed unless Codex exposes runtime controls.",
+      message: "Provider-per-role behavior and permissions are instruction-level or user-managed unless Codex exposes runtime controls.",
       code: "codex-runtime-limits"
     }
   ];
@@ -3688,13 +3177,13 @@ function targetForItem2(item, state, observed) {
 }
 function surfaceForItem2(item) {
   return {
-    id: `${item.kind}:${item.role ?? basename3(item.targetPath)}`,
+    id: `${item.kind}:${item.role ?? basename2(item.targetPath)}`,
     label: item.role ? `Codex ${item.role} subagent TOML` : item.kind.replaceAll("-", " "),
     path: item.targetPath,
     description: item.description
   };
 }
-function backupForItem2(item) {
+function backupForItem(item) {
   return {
     required: item.requiresBackup,
     strategy: item.requiresBackup ? "managed-backup-file" : "none",
@@ -3704,7 +3193,7 @@ function backupForItem2(item) {
 function rootBlockState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const content = readFileSync9(item.targetPath, "utf8");
+  const content = readFileSync5(item.targetPath, "utf8");
   if (item.content && content.includes(item.content)) {
     return { state: "installed", observed: "managed root block present" };
   }
@@ -3717,11 +3206,11 @@ function managedModelState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
   try {
-    const parsed = JSON.parse(readFileSync9(item.targetPath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(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 === readFileSync9(item.targetPath, "utf8") ? { state: "installed", observed: "managed model state current" } : { state: "drift", observed: "managed model state differs" };
+    return item.content === readFileSync5(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" };
   }
@@ -3729,7 +3218,7 @@ function managedModelState(item) {
 function userConfigState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  const content = readFileSync9(item.targetPath, "utf8");
+  const content = readFileSync5(item.targetPath, "utf8");
   if (/^\s*default_mode_request_user_input\s*=\s*true\b/m.test(content)) {
     return {
       state: "installed",
@@ -3741,41 +3230,10 @@ function userConfigState(item) {
   }
   return { state: "missing", observed: "managed feature flag absent" };
 }
-function marketplaceState(item) {
-  if (!existsSync8(item.targetPath))
-    return { state: "missing", observed: "absent" };
-  try {
-    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"
-    );
-    if (!entry)
-      return { state: "missing", observed: "marketplace entry absent" };
-    const sourcePath = typeof entry === "object" && entry && "source" in entry && entry.source && typeof entry.source === "object" && "path" in entry.source ? String(entry.source.path) : "";
-    return sourcePath.includes(".codex/plugins/thoth-agents") ? { state: "installed", observed: "marketplace entry present" } : { state: "drift", observed: `marketplace source ${sourcePath}` };
-  } catch {
-    return { state: "unknown", observed: "unparseable marketplace JSON" };
-  }
-}
-function contentState2(item) {
+function contentState(item) {
   if (!existsSync8(item.targetPath))
     return { state: "missing", observed: "absent" };
-  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;
-      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" };
-    }
-  }
+  const observed = readFileSync5(item.targetPath, "utf8");
   if (item.content === observed)
     return { state: "installed", observed: "current" };
   if (item.role) {
@@ -3790,7 +3248,7 @@ function contentState2(item) {
   }
   return { state: "drift", observed: "content differs" };
 }
-function classifyItem2(item) {
+function classifyItem(item) {
   if (item.action === "diagnose-only") {
     return { state: "unknown", observed: "diagnostic guidance only" };
   }
@@ -3799,8 +3257,7 @@ function classifyItem2(item) {
     return managedModelState(item);
   }
   if (item.action === "merge-toml") return userConfigState(item);
-  if (item.action === "merge-marketplace") return marketplaceState(item);
-  return contentState2(item);
+  return contentState(item);
 }
 function aggregateState2(states) {
   if (states.includes("unknown")) return "unknown";
@@ -3823,7 +3280,50 @@ function statusSummary2(state) {
       return "Codex managed setup could not be classified safely.";
   }
 }
-function getCodexStatus(context2 = { cwd: process.cwd() }) {
+function codexRequiredSkillStatus(context2) {
+  const targets = REQUIRED_SKILLS.map((skill) => {
+    const path = getRequiredSkillPath(skill, "codex", context2.homeDir);
+    const installed = existsSync8(path);
+    return {
+      kind: "skill",
+      path,
+      label: `Codex required skill: ${skill.name}`,
+      state: installed ? "installed" : "missing",
+      expected: "required global Codex skill",
+      observed: installed ? "installed" : "missing"
+    };
+  });
+  return {
+    targets,
+    diagnostics: targets.some((target) => target.state === "missing") ? [
+      {
+        severity: "important",
+        code: "codex-required-skills-missing",
+        message: "Required Codex skills are missing; run install, update, or sync to restore them."
+      }
+    ] : []
+  };
+}
+function codexRequiredSkillPlanItem() {
+  return {
+    title: "Install required external skills for Codex",
+    target: {
+      kind: "skill",
+      label: "Required Codex skills",
+      expected: REQUIRED_SKILLS.map(({ name }) => name).join(", ")
+    },
+    preview: JSON.stringify(
+      REQUIRED_SKILLS.map((skill) => ({
+        name: skill.name,
+        ...getRequiredSkillInstallCommand(skill, "codex")
+      })),
+      null,
+      2
+    )
+  };
+}
+function getCodexStatus(context2 = { cwd: process.cwd() }, evidence = {}) {
+  const providerCapability = classifyProviderCapabilityEvidence(evidence);
   let plan;
   try {
     plan = buildCodexSetupPlan(codexConfig(context2, true));
@@ -3843,26 +3343,36 @@ function getCodexStatus(context2 = { cwd: process.cwd() }) {
         }
       ],
       actions: codexActions,
+      providerCapability,
       disclaimers: codexDisclaimers()
     };
   }
-  const classified = plan.items.filter((item) => item.action !== "diagnose-only").map((item) => ({ item, ...classifyItem2(item) }));
-  const state = aggregateState2(classified.map((item) => item.state));
+  const classified = plan.items.filter((item) => item.action !== "diagnose-only").map((item) => ({ item, ...classifyItem(item) }));
+  const requiredSkills = codexRequiredSkillStatus(context2);
+  const state = aggregateState2([
+    ...classified.map((item) => item.state),
+    ...requiredSkills.targets.map((target) => target.state ?? "unknown")
+  ]);
   const diagnostics = plan.diagnostics.map((message) => ({
     severity: "minor",
     message,
     code: "codex-diagnostic"
   }));
+  diagnostics.push(...requiredSkills.diagnostics);
   return {
     harness: "codex",
     displayName: CODEX_DISPLAY_NAME,
     state,
     summary: statusSummary2(state),
-    targets: classified.map(
-      ({ item, state: state2, observed }) => targetForItem2(item, state2, observed)
-    ),
+    targets: [
+      ...classified.map(
+        ({ item, state: state2, observed }) => targetForItem2(item, state2, observed)
+      ),
+      ...requiredSkills.targets
+    ],
     diagnostics,
     actions: codexActions,
+    providerCapability,
     disclaimers: [
       ...codexDisclaimers(),
       ...plan.disclaimers.map((message) => ({ message }))
@@ -3874,7 +3384,7 @@ function planItemFromSetup2(item) {
     title: item.description,
     target: targetForItem2(item),
     preview: item.content,
-    backup: backupForItem2(item)
+    backup: backupForItem(item)
   };
 }
 function planFromSetup2(id, action, title, summary, setupPlan, context2) {
@@ -3895,7 +3405,10 @@ function planFromSetup2(id, action, title, summary, setupPlan, context2) {
       strategy: "existing-helper",
       description: "Codex setup apply uses the existing installer backup behavior for files that already exist."
     },
-    items: setupPlan.items.map(planItemFromSetup2),
+    items: [
+      ...setupPlan.items.map(planItemFromSetup2),
+      codexRequiredSkillPlanItem()
+    ],
     warnings: [
       ...status.diagnostics,
       ...canApply ? [] : [
@@ -3910,7 +3423,7 @@ function planFromSetup2(id, action, title, summary, setupPlan, context2) {
       ...setupPlan.disclaimers.map((message) => ({ message }))
     ]
   };
-  codexPlanSources.set(plan, setupPlan);
+  codexPlanSources.set(plan, { setupPlan, context: context2 });
   return plan;
 }
 function buildCodexUpdatePlan(context2 = { cwd: process.cwd() }) {
@@ -3930,7 +3443,7 @@ function buildCodexSyncPlan(context2 = { cwd: process.cwd() }) {
     "codex-sync-preview",
     "sync",
     "Sync Codex managed configuration",
-    "Preview Codex managed root instructions, subagents, plugin source, marketplace entry, and feature gates.",
+    "Preview Codex managed root instructions, subagents, feature gates, and native marketplace guidance.",
     setupPlan,
     context2
   );
@@ -4120,26 +3633,26 @@ function applyCodexPlan(plan) {
   const rejection = validateCodexPlan(plan);
   if (rejection) return rejection;
   if (plan.action === "model-config") {
-    const source = codexModelSources.get(plan);
-    if (!source) {
+    const source2 = codexModelSources.get(plan);
+    if (!source2) {
       return rejectPlan2(
         plan,
         "Codex model plan was not produced by buildCodexModelPlan in this process."
       );
     }
-    const result2 = applyCodexManagedModelOverrides(source.config, source.roles);
+    const result2 = applyCodexManagedModelOverrides(source2.config, source2.roles);
     return {
       harness: "codex",
       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((path4) => ({
-        kind: path4.endsWith(".json") ? "memory-state" : "generated-artifact",
-        path: path4,
-        label: basename3(path4),
+      changedTargets: result2.changed.map((path) => ({
+        kind: path.endsWith(".json") ? "memory-state" : "generated-artifact",
+        path,
+        label: basename2(path),
         state: "installed"
       })),
-      backups: result2.changed.filter((path4) => existsSync8(`${path4}.bak`)).map((path4) => ({ path: `${path4}.bak`, label: "managed backup" })),
+      backups: result2.changed.filter((path) => existsSync8(`${path}.bak`)).map((path) => ({ path: `${path}.bak`, label: "managed backup" })),
       warnings: result2.success ? [] : [
         {
           severity: "critical",
@@ -4149,31 +3662,62 @@ function applyCodexPlan(plan) {
       disclaimers: codexDisclaimers()
     };
   }
-  const setupPlan = codexPlanSources.get(plan);
-  if (!setupPlan) {
+  const source = codexPlanSources.get(plan);
+  if (!source) {
     return rejectPlan2(
       plan,
       "Codex setup plan was not produced by a Codex operation plan builder in this process."
     );
   }
-  const result = applyCodexSetup({ ...setupPlan, dryRun: false });
+  const result = applyCodexSetup({ ...source.setupPlan, dryRun: false });
+  const requiredSkillWarnings = [];
+  const requiredSkillTargets = [];
+  if (result.success) {
+    for (const skill of REQUIRED_SKILLS) {
+      const installed = installRequiredSkill(skill, "codex", {
+        homeDir: source.context.homeDir
+      });
+      const success2 = installed.status !== "failed";
+      requiredSkillTargets.push({
+        kind: "skill",
+        path: installed.skillPath,
+        label: `Codex required skill: ${skill.name}`,
+        state: success2 ? "installed" : "drift",
+        observed: success2 ? installed.status : "installation failed"
+      });
+      if (!success2) {
+        requiredSkillWarnings.push({
+          severity: "critical",
+          code: "codex-required-skill-failed",
+          message: `Failed to install required Codex skill: ${skill.name}.`
+        });
+      }
+    }
+  }
+  const success = result.success && requiredSkillWarnings.length === 0;
   return {
     harness: "codex",
     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((path4) => ({
-      kind: path4.endsWith(".json") ? "memory-state" : "generated-artifact",
-      path: path4,
-      label: basename3(path4),
-      state: "installed"
-    })),
-    backups: result.changed.filter((path4) => existsSync8(`${path4}.bak`)).map((path4) => ({ path: `${path4}.bak`, label: "managed backup" })),
-    warnings: result.success ? [] : [
-      {
-        severity: "critical",
-        message: result.error ?? "Codex setup apply failed."
-      }
+    applied: success,
+    summary: success ? `Applied Codex managed ${plan.action} plan.` : requiredSkillWarnings.length > 0 ? `Codex setup was written, but required skills failed to install.` : result.error ?? `Failed to apply Codex ${plan.action} plan.`,
+    changedTargets: [
+      ...result.changed.map((path) => ({
+        kind: path.endsWith(".json") ? "memory-state" : "generated-artifact",
+        path,
+        label: basename2(path),
+        state: "installed"
+      })),
+      ...requiredSkillTargets
+    ],
+    backups: result.changed.filter((path) => existsSync8(`${path}.bak`)).map((path) => ({ path: `${path}.bak`, label: "managed backup" })),
+    warnings: [
+      ...requiredSkillWarnings,
+      ...result.success ? [] : [
+        {
+          severity: "critical",
+          message: result.error ?? "Codex setup apply failed."
+        }
+      ]
     ],
     disclaimers: codexDisclaimers()
   };
@@ -4181,8 +3725,8 @@ function applyCodexPlan(plan) {
 
 // src/cli/operations/opencode.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join4 } from "path";
 
 // src/cli/opencode-effort.ts
 var OPENAI_GPT_RUNTIME_VARIANTS = /* @__PURE__ */ new Set([
@@ -4214,80 +3758,6 @@ function resolveOpenCodeEffort(input) {
   };
 }
 
-// src/cli/skills.ts
-import { spawnSync } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join9 } from "path";
-var RECOMMENDED_SKILLS = [
-  {
-    name: "simplify",
-    repo: "https://github.com/brianlovin/claude-config",
-    skillName: "simplify",
-    description: "YAGNI code simplification expert"
-  },
-  {
-    name: "playwright-cli",
-    repo: "https://github.com/microsoft/playwright-cli",
-    skillName: "playwright-cli",
-    description: "Browser automation for visual checks and testing"
-  }
-];
-function getRecommendedSkillPath(skill, homeDir = homedir3()) {
-  return join9(homeDir, ".agents", "skills", skill.skillName, "SKILL.md");
-}
-function isRecommendedSkillInstalled(skill, options = {}) {
-  return existsSync9(getRecommendedSkillPath(skill, options.homeDir));
-}
-function runSkillInstallCommand(skill) {
-  const args = [
-    "skills",
-    "add",
-    skill.repo,
-    "--skill",
-    skill.skillName,
-    "-a",
-    "opencode",
-    "-y",
-    "--global"
-  ];
-  try {
-    const result = spawnSync("npx", args, { stdio: "inherit" });
-    if (result.status !== 0) {
-      return { success: false };
-    }
-    if (skill.postInstallCommands && skill.postInstallCommands.length > 0) {
-      console.log(`Running post-install commands for ${skill.name}...`);
-      for (const cmd of skill.postInstallCommands) {
-        console.log(`> ${cmd}`);
-        const [command, ...cmdArgs] = cmd.split(" ");
-        const cmdResult = spawnSync(command, cmdArgs, { stdio: "inherit" });
-        if (cmdResult.status !== 0) {
-          console.warn(`Post-install command failed: ${cmd}`);
-        }
-      }
-    }
-    return { success: true };
-  } catch (error) {
-    console.error(`Failed to install skill: ${skill.name}`, error);
-    return { success: false, error };
-  }
-}
-function installRecommendedSkill(skill, options = {}) {
-  const skillPath = getRecommendedSkillPath(skill, options.homeDir);
-  if (isRecommendedSkillInstalled(skill, options)) {
-    return { skill, status: "already-installed", skillPath };
-  }
-  const result = runSkillInstallCommand(skill);
-  if (result.success) {
-    return { skill, status: "installed", skillPath };
-  }
-  if (isRecommendedSkillInstalled(skill, options)) {
-    return { skill, status: "already-installed", skillPath };
-  }
-  return { skill, status: "failed", skillPath, error: result.error };
-}
-
 // src/cli/operations/opencode.ts
 var PACKAGE_NAME = "thoth-agents";
 var EXPECTED_PLUGIN = `${PACKAGE_NAME}@latest`;
@@ -4453,7 +3923,7 @@ var openCodeActions = [
     id: "opencode-install",
     kind: "install",
     label: "Install",
-    description: "Preview OpenCode install using --no-tui --tmux=no --skills=yes semantics",
+    description: "Preview OpenCode install with required external skills",
     dryRun: true,
     requiresConfirmation: true,
     supported: true
@@ -4508,7 +3978,7 @@ function targetForLiteConfig(state) {
     path: getExistingLiteConfigPath(),
     label: "thoth-agents config",
     ...state ? { state } : {},
-    expected: `seven-agent ${OPENAI_PRESET} roster`
+    expected: `seven-role ${OPENAI_PRESET} roster`
   };
 }
 function titleCaseSkillName(value) {
@@ -4522,89 +3992,32 @@ function titleCaseSkillName(value) {
   }).join("-");
 }
 function homeDirFromContext(context2) {
-  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join10(context2.cwd, "home") : void 0);
+  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join4(context2.cwd, "home") : void 0);
 }
 function openCodeSkillTargets(context2) {
   const homeDir = homeDirFromContext(context2);
-  const recommendedTargets = RECOMMENDED_SKILLS.map(
-    (skill) => {
-      const path4 = getRecommendedSkillPath(skill, homeDir);
-      const installed = existsSync10(path4);
-      return {
-        kind: "skill",
-        path: path4,
-        label: titleCaseSkillName(skill.skillName),
-        state: installed ? "installed" : "missing",
-        expected: "recommended global OpenCode skill",
-        observed: installed ? "recommended global skill installed" : "recommended global skill missing"
-      };
-    }
-  );
-  let staleSkillNames = /* @__PURE__ */ new Set();
-  let removedSkillNames = [];
-  let skillHealthError;
-  try {
-    const updateCheck = checkCustomSkillsNeedUpdate();
-    staleSkillNames = new Set(
-      updateCheck.skillsNeedingUpdate.map(({ skill }) => skill.name)
-    );
-    removedSkillNames = updateCheck.removedSkills;
-  } catch (error) {
-    skillHealthError = String(error);
-  }
-  const bundledTargets = CUSTOM_SKILLS.map((skill) => {
-    const path4 = join10(getCustomSkillsDir(), skill.name, "SKILL.md");
-    const installed = existsSync10(path4);
-    const stale = installed && staleSkillNames.has(skill.name);
-    let state = "installed";
-    let observed = "bundled OpenCode skill installed and current";
-    if (!installed) {
-      state = "missing";
-      observed = "bundled OpenCode skill missing";
-    } else if (stale) {
-      state = "drift";
-      observed = "bundled OpenCode skill is outdated";
-    }
+  const requiredTargets = REQUIRED_SKILLS.map((skill) => {
+    const path = getRequiredSkillPath(skill, "opencode", homeDir);
+    const installed = existsSync9(path);
     return {
       kind: "skill",
-      path: path4,
-      label: titleCaseSkillName(skill.name),
-      state,
-      expected: "bundled thoth-agents OpenCode skill",
-      observed
+      path,
+      label: titleCaseSkillName(skill.skillName),
+      state: installed ? "installed" : "missing",
+      expected: "required global OpenCode skill",
+      observed: installed ? "required global skill installed" : "required global skill missing"
     };
   });
   const diagnostics = [];
-  if (recommendedTargets.some((target) => target.state === "missing")) {
-    diagnostics.push({
-      severity: "minor",
-      message: "Recommended OpenCode global skills are missing; run the OpenCode install flow with skills enabled.",
-      code: "opencode-recommended-skills-missing"
-    });
-  }
-  if (bundledTargets.some((target) => target.state === "missing")) {
+  if (requiredTargets.some((target) => target.state === "missing")) {
     diagnostics.push({
       severity: "important",
-      message: "Bundled thoth-agents OpenCode skills are missing; run OpenCode install or sync to refresh managed skills.",
-      code: "opencode-bundled-skills-missing"
-    });
-  }
-  if (bundledTargets.some((target) => target.state === "drift") || removedSkillNames.length > 0) {
-    diagnostics.push({
-      severity: "important",
-      message: "Bundled thoth-agents OpenCode skills are outdated; run OpenCode install or sync to refresh managed skills.",
-      code: "opencode-bundled-skills-outdated"
-    });
-  }
-  if (skillHealthError) {
-    diagnostics.push({
-      severity: "critical",
-      message: `Bundled skill health could not be classified: ${skillHealthError}`,
-      code: "opencode-bundled-skills-health-unknown"
+      message: "Required OpenCode global skills are missing; run install or sync to restore them.",
+      code: "opencode-required-skills-missing"
     });
   }
   return {
-    targets: [...recommendedTargets, ...bundledTargets],
+    targets: requiredTargets,
     diagnostics
   };
 }
@@ -4677,12 +4090,10 @@ var REPAIRABLE_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
   "opencode-lite-config-missing",
   "opencode-roster-drift",
   ACTIVE_PRESET_SELECTED_CODE,
-  "opencode-bundled-skills-missing",
-  "opencode-bundled-skills-outdated"
+  "opencode-required-skills-missing"
 ]);
 var MODEL_PRECONFIG_SKILL_CODES = /* @__PURE__ */ new Set([
-  "opencode-bundled-skills-missing",
-  "opencode-bundled-skills-outdated"
+  "opencode-required-skills-missing"
 ]);
 function uniqueTargets(targets) {
   const seen = /* @__PURE__ */ new Set();
@@ -4714,9 +4125,9 @@ function targetsForBlockingDiagnostic(diagnostic, status) {
   if (code === "opencode-roster-drift" || code === ACTIVE_PRESET_SELECTED_CODE || code === "opencode-lite-config-missing" || code === "thoth-config-parse-error" || code === "opencode-roster-unrecognized") {
     return lite ? [lite] : [];
   }
-  if (code === "opencode-bundled-skills-missing" || code === "opencode-bundled-skills-outdated" || code === "opencode-bundled-skills-health-unknown") {
+  if (code === "opencode-required-skills-missing") {
     return status.targets.filter(
-      (target) => target.expected === "bundled thoth-agents OpenCode skill" && (code === "opencode-bundled-skills-health-unknown" || target.state !== "installed")
+      (target) => target.expected === "required global OpenCode skill" && target.state !== "installed"
     );
   }
   return [
@@ -4759,7 +4170,7 @@ function blockingDetails(action, status, includeRepairable = false) {
 function canApplyToManagedHealth(action, status) {
   return blockingDetails(action, status).diagnostics.length === 0;
 }
-function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
+function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
   const mainPath = getExistingConfigPath();
   const litePath = getExistingLiteConfigPath();
   const main = parseConfig(mainPath);
@@ -4801,8 +4212,8 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
       actions: openCodeActions
     };
   }
-  const mainExists = existsSync10(mainPath);
-  const liteExists = existsSync10(litePath);
+  const mainExists = existsSync9(mainPath);
+  const liteExists = existsSync9(litePath);
   const mainTarget = {
     ...targetForMainConfig(),
     observed: configPluginMarker(main.config)
@@ -5028,7 +4439,7 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
       harness: "opencode",
       displayName: "OpenCode",
       state: "drift",
-      summary: selectedNamedPreset ? "A valid named OpenCode preset is active outside the managed seven-agent roster." : "thoth-agents config does not match the expected seven-agent roster.",
+      summary: selectedNamedPreset ? "A valid named OpenCode preset is active outside the managed seven-role roster." : "thoth-agents config does not match the expected seven-role roster.",
       targets: [
         { ...mainTarget, state: "installed" },
         { ...liteTarget, state: "drift" },
@@ -5045,11 +4456,14 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
       actions: openCodeActions
     };
   }
+  const requiredSkillsMissing = skillStatus.targets.some(
+    (target) => target.state === "missing"
+  );
   return {
     harness: "opencode",
     displayName: "OpenCode",
-    state: "installed",
-    summary: "OpenCode managed thoth-agents configuration is installed.",
+    state: requiredSkillsMissing ? "drift" : "installed",
+    summary: requiredSkillsMissing ? "OpenCode configuration is installed, but required external skills are missing." : "OpenCode managed thoth-agents configuration is installed.",
     targets: [
       { ...mainTarget, state: "installed" },
       { ...liteTarget, state: "installed" },
@@ -5059,11 +4473,17 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
     actions: openCodeActions
   };
 }
-function defaultBackup(path4) {
+function getOpenCodeStatus(context2 = { cwd: process.cwd() }, evidence = {}) {
+  return {
+    ...getOpenCodeManagedStatus(context2),
+    providerCapability: classifyProviderCapabilityEvidence(evidence)
+  };
+}
+function defaultBackup(path) {
   return {
     required: true,
     strategy: "managed-backup-file",
-    destinations: [{ path: `${path4}.bak`, label: "managed backup" }]
+    destinations: [{ path: `${path}.bak`, label: "managed backup" }]
   };
 }
 function backupFromItems(items) {
@@ -5085,18 +4505,6 @@ function backupFromItems(items) {
     ...primary?.description ? { description: primary.description } : {}
   };
 }
-function bundledSkillsRefreshItem() {
-  const names = CUSTOM_SKILLS.map(({ name }) => name);
-  return {
-    title: "Refresh bundled thoth-agents OpenCode skills",
-    target: {
-      kind: "skill",
-      label: "Bundled thoth-agents OpenCode skills",
-      expected: `${names.length} managed bundled skills`
-    },
-    preview: JSON.stringify({ count: names.length, names }, null, 2)
-  };
-}
 function defaultDisclaimers() {
   return [
     {
@@ -5151,7 +4559,7 @@ function planFromItems(id, action, title, summary, items, context2) {
   };
 }
 function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
-  const path4 = getExistingConfigPath();
+  const path = getExistingConfigPath();
   const { plan, status } = planFromItems(
     "opencode-update-preview",
     "update",
@@ -5163,7 +4571,7 @@ function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
         target: targetForMainConfig(),
         state: getOpenCodeStatus(_context).state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
-        backup: defaultBackup(path4)
+        backup: defaultBackup(path)
       }
     ],
     _context
@@ -5177,8 +4585,6 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
   const generatedConfig = generateLiteConfig({
     agent: "opencode",
     hasTmux: false,
-    installSkills: false,
-    installCustomSkills: true,
     dryRun: true,
     reset: false
   });
@@ -5203,12 +4609,27 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
         backup: defaultBackup(getExistingConfigPath())
       },
       {
-        title: "Write thoth-agents seven-agent config",
+        title: "Write thoth-agents seven-role config",
         target: targetForLiteConfig(),
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
       },
-      bundledSkillsRefreshItem()
+      {
+        title: "Install required external skills",
+        target: {
+          kind: "skill",
+          label: "Required OpenCode skills",
+          expected: REQUIRED_SKILLS.map(({ name }) => name).join(", ")
+        },
+        preview: JSON.stringify(
+          REQUIRED_SKILLS.map((skill) => ({
+            name: skill.name,
+            ...getRequiredSkillInstallCommand(skill, "opencode")
+          })),
+          null,
+          2
+        )
+      }
     ],
     _context
   );
@@ -5221,8 +4642,6 @@ function tuiInstallConfig() {
   return {
     agent: "opencode",
     hasTmux: false,
-    installSkills: true,
-    installCustomSkills: true,
     dryRun: true,
     reset: false
   };
@@ -5232,16 +4651,15 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
   const installPreview = {
     noTui: true,
     hasTmux: false,
-    installSkills: true,
-    installCustomSkills: true,
-    equivalentCommand: "install --agent=opencode --no-tui --tmux=no --skills=yes"
+    requiredSkills: REQUIRED_SKILLS.map((skill) => skill.name),
+    equivalentCommand: "install --agent=opencode --no-tui --tmux=no"
   };
   const litePath = getExistingLiteConfigPath();
   const { plan, status } = planFromItems(
     "opencode-install-preview",
     "install",
     "Preview install",
-    "Preview OpenCode install equivalent to install --agent=opencode --no-tui --tmux=no --skills=yes.",
+    "Preview OpenCode install with the required external skills.",
     [
       {
         title: "Apply OpenCode TUI install options",
@@ -5250,7 +4668,7 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
           path: getExistingConfigPath(),
           label: "OpenCode install options",
           state: getOpenCodeStatus(_context).state,
-          expected: "--no-tui --tmux=no --skills=yes"
+          expected: "--no-tui --tmux=no plus required external skills"
         },
         preview: JSON.stringify(installPreview, null, 2)
       },
@@ -5268,20 +4686,26 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
         backup: defaultBackup(getExistingConfigPath())
       },
       {
-        title: "Write thoth-agents seven-agent config",
+        title: "Write thoth-agents seven-role config",
         target: targetForLiteConfig(),
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
       },
-      bundledSkillsRefreshItem(),
       {
-        title: "Install recommended external skills",
+        title: "Install required external skills",
         target: {
           kind: "skill",
-          label: "Recommended OpenCode skills",
-          expected: "skills=yes"
+          label: "Required OpenCode skills",
+          expected: REQUIRED_SKILLS.map(({ name }) => name).join(", ")
         },
-        preview: JSON.stringify({ installSkills: true }, null, 2)
+        preview: JSON.stringify(
+          REQUIRED_SKILLS.map((skill) => ({
+            name: skill.name,
+            ...getRequiredSkillInstallCommand(skill, "opencode")
+          })),
+          null,
+          2
+        )
       }
     ],
     _context
@@ -5528,8 +4952,6 @@ function applyModelPlan(roles) {
   const base = parsed.config ?? generateLiteConfig({
     agent: "opencode",
     hasTmux: false,
-    installSkills: false,
-    installCustomSkills: true,
     dryRun: false,
     reset: false
   });
@@ -5583,85 +5005,33 @@ function applyModelPlan(roles) {
         observed: "agents role overrides updated"
       }
     ],
-    backups: existsSync10(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
+    backups: existsSync9(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
     warnings,
     disclaimers: defaultDisclaimers()
   };
 }
-function applyRecommendedSkills() {
+function applyRequiredSkills(context2) {
   const warnings = [];
-  for (const skill of RECOMMENDED_SKILLS) {
+  const homeDir = homeDirFromContext(context2);
+  for (const skill of REQUIRED_SKILLS) {
     try {
-      const result = installRecommendedSkill(skill);
+      const result = installRequiredSkill(skill, "opencode", { homeDir });
       if (result.status !== "failed") continue;
       warnings.push({
-        severity: "important",
-        code: "opencode-recommended-skill-failed",
-        message: `Failed to install optional recommended OpenCode skill: ${skill.name}.`
+        severity: "critical",
+        code: "opencode-required-skill-failed",
+        message: `Failed to install required OpenCode skill: ${skill.name}.`
       });
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
       warnings.push({
-        severity: "important",
-        code: "opencode-recommended-skill-failed",
-        message: `Failed to install optional recommended OpenCode skill ${skill.name}: ${reason}.`
+        severity: "critical",
+        code: "opencode-required-skill-failed",
+        message: `Failed to install required OpenCode skill ${skill.name}: ${reason}.`
       });
     }
   }
-  return warnings;
-}
-function bundledSkillsFailure(plan, changedTargets, backups, warnings, detail) {
-  const message = `Failed to install bundled thoth-agents OpenCode skills: ${detail}.`;
-  return {
-    harness: plan.harness,
-    action: plan.action,
-    applied: false,
-    summary: message,
-    changedTargets,
-    backups,
-    warnings: [
-      ...warnings,
-      {
-        severity: "critical",
-        code: "opencode-bundled-skills-failed",
-        message
-      }
-    ],
-    disclaimers: defaultDisclaimers()
-  };
-}
-function applyBundledSkills(plan, changedTargets, backups, warnings) {
-  let bundled;
-  try {
-    bundled = installCustomSkills();
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    return bundledSkillsFailure(
-      plan,
-      changedTargets,
-      backups,
-      warnings,
-      detail
-    );
-  }
-  if (!bundled.success) {
-    const failedNames = bundled.failedSkills.map(({ skill }) => skill.name);
-    const detail = failedNames.length > 0 ? failedNames.join(", ") : "unknown bundled skills";
-    return bundledSkillsFailure(
-      plan,
-      changedTargets,
-      backups,
-      warnings,
-      detail
-    );
-  }
-  changedTargets.push({
-    kind: "skill",
-    label: "Bundled thoth-agents OpenCode skills",
-    state: "installed",
-    observed: "managed bundled skills refreshed"
-  });
-  return null;
+  return { success: warnings.length === 0, warnings };
 }
 function applyOpenCodePlan(plan) {
   const rejection = validateApplyPlan(plan);
@@ -5718,7 +5088,7 @@ function applyOpenCodePlan(plan) {
     ...targetForMainConfig("installed"),
     observed: `plugin includes ${EXPECTED_PLUGIN}`
   });
-  if (existsSync10(`${mainConfigResult.configPath}.bak`)) {
+  if (existsSync9(`${mainConfigResult.configPath}.bak`)) {
     backups.push({
       path: `${mainConfigResult.configPath}.bak`,
       label: "OpenCode config backup"
@@ -5729,8 +5099,6 @@ function applyOpenCodePlan(plan) {
       {
         agent: "opencode",
         hasTmux: false,
-        installSkills: issued.payload.action === "install",
-        installCustomSkills: true,
         dryRun: false,
         reset: false
       },
@@ -5744,32 +5112,36 @@ function applyOpenCodePlan(plan) {
     }
     changedTargets.push({
       ...targetForLiteConfig("installed"),
-      observed: "seven-agent roster written"
+      observed: "seven-role roster written"
     });
-    if (existsSync10(`${liteResult.configPath}.bak`)) {
+    if (existsSync9(`${liteResult.configPath}.bak`)) {
       backups.push({
         path: `${liteResult.configPath}.bak`,
         label: "thoth-agents config backup"
       });
     }
-    const skillsRejection = applyBundledSkills(
-      plan,
-      changedTargets,
-      backups,
-      warnings
-    );
-    if (skillsRejection) return skillsRejection;
   }
-  if (issued.payload.action === "install") {
-    warnings.push(...applyRecommendedSkills());
+  if (issued.payload.action === "install" || issued.payload.action === "sync") {
+    const requiredSkills = applyRequiredSkills(issued.context);
+    warnings.push(...requiredSkills.warnings);
     changedTargets.push({
       kind: "skill",
-      label: "Recommended OpenCode skills",
-      state: warnings.some(
-        (warning3) => warning3.code === "opencode-recommended-skill-failed"
-      ) ? "drift" : "installed",
-      observed: "optional skills=yes processed"
+      label: "Required OpenCode skills",
+      state: requiredSkills.success ? "installed" : "drift",
+      observed: requiredSkills.success ? "required external skills installed" : "required external skill installation failed"
     });
+    if (!requiredSkills.success) {
+      return {
+        harness: "opencode",
+        action: plan.action,
+        applied: false,
+        summary: "OpenCode configuration was written, but required skills failed to install.",
+        changedTargets,
+        backups,
+        warnings,
+        disclaimers: defaultDisclaimers()
+      };
+    }
   }
   return {
     harness: "opencode",
@@ -5806,14 +5178,14 @@ import { execFileSync } from "child_process";
 
 // src/cli/model-catalog/cache.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync6,
   renameSync as renameSync2,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir3 } from "os";
 import { dirname as dirname5, posix, win32 } from "path";
 import { z as z2 } from "zod";
 var modelCatalogSourceSchema = z2.enum(["remote", "lkg", "manual"]);
@@ -5834,19 +5206,19 @@ var modelsDevCacheSchema = z2.object({
 function resolveModelsDevCachePath(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const home = options.homeDir ?? homedir4();
+  const home = options.homeDir ?? homedir3();
   if (platform === "win32") {
-    const path4 = win32;
-    const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path4.join(home, "AppData", "Local");
-    return path4.join(base2, "thoth-agents", "models-dev-v1.json");
+    const path = win32;
+    const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path.join(home, "AppData", "Local");
+    return path.join(base2, "thoth-agents", "models-dev-v1.json");
   }
   const base = env.XDG_CACHE_HOME ?? posix.join(home, ".cache");
   return posix.join(base, "thoth-agents", "models-dev-v1.json");
 }
 function readModelsDevCache(cachePath) {
-  if (!existsSync11(cachePath)) return void 0;
+  if (!existsSync10(cachePath)) return void 0;
   try {
-    const input = JSON.parse(readFileSync10(cachePath, "utf8"));
+    const input = JSON.parse(readFileSync6(cachePath, "utf8"));
     const parsed = modelsDevCacheSchema.safeParse(input);
     return parsed.success ? parsed.data : void 0;
   } catch {
@@ -5868,7 +5240,7 @@ function writeModelsDevCacheAtomic(cachePath, cache) {
     );
     renameSync2(temporaryPath, cachePath);
   } catch (error) {
-    if (existsSync11(temporaryPath)) unlinkSync(temporaryPath);
+    if (existsSync10(temporaryPath)) unlinkSync(temporaryPath);
     throw error;
   }
 }
@@ -6060,7 +5432,7 @@ var CODEX_DOCUMENTED_EFFORTS2 = /* @__PURE__ */ new Set([
   "max",
   "ultra"
 ]);
-var CLAUDE_CODE_EFFORTS2 = ["low", "medium", "high", "xhigh", "max"];
+var CLAUDE_CODE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 function parseOpenCodeModels(output) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
@@ -6093,7 +5465,7 @@ function writableEfforts(harness, option) {
   }
   if (harness === "claude") {
     return option.efforts.filter(
-      (effort) => CLAUDE_CODE_EFFORTS2.includes(effort)
+      (effort) => CLAUDE_CODE_EFFORTS.includes(effort)
     );
   }
   return option.efforts.filter(
@@ -6144,7 +5516,7 @@ var CLAUDE_CODE_MODEL_OPTIONS = [
   }
 ].map((option) => ({
   ...option,
-  efforts: option.id === "inherit" ? [] : [...CLAUDE_CODE_EFFORTS2],
+  efforts: option.id === "inherit" ? [] : [...CLAUDE_CODE_EFFORTS],
   source: "manual"
 }));
 async function getModelOptions(harness) {
@@ -6181,7 +5553,7 @@ async function getModelOptions(harness) {
 }
 
 // src/cli/tui/operations.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 var context = { cwd: process.cwd() };
 var codexContext = { cwd: process.cwd() };
 var claudeCodeContext = {
@@ -6191,7 +5563,8 @@ var claudeCodeContext = {
 var opencodeModelRoles = ALL_AGENT_NAMES.map(
   (role) => ({
     role,
-    model: DEFAULT_MODELS[role] ?? "openai/gpt-5.4"
+    model: getDefaultOpenCodeModel(role),
+    effort: { kind: "effort", value: getDefaultOpenCodeVariant(role) }
   })
 );
 var codexModelRoles = CODEX_ROLE_NAMES.map(
@@ -6222,7 +5595,7 @@ function getCodexModelRoles(source = codexContext) {
       const item = plan.items.find(
         (candidate) => candidate.action === "write-role-toml" && candidate.role === role
       );
-      const content = item && existsSync12(item.targetPath) ? readFileSync11(item.targetPath, "utf8") : item?.content;
+      const content = item && existsSync11(item.targetPath) ? readFileSync7(item.targetPath, "utf8") : item?.content;
       const effort = content ? parseRoleTomlEffort(content) : void 0;
       return {
         role,
@@ -6234,32 +5607,8 @@ 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 content = item && existsSync12(item.targetPath) ? readFileSync11(item.targetPath, "utf8") : item?.content;
-      const model = content ? parseSubagentModel(content) : void 0;
-      const effort = content ? parseSubagentEffort(content) : void 0;
-      return {
-        role,
-        model: model ?? "inherit",
-        effort: effort ? { kind: "effort", value: effort } : { kind: "inherit" }
-      };
-    });
-  } catch {
-    return defaultClaudeCodeModelRoles();
-  }
+function getClaudeCodeModelRoles(_source = claudeCodeContext) {
+  return defaultClaudeCodeModelRoles();
 }
 function readRoleField(config, role, field) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
@@ -6281,10 +5630,13 @@ function getOpenCodeModelRoles() {
   const selectedPreset = presetName !== void 0 ? presets[presetName] : void 0;
   const activePreset = selectedPreset && typeof selectedPreset === "object" && !Array.isArray(selectedPreset) ? selectedPreset : void 0;
   return ALL_AGENT_NAMES.map((role) => {
-    const variant = readRoleField(agents, role, "variant") ?? readRoleField(activePreset, role, "variant");
+    const defaultModel = getDefaultOpenCodeModel(role);
+    const model = readRoleField(agents, role, "model") ?? readRoleField(activePreset, role, "model") ?? defaultModel;
+    const configuredVariant = readRoleField(agents, role, "variant") ?? readRoleField(activePreset, role, "variant");
+    const variant = configuredVariant ?? (model === defaultModel ? getDefaultOpenCodeVariant(role) : void 0);
     return {
       role,
-      model: readRoleField(agents, role, "model") ?? readRoleField(activePreset, role, "model") ?? DEFAULT_MODELS[role] ?? "openai/gpt-5.4",
+      model,
       effort: variant ? { kind: "effort", value: variant } : { kind: "inherit" }
     };
   });
@@ -6302,12 +5654,12 @@ function buildTuiModelPlan(harness, roles) {
   return buildCodexModelPlan({ harness, dryRun: true, roles }, codexContext);
 }
 var defaultTuiOperations = {
-  status(harness) {
-    if (harness === "opencode") return getOpenCodeStatus(context);
+  status(harness, evidence) {
+    if (harness === "opencode") return getOpenCodeStatus(context, evidence);
     if (harness === "claude") {
-      return getClaudeCodeStatus(claudeCodeContext);
+      return getClaudeCodeStatus(claudeCodeContext, evidence);
     }
-    return getCodexStatus(codexContext);
+    return getCodexStatus(codexContext, evidence);
   },
   modelRoles(harness) {
     if (harness === "opencode") return getOpenCodeModelRoles();
@@ -6365,8 +5717,9 @@ export {
   buildClaudeCodeSetupPlan,
   applyClaudeCodeSetup,
   formatClaudeCodeSetupPlan,
-  RECOMMENDED_SKILLS,
-  installRecommendedSkill,
+  REQUIRED_SKILLS,
+  getRequiredSkillInstallCommand,
+  installRequiredSkill,
   getClaudeCodeStatus,
   buildClaudeCodeUpdatePlan,
   buildClaudeCodeSyncPlan,