thoth-agents 0.3.4 → 0.3.6

package/dist/{chunk-W5GCMYA3.js → chunk-HIXSRHEG.js}

@@ -3777,8 +3777,8 @@ function applyCodexPlan(plan) {
 
 // src/cli/operations/opencode.ts
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync9 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join5 } from "path";
 
 // src/cli/opencode-effort.ts
 var OPENAI_GPT_RUNTIME_VARIANTS = /* @__PURE__ */ new Set([
@@ -3810,10 +3810,127 @@ function resolveOpenCodeEffort(input) {
   };
 }
 
+// src/cli/owned-skills.ts
+import {
+  cpSync,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  renameSync as renameSync2,
+  rmSync,
+  statSync
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname5, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+
+// src/harness/core/owned-skills.ts
+var THOTH_OWNED_SKILL_NAMES = [
+  "thoth-init",
+  "thoth-sdd",
+  "thoth-constitution",
+  "thoth-archive",
+  "plan-reviewer"
+];
+
+// src/cli/owned-skills.ts
+function resolveOwnedSkillPackageRoot(moduleUrl) {
+  const packageRoot = findPackageRoot(dirname5(fileURLToPath4(moduleUrl)));
+  if (!packageRoot) {
+    throw new Error(
+      "Unable to locate the thoth-agents package root for bundled owned skills."
+    );
+  }
+  return packageRoot;
+}
+function defaultPackageRoot() {
+  return resolveOwnedSkillPackageRoot(import.meta.url);
+}
+function getOpenCodeOwnedSkillEntries(options = {}) {
+  const packageRoot = options.packageRoot ?? defaultPackageRoot();
+  const homeDir = options.homeDir ?? homedir3();
+  return THOTH_OWNED_SKILL_NAMES.map((name) => ({
+    name,
+    sourcePath: join4(packageRoot, "skills", name),
+    destinationPath: join4(homeDir, ".config", "opencode", "skills", name)
+  }));
+}
+function validateCanonicalSkill(entry) {
+  if (!existsSync9(entry.sourcePath) || !statSync(entry.sourcePath).isDirectory()) {
+    throw new Error(
+      `Canonical owned skill directory is missing: ${entry.name}`
+    );
+  }
+  const contractPath = join4(entry.sourcePath, "SKILL.md");
+  if (!existsSync9(contractPath) || !statSync(contractPath).isFile()) {
+    throw new Error(`Canonical owned skill contract is missing: ${entry.name}`);
+  }
+}
+function installOwnedSkills(skills) {
+  const firstSkill = skills[0];
+  if (!firstSkill) return;
+  const globalRoot = dirname5(firstSkill.destinationPath);
+  mkdirSync3(globalRoot, { recursive: true });
+  const transactionRoot = mkdtempSync(join4(globalRoot, ".thoth-agents-owned-"));
+  const stagedRoot = join4(transactionRoot, "staged");
+  const backupRoot = join4(transactionRoot, "backup");
+  mkdirSync3(stagedRoot, { recursive: true });
+  mkdirSync3(backupRoot, { recursive: true });
+  try {
+    for (const skill of skills) {
+      cpSync(skill.sourcePath, join4(stagedRoot, skill.name), {
+        recursive: true,
+        force: true
+      });
+    }
+    for (const skill of skills) {
+      const stagedPath = join4(stagedRoot, skill.name);
+      const backupPath = join4(backupRoot, skill.name);
+      const hadExistingDestination = existsSync9(skill.destinationPath);
+      if (hadExistingDestination) {
+        renameSync2(skill.destinationPath, backupPath);
+      }
+      try {
+        renameSync2(stagedPath, skill.destinationPath);
+      } catch (error) {
+        if (existsSync9(skill.destinationPath)) {
+          rmSync(skill.destinationPath, { recursive: true, force: true });
+        }
+        if (hadExistingDestination && existsSync9(backupPath)) {
+          renameSync2(backupPath, skill.destinationPath);
+        }
+        throw error;
+      }
+      if (existsSync9(backupPath)) {
+        rmSync(backupPath, { recursive: true, force: true });
+      }
+    }
+  } finally {
+    rmSync(transactionRoot, { recursive: true, force: true });
+  }
+}
+function syncOpenCodeOwnedSkills(options = {}) {
+  const skills = getOpenCodeOwnedSkillEntries(options);
+  try {
+    for (const skill of skills) validateCanonicalSkill(skill);
+    if (options.dryRun) return { success: true, status: "planned", skills };
+    installOwnedSkills(skills);
+    return { success: true, status: "installed", skills };
+  } catch (error) {
+    return {
+      success: false,
+      status: "failed",
+      skills,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 // src/cli/operations/opencode.ts
 var PACKAGE_NAME = "thoth-agents";
 var EXPECTED_PLUGIN = `${PACKAGE_NAME}@latest`;
 var OPENAI_PRESET = "openai";
+var APPLIED_MODELS_PRESET = "agents";
 var ROLE_NAMES = [...ALL_AGENT_NAMES];
 var issuedOpenCodePlans = /* @__PURE__ */ new WeakMap();
 var NonCanonicalDataError = class extends Error {
@@ -4044,7 +4161,7 @@ function titleCaseSkillName(value) {
   }).join("-");
 }
 function homeDirFromContext(context2) {
-  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join4(context2.cwd, "home") : void 0);
+  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join5(context2.cwd, "home") : void 0);
 }
 function openCodeSkillTargets(context2) {
   const homeDir = homeDirFromContext(context2);
@@ -4065,8 +4182,24 @@ function openCodeSkillTargets(context2) {
       observed: installed ? "required global skill installed" : "required global skill missing"
     };
   });
+  const ownedTargets = getOpenCodeOwnedSkillEntries({
+    homeDir
+  }).map((skill) => {
+    const path = join5(skill.destinationPath, "SKILL.md");
+    const installed = existsSync10(path);
+    return {
+      kind: "skill",
+      path,
+      label: titleCaseSkillName(skill.name),
+      state: installed ? "installed" : "missing",
+      expected: "required global OpenCode skill",
+      observed: installed ? "thoth-owned global skill installed" : "thoth-owned global skill missing"
+    };
+  });
   const diagnostics = [];
-  if (requiredTargets.some((target) => target.state === "missing")) {
+  if ([...requiredTargets, ...ownedTargets].some(
+    (target) => target.state === "missing"
+  )) {
     diagnostics.push({
       severity: "important",
       message: "Required OpenCode global skills are missing; run install or sync to restore them.",
@@ -4074,7 +4207,7 @@ function openCodeSkillTargets(context2) {
     });
   }
   return {
-    targets: requiredTargets,
+    targets: [...requiredTargets, ...ownedTargets],
     diagnostics
   };
 }
@@ -4092,28 +4225,23 @@ function hasManagedPluginDrift(config) {
 }
 function liteConfigMarker(config) {
   const preset = typeof config?.preset === "string" ? config.preset : void 0;
-  const presets = config?.presets && typeof config.presets === "object" ? config.presets : {};
-  const openaiPreset = presets[OPENAI_PRESET] && typeof presets[OPENAI_PRESET] === "object" ? presets[OPENAI_PRESET] : {};
-  const legacyAgents = config?.agents && typeof config.agents === "object" ? config.agents : {};
+  const presets = configRecord(config?.presets);
+  const managedPreset = preset === OPENAI_PRESET || preset === APPLIED_MODELS_PRESET ? configRecord(presets[preset]) : {};
+  const legacyAgents = configRecord(config?.agents);
   const roles = ROLE_NAMES.filter(
-    (role) => role in openaiPreset || role in legacyAgents
+    (role) => role in managedPreset || role in legacyAgents
   );
   return `preset: ${preset ?? "none"}; observed roles: ${roles.join(", ")}`;
 }
-function hasSevenAgentPreset(config) {
-  if (!config || config.preset !== OPENAI_PRESET) return false;
-  if (!config.presets || typeof config.presets !== "object") return false;
-  const presets = config.presets;
-  const openaiPreset = presets[OPENAI_PRESET];
-  if (!openaiPreset || typeof openaiPreset !== "object") return false;
-  const roles = openaiPreset;
-  return ROLE_NAMES.every((role) => {
-    const value = roles[role];
-    return value !== null && typeof value === "object" && typeof value.model === "string";
-  });
+function hasManagedSevenAgentPreset(config) {
+  if (!config || config.preset !== OPENAI_PRESET && config.preset !== APPLIED_MODELS_PRESET) {
+    return false;
+  }
+  const presets = configRecord(config.presets);
+  return hasCompleteAgentRoster(presets[config.preset]);
 }
 function hasSelectedNamedPreset(config) {
-  if (!config || typeof config.preset !== "string" || config.preset.length === 0 || config.preset === OPENAI_PRESET || config.preset === "agents") {
+  if (!config || typeof config.preset !== "string" || config.preset.length === 0 || config.preset === OPENAI_PRESET || config.preset === APPLIED_MODELS_PRESET) {
     return false;
   }
   if (!config.presets || typeof config.presets !== "object" || Array.isArray(config.presets)) {
@@ -4125,13 +4253,7 @@ function hasSelectedNamedPreset(config) {
   return selectedPreset !== null && typeof selectedPreset === "object" && !Array.isArray(selectedPreset);
 }
 function hasLegacySevenAgentRoster(config) {
-  if (!config || config.preset !== "agents") return false;
-  if (!config.agents || typeof config.agents !== "object") return false;
-  const agents = config.agents;
-  return ROLE_NAMES.every((role) => {
-    const value = agents[role];
-    return value !== null && typeof value === "object" && typeof value.model === "string";
-  });
+  return config?.preset === APPLIED_MODELS_PRESET && !hasManagedSevenAgentPreset(config) && hasCompleteAgentRoster(config.agents);
 }
 var ACTIVE_PRESET_SELECTED_CODE = "opencode-active-preset-selected";
 function activePresetSelectedDiagnostic() {
@@ -4184,7 +4306,7 @@ function targetsForBlockingDiagnostic(diagnostic, status) {
   }
   if (code === "opencode-required-skills-missing") {
     return status.targets.filter(
-      (target) => target.expected === "required global OpenCode skill" && target.state !== "installed"
+      (target) => target.kind === "skill" && target.state !== "installed"
     );
   }
   return [
@@ -4269,8 +4391,8 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
       actions: openCodeActions
     };
   }
-  const mainExists = existsSync9(mainPath);
-  const liteExists = existsSync9(litePath);
+  const mainExists = existsSync10(mainPath);
+  const liteExists = existsSync10(litePath);
   const mainTarget = {
     ...targetForMainConfig(),
     observed: configPluginMarker(main.config)
@@ -4281,7 +4403,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
   };
   if (!mainExists || !hasExpectedPlugin(main.config)) {
     if (hasManagedPluginDrift(main.config)) {
-      const currentRoster = hasSevenAgentPreset(lite.config);
+      const currentRoster = hasManagedSevenAgentPreset(lite.config);
       const legacyRoster = hasLegacySevenAgentRoster(lite.config);
       const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
       const recognizedRoster = currentRoster || legacyRoster || selectedNamedPreset;
@@ -4347,7 +4469,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
       };
     }
     if (!mainExists && liteExists) {
-      const currentRoster = hasSevenAgentPreset(lite.config);
+      const currentRoster = hasManagedSevenAgentPreset(lite.config);
       const legacyRoster = hasLegacySevenAgentRoster(lite.config);
       const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
       if (!currentRoster && !legacyRoster && !selectedNamedPreset) {
@@ -4490,7 +4612,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
       actions: openCodeActions
     };
   }
-  if (!hasSevenAgentPreset(lite.config)) {
+  if (!hasManagedSevenAgentPreset(lite.config)) {
     const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
     return {
       harness: "opencode",
@@ -4520,7 +4642,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
     harness: "opencode",
     displayName: "OpenCode",
     state: requiredSkillsMissing ? "drift" : "installed",
-    summary: requiredSkillsMissing ? "OpenCode configuration is installed, but required external skills are missing." : "OpenCode managed thoth-agents configuration is installed.",
+    summary: requiredSkillsMissing ? "OpenCode configuration is installed, but required global skills are missing." : "OpenCode managed thoth-agents configuration is installed.",
     targets: [
       { ...mainTarget, state: "installed" },
       { ...liteTarget, state: "installed" },
@@ -4638,7 +4760,7 @@ function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
     action: "update"
   });
 }
-function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
+function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
   const generatedConfig = generateLiteConfig({
     agent: "opencode",
     hasTmux: false,
@@ -4646,6 +4768,10 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
     reset: false
   });
   const litePath = getExistingLiteConfigPath();
+  const ownedSkills = syncOpenCodeOwnedSkills({
+    dryRun: true,
+    homeDir: homeDirFromContext(context2)
+  });
   const { plan, status } = planFromItems(
     "opencode-sync-preview",
     "sync",
@@ -4655,7 +4781,7 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
       {
         title: "Ensure OpenCode plugin points at thoth-agents@latest",
         target: targetForMainConfig(),
-        state: getOpenCodeStatus(_context).state,
+        state: getOpenCodeStatus(context2).state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
         backup: defaultBackup(getExistingConfigPath())
       },
@@ -4671,6 +4797,15 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
       },
+      {
+        title: "Synchronize global thoth-owned OpenCode skills",
+        target: {
+          kind: "skill",
+          label: "Thoth-owned OpenCode skills",
+          expected: ownedSkills.skills.map(({ name }) => name).join(", ")
+        },
+        preview: JSON.stringify(ownedSkills, null, 2)
+      },
       {
         title: "Install required external skills",
         target: {
@@ -4688,9 +4823,9 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
         )
       }
     ],
-    _context
+    context2
   );
-  return issueOpenCodePlan(plan, status, _context, {
+  return issueOpenCodePlan(plan, status, context2, {
     kind: "fixed",
     action: "sync"
   });
@@ -4703,11 +4838,16 @@ function tuiInstallConfig() {
     reset: false
   };
 }
-function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
+function buildOpenCodeInstallPlan(context2 = { cwd: process.cwd() }) {
+  const ownedSkills = syncOpenCodeOwnedSkills({
+    dryRun: true,
+    homeDir: homeDirFromContext(context2)
+  });
   const generatedConfig = generateLiteConfig(tuiInstallConfig());
   const installPreview = {
     noTui: true,
     hasTmux: false,
+    ownedSkills: ownedSkills.skills.map((skill) => skill.name),
     requiredSkills: REQUIRED_SKILLS.map((skill) => skill.name),
     equivalentCommand: "install --agent=opencode --no-tui --tmux=no"
   };
@@ -4716,7 +4856,7 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
     "opencode-install-preview",
     "install",
     "Preview install",
-    "Preview OpenCode install with the required external skills.",
+    "Preview OpenCode install with the required global skills.",
     [
       {
         title: "Apply OpenCode TUI install options",
@@ -4724,15 +4864,15 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
           kind: "config",
           path: getExistingConfigPath(),
           label: "OpenCode install options",
-          state: getOpenCodeStatus(_context).state,
-          expected: "--no-tui --tmux=no plus required external skills"
+          state: getOpenCodeStatus(context2).state,
+          expected: "--no-tui --tmux=no plus required global skills"
         },
         preview: JSON.stringify(installPreview, null, 2)
       },
       {
         title: "Ensure OpenCode plugin points at thoth-agents@latest",
         target: targetForMainConfig(),
-        state: getOpenCodeStatus(_context).state,
+        state: getOpenCodeStatus(context2).state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
         backup: defaultBackup(getExistingConfigPath())
       },
@@ -4748,6 +4888,15 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
       },
+      {
+        title: "Synchronize global thoth-owned OpenCode skills",
+        target: {
+          kind: "skill",
+          label: "Thoth-owned OpenCode skills",
+          expected: ownedSkills.skills.map(({ name }) => name).join(", ")
+        },
+        preview: JSON.stringify(ownedSkills, null, 2)
+      },
       {
         title: "Install required external skills",
         target: {
@@ -4765,9 +4914,9 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
         )
       }
     ],
-    _context
+    context2
   );
-  return issueOpenCodePlan(plan, status, _context, {
+  return issueOpenCodePlan(plan, status, context2, {
     kind: "fixed",
     action: "install"
   });
@@ -4996,6 +5145,33 @@ function invalidModelPayloadReason(roles) {
   }
   return void 0;
 }
+function configRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function hasCompleteAgentRoster(value) {
+  const roles = configRecord(value);
+  return ROLE_NAMES.every(
+    (role) => typeof configRecord(roles[role]).model === "string"
+  );
+}
+function effectiveRolePreset(base, generated) {
+  const presets = configRecord(base.presets);
+  const generatedPresets = configRecord(generated.presets);
+  const defaults = configRecord(generatedPresets[OPENAI_PRESET]);
+  const selected = typeof base.preset === "string" ? configRecord(presets[base.preset]) : {};
+  const selectedIsMaterializedAgentsPreset = base.preset === APPLIED_MODELS_PRESET && hasCompleteAgentRoster(selected);
+  const rootAgents = configRecord(base.agents);
+  return Object.fromEntries(
+    ROLE_NAMES.map((role) => [
+      role,
+      {
+        ...selectedIsMaterializedAgentsPreset ? {} : configRecord(defaults[role]),
+        ...configRecord(selected[role]),
+        ...configRecord(rootAgents[role])
+      }
+    ])
+  );
+}
 function applyModelPlan(roles) {
   const roleModels = new Map(
     roles.map((role) => [
@@ -5006,26 +5182,33 @@ function applyModelPlan(roles) {
   ensureConfigDir();
   const targetPath = getExistingLiteConfigPath();
   const parsed = parseConfig(targetPath);
-  const base = parsed.config ?? generateLiteConfig({
+  const generated = generateLiteConfig({
     agent: "opencode",
     hasTmux: false,
     dryRun: false,
     reset: false
   });
-  const agents = base.agents && typeof base.agents === "object" ? { ...base.agents } : {};
+  const base = parsed.config ?? generated;
+  const agents = { ...configRecord(base.agents) };
+  const appliedPreset = effectiveRolePreset(base, generated);
   const statePath = getOpenCodeManagedModelStatePath();
   const state = readManagedModelState(statePath, 1);
   const configuredEfforts = { ...state.configuredEfforts ?? {} };
   const warnings = [];
   for (const [role, override] of roleModels) {
     const current = {
-      ...agents[role] ?? {}
+      ...configRecord(agents[role])
+    };
+    const presetRole = {
+      ...configRecord(appliedPreset[role])
     };
     const currentVariant = typeof current.variant === "string" ? current.variant : void 0;
     const trackedVariant = configuredEfforts[role];
     const userOwnsVariant = override.variant === null && currentVariant !== void 0 && (trackedVariant === void 0 || currentVariant !== trackedVariant);
     current.model = override.model;
+    presetRole.model = override.model;
     if (userOwnsVariant) {
+      presetRole.variant = currentVariant;
       delete configuredEfforts[role];
       warnings.push({
         severity: "important",
@@ -5034,14 +5217,22 @@ function applyModelPlan(roles) {
       });
     } else if (override.variant === null) {
       delete current.variant;
+      delete presetRole.variant;
       delete configuredEfforts[role];
     } else {
       current.variant = override.variant;
+      presetRole.variant = override.variant;
       configuredEfforts[role] = override.variant;
     }
     agents[role] = current;
+    appliedPreset[role] = presetRole;
   }
   base.agents = agents;
+  base.presets = {
+    ...configRecord(base.presets),
+    [APPLIED_MODELS_PRESET]: appliedPreset
+  };
+  base.preset = APPLIED_MODELS_PRESET;
   writeConfig(targetPath, base);
   writeTextWithBackup(
     statePath,
@@ -5062,7 +5253,7 @@ function applyModelPlan(roles) {
         observed: "agents role overrides updated"
       }
     ],
-    backups: existsSync9(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
+    backups: existsSync10(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
     warnings,
     disclaimers: defaultDisclaimers()
   };
@@ -5090,6 +5281,22 @@ function applyRequiredSkills(context2) {
   }
   return { success: warnings.length === 0, warnings };
 }
+function applyOwnedSkills(context2) {
+  const result = syncOpenCodeOwnedSkills({
+    homeDir: homeDirFromContext(context2)
+  });
+  if (result.success) return { success: true, warnings: [] };
+  return {
+    success: false,
+    warnings: [
+      {
+        severity: "critical",
+        code: "opencode-owned-skills-sync-failed",
+        message: `Failed to synchronize thoth-owned OpenCode skills: ${result.error ?? "unknown error"}.`
+      }
+    ]
+  };
+}
 function applyOpenCodePlan(plan) {
   const rejection = validateApplyPlan(plan);
   if (rejection) return rejection;
@@ -5145,7 +5352,7 @@ function applyOpenCodePlan(plan) {
     ...targetForMainConfig("installed"),
     observed: `plugin includes ${EXPECTED_PLUGIN}`
   });
-  if (existsSync9(`${mainConfigResult.configPath}.bak`)) {
+  if (existsSync10(`${mainConfigResult.configPath}.bak`)) {
     backups.push({
       path: `${mainConfigResult.configPath}.bak`,
       label: "OpenCode config backup"
@@ -5171,7 +5378,7 @@ function applyOpenCodePlan(plan) {
       ...targetForLiteConfig("installed"),
       observed: "seven-role roster written"
     });
-    if (existsSync9(`${liteResult.configPath}.bak`)) {
+    if (existsSync10(`${liteResult.configPath}.bak`)) {
       backups.push({
         path: `${liteResult.configPath}.bak`,
         label: "thoth-agents config backup"
@@ -5179,6 +5386,26 @@ function applyOpenCodePlan(plan) {
     }
   }
   if (issued.payload.action === "install" || issued.payload.action === "sync") {
+    const ownedSkills = applyOwnedSkills(issued.context);
+    warnings.push(...ownedSkills.warnings);
+    changedTargets.push({
+      kind: "skill",
+      label: "Thoth-owned OpenCode skills",
+      state: ownedSkills.success ? "installed" : "drift",
+      observed: ownedSkills.success ? "thoth-owned global skills synchronized" : "thoth-owned global skill synchronization failed"
+    });
+    if (!ownedSkills.success) {
+      return {
+        harness: "opencode",
+        action: plan.action,
+        applied: false,
+        summary: "OpenCode configuration was written, but thoth-owned skills failed to synchronize.",
+        changedTargets,
+        backups,
+        warnings,
+        disclaimers: defaultDisclaimers()
+      };
+    }
     const requiredSkills = applyRequiredSkills(issued.context);
     warnings.push(...requiredSkills.warnings);
     changedTargets.push({
@@ -5235,15 +5462,15 @@ import { execFileSync } from "child_process";
 
 // src/cli/model-catalog/cache.ts
 import {
-  existsSync as existsSync10,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync4,
   readFileSync as readFileSync6,
-  renameSync as renameSync2,
+  renameSync as renameSync3,
   unlinkSync,
   writeFileSync as writeFileSync3
 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname5, posix, win32 } from "path";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname6, posix, win32 } from "path";
 import { z as z2 } from "zod";
 var modelCatalogSourceSchema = z2.enum(["remote", "lkg", "manual"]);
 var cachedModelOptionSchema = z2.object({
@@ -5263,7 +5490,7 @@ var modelsDevCacheSchema = z2.object({
 function resolveModelsDevCachePath(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const home = options.homeDir ?? homedir3();
+  const home = options.homeDir ?? homedir4();
   if (platform === "win32") {
     const path = win32;
     const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path.join(home, "AppData", "Local");
@@ -5273,7 +5500,7 @@ function resolveModelsDevCachePath(options = {}) {
   return posix.join(base, "thoth-agents", "models-dev-v1.json");
 }
 function readModelsDevCache(cachePath) {
-  if (!existsSync10(cachePath)) return void 0;
+  if (!existsSync11(cachePath)) return void 0;
   try {
     const input = JSON.parse(readFileSync6(cachePath, "utf8"));
     const parsed = modelsDevCacheSchema.safeParse(input);
@@ -5287,7 +5514,7 @@ function writeModelsDevCacheAtomic(cachePath, cache) {
   if (!validated.success) {
     throw new Error(`Invalid models.dev cache: ${validated.error.message}`);
   }
-  mkdirSync3(dirname5(cachePath), { recursive: true });
+  mkdirSync4(dirname6(cachePath), { recursive: true });
   const temporaryPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
   try {
     writeFileSync3(
@@ -5295,9 +5522,9 @@ function writeModelsDevCacheAtomic(cachePath, cache) {
       `${JSON.stringify(validated.data, null, 2)}
 `
     );
-    renameSync2(temporaryPath, cachePath);
+    renameSync3(temporaryPath, cachePath);
   } catch (error) {
-    if (existsSync10(temporaryPath)) unlinkSync(temporaryPath);
+    if (existsSync11(temporaryPath)) unlinkSync(temporaryPath);
     throw error;
   }
 }
@@ -5610,7 +5837,7 @@ async function getModelOptions(harness) {
 }
 
 // src/cli/tui/operations.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 var context = { cwd: process.cwd() };
 var codexContext = { cwd: process.cwd() };
 var claudeCodeContext = {
@@ -5652,7 +5879,7 @@ function getCodexModelRoles(source = codexContext) {
       const item = plan.items.find(
         (candidate) => candidate.action === "write-role-toml" && candidate.role === role
       );
-      const content = item && existsSync11(item.targetPath) ? readFileSync7(item.targetPath, "utf8") : item?.content;
+      const content = item && existsSync12(item.targetPath) ? readFileSync7(item.targetPath, "utf8") : item?.content;
       const effort = content ? parseRoleTomlEffort(content) : void 0;
       return {
         role,
@@ -5688,9 +5915,10 @@ function getOpenCodeModelRoles() {
   const activePreset = selectedPreset && typeof selectedPreset === "object" && !Array.isArray(selectedPreset) ? selectedPreset : void 0;
   return ALL_AGENT_NAMES.map((role) => {
     const defaultModel = getDefaultOpenCodeModel(role);
-    const model = readRoleField(agents, role, "model") ?? readRoleField(activePreset, role, "model") ?? defaultModel;
+    const configuredModel = readRoleField(agents, role, "model") ?? readRoleField(activePreset, role, "model");
+    const model = configuredModel ?? defaultModel;
     const configuredVariant = readRoleField(agents, role, "variant") ?? readRoleField(activePreset, role, "variant");
-    const variant = configuredVariant ?? (model === defaultModel ? getDefaultOpenCodeVariant(role) : void 0);
+    const variant = configuredVariant ?? (configuredModel === void 0 ? getDefaultOpenCodeVariant(role) : void 0);
     return {
       role,
       model,
@@ -5774,6 +6002,7 @@ export {
   buildClaudeCodeSetupPlan,
   applyClaudeCodeSetup,
   formatClaudeCodeSetupPlan,
+  syncOpenCodeOwnedSkills,
   getNpxCommand,
   REQUIRED_SKILLS,
   getRequiredSkillInstallCommand,