thoth-agents 0.11.0 → 0.13.0

package/dist/{chunk-I5TXGNSG.js → chunk-5MYXVRZZ.js}

@@ -1,8 +1,9 @@
 import {
   CONTEXT7_MCP_URL,
   GREP_APP_MCP_URL,
-  exa
-} from "./chunk-62L3ORXN.js";
+  exa,
+  spawn
+} from "./chunk-MIDGZE34.js";
 import {
   PI_EFFORT_VALUES,
   PI_MANAGED_OWNER,
@@ -16,7 +17,7 @@ import {
   savePiModelConfig,
   syncPiSpecialists,
   writePiManagedText
-} from "./chunk-5WPP6IY7.js";
+} from "./chunk-VVYAQTYE.js";
 import {
   ALL_AGENT_NAMES,
   CLAUDE_CODE_PROMPT_DIALECT,
@@ -25,30 +26,38 @@ import {
   CONFIRMED_OPENAI_SUBAGENT_PRESET,
   DEFAULT_MODELS,
   LEGACY_OPENAI_PRESET,
+  MODEL_MAPPINGS,
   PI_SPECIALIST_ROLES,
   SUBAGENT_NAMES,
+  activeOpenCodeProfile,
   claudeCodeSubagentType,
+  effectiveOpenCodeProfile,
   ensureConfigDir,
   findPackageRoot,
   generateLiteConfig,
   getAgentOverride,
   getAgentPackContract,
+  getConfigDir,
   getDefaultOpenCodeModel,
   getDefaultOpenCodeVariant,
   getExistingConfigPath,
   getExistingLiteConfigPath,
   getOpenCodeManagedModelStatePath,
   getPrimaryModelId,
+  isManagedOpenCodePlugin,
   isPiSpecialistRole,
   isValidPackageVersion,
+  openCodeProfileStore,
   parseConfig,
   piSpecialistName,
+  pluginEntries,
   renderAgentRoutingDescription,
   resolveExecutingPackageVersion,
   updateOpenCodeMainConfig,
+  withoutLegacyPresets,
   writeConfig,
   writeLiteConfig
-} from "./chunk-DNPKVFOB.js";
+} from "./chunk-YCWGTDFE.js";
 
 // src/cli/model-effort.ts
 function normalizeEffortSelection(value) {
@@ -4387,47 +4396,35 @@ function recordCompletedInstall(options) {
 
 // src/cli/thoth-mem-install.ts
 import { spawnSync as spawnSync3 } from "child_process";
-
-// src/cli/npx-command.ts
-function getNpxCommand(args, options = {}) {
-  if ((options.platform ?? process.platform) !== "win32") {
-    return { command: "npx", args: [...args] };
-  }
-  return {
-    command: options.commandShell ?? process.env.ComSpec ?? "cmd.exe",
-    args: ["/d", "/s", "/c", ["npx", ...args].join(" ")]
-  };
-}
-
-// src/cli/thoth-mem-install.ts
+var THOTH_MEM_PACKAGE_SPEC = "thoth-mem@>=0.7.0";
 var THOTH_MEM_SETUP_TIMEOUT_MS = 12e4;
 var STATUS_EXIT_CODE = {
+  planned: 0,
   complete: 0,
-  failed: 1,
-  partial: 2,
-  requires_user_action: 3
+  unsupported: 1,
+  "requires-user-action": 1
 };
-var SETUP_STATUSES = new Set(
-  Object.keys(STATUS_EXIT_CODE)
-);
-var STEP_OUTCOMES = /* @__PURE__ */ new Set([
-  "planned",
-  "skipped",
-  "confirmed",
-  "failed",
-  "unavailable"
-]);
 function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
-function isSetupStep(value) {
-  return isRecord6(value) && typeof value.name === "string" && value.name.length > 0 && typeof value.outcome === "string" && STEP_OUTCOMES.has(value.outcome);
-}
 function isProviderSetupResult(value, expectedHarness) {
-  return isRecord6(value) && typeof value.status === "string" && SETUP_STATUSES.has(value.status) && typeof value.changed === "boolean" && value.harness === expectedHarness && value.scope === "global" && typeof value.target === "string" && value.target.length > 0 && Array.isArray(value.steps) && value.steps.every(isSetupStep) && isStringArray(value.diagnostics) && isStringArray(value.manual_actions) && (value.receipt === null || typeof value.receipt === "string");
+  if (!isRecord6(value) || typeof value.status !== "string" || !Object.hasOwn(STATUS_EXIT_CODE, value.status) || typeof value.changed !== "boolean" || typeof value.recovered !== "boolean" || value.host !== void 0 && value.host !== expectedHarness || !isStringArray(value.actions) || !isStringArray(value.warnings) || !(value.receiptPath === null || typeof value.receiptPath === "string") || value.diagnostics !== void 0 && !isStringArray(value.diagnostics) || value.restartRequired !== void 0 && typeof value.restartRequired !== "boolean") {
+    return false;
+  }
+  if (expectedHarness === "opencode") {
+    return typeof value.plugin === "string" && typeof value.opencodeVersion === "string" && typeof value.configPath === "string" && typeof value.skillPath === "string" && typeof value.providerConfigPath === "string";
+  }
+  if (value.host !== expectedHarness || typeof value.source !== "string" || typeof value.version !== "string" || !isRecord6(value.verification)) {
+    return false;
+  }
+  const verification = value.verification;
+  if (expectedHarness === "pi") {
+    return typeof value.piVersion === "string" && typeof verification.package === "boolean" && typeof verification.source === "boolean" && typeof verification.manifest === "boolean";
+  }
+  return (value.strategy === "plugin_manager" || value.strategy === "unsupported") && isStringArray(value.diagnostics) && typeof value.restartRequired === "boolean" && typeof verification.marketplace === "boolean" && typeof verification.plugin === "boolean" && typeof verification.enabled === "boolean" && (verification.modelUse === void 0 || verification.modelUse === false);
 }
 function parseProviderSetupResult(stdout, expectedHarness) {
   let value;
@@ -4438,9 +4435,10 @@ function parseProviderSetupResult(stdout, expectedHarness) {
   }
   return isProviderSetupResult(value, expectedHarness) ? value : void 0;
 }
-function defaultCommandExecutor3(command, args, options) {
+function executeThothMemCommand(command, args, options) {
   const result = spawnSync3(command, [...args], {
     windowsHide: true,
+    windowsVerbatimArguments: process.platform === "win32",
     cwd: options.cwd,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -4466,9 +4464,9 @@ function invalidResult(harness, command, args, exitCode, error) {
     status: "invalid",
     changed: false,
     harness,
-    steps: [],
+    actions: [],
+    warnings: [],
     diagnostics: [],
-    manualActions: [],
     receipt: null,
     command,
     args,
@@ -4477,24 +4475,32 @@ function invalidResult(harness, command, args, exitCode, error) {
   };
 }
 function getThothMemSetupCommand(harness, dryRun, options = {}) {
-  return getNpxCommand(
-    [
-      "-y",
-      "thoth-mem@latest",
-      "setup",
-      harness,
-      ...dryRun ? ["--plan"] : [],
-      "--json"
-    ],
-    options
-  );
+  const args = [
+    "-y",
+    THOTH_MEM_PACKAGE_SPEC,
+    "setup",
+    harness,
+    ...dryRun ? ["--plan"] : [],
+    "--json"
+  ];
+  if ((options.platform ?? process.platform) !== "win32") {
+    return { command: "npx", args };
+  }
+  return {
+    command: options.commandShell ?? process.env.ComSpec ?? "cmd.exe",
+    // Node must not escape this cmd command line: quoted > is a literal,
+    // not redirection, and npx must receive the selector without quote characters.
+    args: [
+      `/d /s /c "npx ${args.map((arg) => arg === THOTH_MEM_PACKAGE_SPEC ? `"${arg}"` : arg).join(" ")}"`
+    ]
+  };
 }
 function runThothMemSetup(options) {
   const { command, args } = getThothMemSetupCommand(
     options.harness,
     options.dryRun ?? false
   );
-  const executor = options.commandExecutor ?? defaultCommandExecutor3;
+  const executor = options.commandExecutor ?? executeThothMemCommand;
   let commandResult;
   try {
     commandResult = executor(command, args, {
@@ -4531,34 +4537,37 @@ function runThothMemSetup(options) {
       command,
       args,
       commandResult.exitCode,
-      stderr ? `thoth-mem returned invalid JSON evidence: ${stderr.slice(0, 2e3)}` : "thoth-mem returned invalid JSON evidence."
+      stderr ? `thoth-mem setup failed or returned invalid JSON evidence: ${stderr.slice(0, 2e3)}` : "thoth-mem returned invalid JSON evidence."
     );
   }
   const expectedExitCode = STATUS_EXIT_CODE[provider.status];
-  const evidenceValid = commandResult.exitCode === expectedExitCode;
+  const expectedStatus = options.dryRun ? "planned" : "complete";
+  const exitConsistent = commandResult.exitCode === expectedExitCode;
+  const modeConsistent = expectedExitCode !== 0 || provider.status === expectedStatus;
+  const evidenceValid = exitConsistent && modeConsistent;
   return {
-    success: evidenceValid && provider.status === "complete",
+    success: evidenceValid && provider.status === expectedStatus,
     evidenceValid,
     status: provider.status,
     changed: provider.changed,
-    harness: provider.harness,
-    target: provider.target,
-    steps: provider.steps,
-    diagnostics: provider.diagnostics,
-    manualActions: provider.manual_actions,
-    receipt: provider.receipt,
+    harness: options.harness,
+    actions: provider.actions,
+    warnings: provider.warnings,
+    diagnostics: provider.diagnostics ?? [],
+    restartRequired: provider.restartRequired,
+    receipt: provider.receiptPath,
     command,
     args,
     exitCode: commandResult.exitCode,
     ...!evidenceValid ? {
-      error: `thoth-mem exit code ${String(commandResult.exitCode)} contradicts reported status ${provider.status} (expected ${expectedExitCode}).`
+      error: !exitConsistent ? `thoth-mem exit code ${String(commandResult.exitCode)} contradicts reported status ${provider.status} (expected ${expectedExitCode}).` : `thoth-mem reported ${provider.status}; expected ${expectedStatus} for this setup mode.`
     } : {}
   };
 }
 
 // src/cli/install-completion.ts
-function isConsistentProviderSuccess(result, harness) {
-  return result.success && result.evidenceValid && result.status === "complete" && result.exitCode === 0 && result.harness === harness;
+function isConsistentProviderSuccess(result, harness, dryRun) {
+  return result.success && result.evidenceValid && result.status === (dryRun ? "planned" : "complete") && result.exitCode === 0 && result.harness === harness;
 }
 function recordHarnessInstallCompletion(options) {
   const ledgerPath = getInstallLedgerPath(options.ledgerOptions);
@@ -4603,12 +4612,12 @@ function finalizeHarnessInstall(options) {
     dryRun: options.dryRun,
     cwd: options.cwd
   });
-  if (!isConsistentProviderSuccess(provider, options.harness)) {
+  if (!isConsistentProviderSuccess(provider, options.harness, options.dryRun)) {
     return {
       success: false,
       provider,
       ledger: { status: "not-attempted", path: ledgerPath },
-      error: provider.error ?? "thoth-mem setup did not return consistent complete evidence."
+      error: provider.error ?? "thoth-mem setup did not return consistent setup evidence."
     };
   }
   const completion = recordHarnessInstallCompletion({
@@ -4629,6 +4638,19 @@ import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join6 } from "path";
+
+// src/cli/npx-command.ts
+function getNpxCommand(args, options = {}) {
+  if ((options.platform ?? process.platform) !== "win32") {
+    return { command: "npx", args: [...args] };
+  }
+  return {
+    command: options.commandShell ?? process.env.ComSpec ?? "cmd.exe",
+    args: ["/d", "/s", "/c", ["npx", ...args].join(" ")]
+  };
+}
+
+// src/cli/skills.ts
 var SKILLS_CLI_AGENT = {
   opencode: "opencode",
   codex: "codex",
@@ -4773,12 +4795,26 @@ function getInstallCompletionEvidence(completion, options) {
       code: `${options.codePrefix}-provider-diagnostic`,
       message
     })),
-    ...completion.provider.manualActions.map((message) => ({
+    ...completion.provider.warnings.map((message) => ({
       severity: "important",
-      code: `${options.codePrefix}-provider-manual-action`,
+      code: `${options.codePrefix}-provider-warning`,
       message
     }))
   ];
+  for (const action of completion.provider.actions) {
+    targets.push({
+      kind: "surface",
+      label: "thoth-mem action",
+      observed: action
+    });
+  }
+  if (completion.provider.restartRequired) {
+    warnings.push({
+      severity: "important",
+      code: `${options.codePrefix}-provider-restart`,
+      message: "thoth-mem: restart required"
+    });
+  }
   if (completion.provider.receipt) {
     targets.push({
       kind: "file",
@@ -6386,19 +6422,18 @@ function resolveOpenCodeEffort(input) {
 }
 
 // src/cli/owned-skills.ts
+import { randomBytes } from "crypto";
 import {
-  cpSync,
   existsSync as existsSync9,
   lstatSync as lstatSync5,
   mkdirSync as mkdirSync4,
-  mkdtempSync,
   readFileSync as readFileSync8,
+  realpathSync as realpathSync2,
   renameSync as renameSync3,
-  rmSync as rmSync4,
   statSync
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname6, join as join7 } from "path";
+import { dirname as dirname6, join as join7, resolve as resolve5, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/harness/core/owned-skills.ts
@@ -6491,7 +6526,7 @@ function getOpenCodeOwnedSkillEntries(options = {}) {
   return THOTH_OWNED_SKILL_NAMES.map((name) => ({
     name,
     sourcePath: join7(packageRoot, "skills", name),
-    destinationPath: join7(homeDir, ".config", "opencode", "skills", name)
+    destinationPath: join7(getConfigDir(homeDir), "skills", name)
   }));
 }
 function getPiOwnedSkillEntries(options) {
@@ -6513,56 +6548,126 @@ function validateCanonicalSkill(entry) {
     throw new Error(`Canonical owned skill contract is missing: ${entry.name}`);
   }
 }
-function installOwnedSkills(skills) {
-  const firstSkill = skills[0];
-  if (!firstSkill) return;
-  const globalRoot = dirname6(firstSkill.destinationPath);
-  mkdirSync4(globalRoot, { recursive: true });
-  const transactionRoot = mkdtempSync(join7(globalRoot, ".thoth-agents-owned-"));
-  const stagedRoot = join7(transactionRoot, "staged");
-  const backupRoot = join7(transactionRoot, "backup");
-  mkdirSync4(stagedRoot, { recursive: true });
-  mkdirSync4(backupRoot, { recursive: true });
-  try {
-    for (const skill of skills) {
-      cpSync(skill.sourcePath, join7(stagedRoot, skill.name), {
-        recursive: true,
-        force: true
-      });
+function getLegacyOpenCodeSkillBackupRoot(homeDir = homedir4()) {
+  return resolve5(
+    process.env.XDG_DATA_HOME || join7(homeDir, ".local", "share"),
+    "thoth-agents",
+    ".opencode-legacy-skills"
+  );
+}
+function inspectLegacyOpenCodeSkills(homeDir = homedir4()) {
+  const seen = /* @__PURE__ */ new Set();
+  const copies = [];
+  for (const [label, root] of [
+    ["resolved", getConfigDir(homeDir)],
+    ["legacy", join7(homeDir, ".config", "opencode")]
+  ]) {
+    for (const directory of ["skills", "skill"]) {
+      for (const name of THOTH_OWNED_SKILL_NAMES) {
+        const sourcePath = join7(root, directory, name);
+        if (!existsSync9(sourcePath)) continue;
+        const real = realpathSync2(sourcePath);
+        if (seen.has(real)) continue;
+        seen.add(real);
+        copies.push({ name, sourcePath, label: `${label}-${directory}` });
+      }
     }
-    for (const skill of skills) {
-      const stagedPath = join7(stagedRoot, skill.name);
-      const backupPath = join7(backupRoot, skill.name);
-      const hadExistingDestination = existsSync9(skill.destinationPath);
-      if (hadExistingDestination) {
-        renameSync3(skill.destinationPath, backupPath);
+  }
+  return copies;
+}
+function planOrMoveLegacySkills(options) {
+  const backupRoot = getLegacyOpenCodeSkillBackupRoot(options.homeDir);
+  const copies = inspectLegacyOpenCodeSkills(options.homeDir);
+  const notices = [];
+  const legacyMoves = [];
+  if (!copies.length) return { backupRoot, notices, legacyMoves };
+  const confirmed = options.moveLegacyOpenCodeSkills && !options.dryRun;
+  let run = join7(backupRoot, "<new-run>");
+  if (confirmed) {
+    try {
+      if (!resolve5(backupRoot).split(sep2).includes(".opencode-legacy-skills"))
+        throw new Error(
+          "Backup path is missing the required hidden .opencode-legacy-skills segment"
+        );
+      mkdirSync4(backupRoot, { recursive: true });
+      let created = false;
+      for (let attempt = 0; attempt < 10; attempt++) {
+        run = join7(
+          backupRoot,
+          `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${randomBytes(8).toString("hex")}`
+        );
+        try {
+          mkdirSync4(run, { mode: 448 });
+          created = true;
+          break;
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+        }
       }
+      if (!created)
+        throw new Error("Unable to create an exclusive backup run directory");
+    } catch (error) {
+      notices.push(`Legacy skill move refused: ${String(error)}`);
+      notices.push(
+        ...copies.map(
+          ({ sourcePath }) => legacyOpenCodeSkillNotice(sourcePath)
+        )
+      );
+      return { backupRoot, notices, legacyMoves };
+    }
+  }
+  for (const copy of copies) {
+    const destinationPath = join7(run, copy.label, copy.name);
+    const move = {
+      sourcePath: copy.sourcePath,
+      destinationPath,
+      status: "planned"
+    };
+    legacyMoves.push(move);
+    if (!confirmed) {
+      notices.push(legacyOpenCodeSkillNotice(copy.sourcePath));
+      notices.push(
+        `Planned move: ${copy.sourcePath} -> ${destinationPath} (backup root: ${backupRoot})`
+      );
+      continue;
+    }
+    try {
+      mkdirSync4(dirname6(destinationPath), { recursive: true });
       try {
-        renameSync3(stagedPath, skill.destinationPath);
+        lstatSync5(destinationPath);
+        throw new Error(
+          `Backup destination already exists: ${destinationPath}`
+        );
       } catch (error) {
-        if (existsSync9(skill.destinationPath)) {
-          rmSync4(skill.destinationPath, { recursive: true, force: true });
-        }
-        if (hadExistingDestination && existsSync9(backupPath)) {
-          renameSync3(backupPath, skill.destinationPath);
-        }
-        throw error;
-      }
-      if (existsSync9(backupPath)) {
-        rmSync4(backupPath, { recursive: true, force: true });
+        if (error.code !== "ENOENT") throw error;
       }
+      renameSync3(copy.sourcePath, destinationPath);
+      move.status = "moved";
+      notices.push(
+        `Moved legacy OpenCode skill: ${copy.sourcePath} -> ${destinationPath} (backup: ${run})`
+      );
+    } catch (error) {
+      move.status = "failed";
+      notices.push(
+        `Legacy skill move failed; original left intact: ${copy.sourcePath}: ${String(error)}. ${legacyOpenCodeSkillNotice(copy.sourcePath)}`
+      );
     }
-  } finally {
-    rmSync4(transactionRoot, { recursive: true, force: true });
   }
+  return { backupRoot, notices, legacyMoves };
+}
+function legacyOpenCodeSkillNotice(path) {
+  return `Warning: legacy OpenCode skill copies shadow the packaged skills: ${path}. Confirm the backup move interactively or pass --move-legacy-opencode-skills to install/update.`;
 }
 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 };
+    return {
+      success: true,
+      status: options.dryRun ? "planned" : "installed",
+      skills,
+      ...planOrMoveLegacySkills(options)
+    };
   } catch (error) {
     return {
       success: false,
@@ -6604,12 +6709,184 @@ function inspectPiPackageSkills(options) {
   }
 }
 
+// src/cli/system.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import { statSync as statSync2 } from "fs";
+var cachedOpenCodePath = null;
+var OPENCODE_PROBE_TIMEOUT_MS = 1500;
+function quoteWindowsShellCommand(command) {
+  if (!/[\s&()^<>"|]/.test(command)) {
+    return command;
+  }
+  return `"${command.replace(/"/g, '\\"')}"`;
+}
+function getOpenCodeVersionInvocation(opencodePath, platform = process.platform) {
+  const options = {
+    stdout: "pipe",
+    stderr: "pipe"
+  };
+  if (platform === "win32") {
+    return {
+      command: [`${quoteWindowsShellCommand(opencodePath)} --version`],
+      options: { ...options, shell: true }
+    };
+  }
+  return { command: [opencodePath, "--version"], options };
+}
+function getOpenCodePaths() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return [
+    // PATH (try this first)
+    "opencode",
+    // User local installations (Linux & macOS)
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    // System-wide installations
+    "/usr/local/bin/opencode",
+    "/opt/opencode/bin/opencode",
+    "/usr/bin/opencode",
+    "/bin/opencode",
+    // macOS specific
+    "/Applications/OpenCode.app/Contents/MacOS/opencode",
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    // Homebrew (macOS & Linux)
+    "/opt/homebrew/bin/opencode",
+    "/home/linuxbrew/.linuxbrew/bin/opencode",
+    `${home}/homebrew/bin/opencode`,
+    // macOS user Library
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    // Snap (Linux)
+    "/snap/bin/opencode",
+    "/var/snap/opencode/current/bin/opencode",
+    // Flatpak (Linux)
+    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    // Nix (Linux/macOS)
+    "/nix/store/opencode/bin/opencode",
+    `${home}/.nix-profile/bin/opencode`,
+    "/run/current-system/sw/bin/opencode",
+    // Cargo (Rust toolchain)
+    `${home}/.cargo/bin/opencode`,
+    // npm/npx global
+    `${home}/.npm-global/bin/opencode`,
+    "/usr/local/lib/node_modules/opencode/bin/opencode",
+    // Yarn global
+    `${home}/.yarn/bin/opencode`,
+    // PNPM
+    `${home}/.pnpm-global/bin/opencode`
+  ];
+}
+function resolveOpenCodePath() {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode") continue;
+    try {
+      const stat = statSync2(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {
+    }
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    try {
+      const invocation = getOpenCodeVersionInvocation(opencodePath);
+      const proc = spawn(invocation.command, {
+        ...invocation.options,
+        windowsHide: true
+      });
+      let timer;
+      const timedOut = /* @__PURE__ */ Symbol("timeout");
+      try {
+        const outcome = await Promise.race([
+          proc.exited.then(() => proc.exitCode),
+          new Promise((resolve11) => {
+            timer = setTimeout(
+              () => resolve11(timedOut),
+              OPENCODE_PROBE_TIMEOUT_MS
+            );
+          })
+        ]);
+        if (outcome === timedOut) {
+          proc.kill();
+          continue;
+        }
+        if (outcome === 0) {
+          cachedOpenCodePath = opencodePath;
+          return true;
+        }
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+var OPENCODE_VERSION_REQUIREMENT = "OpenCode 2.2.6 or later is required; install or upgrade OpenCode before applying configuration.";
+function isSupportedOpenCodeVersion(output) {
+  const match = /^(?:opencode\s+)?v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/iu.exec(
+    output?.trim() ?? ""
+  );
+  if (!match) return false;
+  const [, major, minor, patch] = match;
+  return Number(major) > 2 || Number(major) === 2 && (Number(minor) > 2 || Number(minor) === 2 && Number(patch) >= 6);
+}
+function getOpenCodeVersionSync() {
+  try {
+    const invocation = getOpenCodeVersionInvocation(resolveOpenCodePath());
+    const [command, ...args] = invocation.command;
+    if (!command) return null;
+    const result = spawnSync5(command, args, {
+      shell: invocation.options.shell,
+      windowsHide: true,
+      encoding: "utf8",
+      timeout: OPENCODE_PROBE_TIMEOUT_MS
+    });
+    return result.status === 0 ? result.stdout.trim() : null;
+  } catch {
+    return null;
+  }
+}
+async function getOpenCodeVersion() {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const invocation = getOpenCodeVersionInvocation(opencodePath);
+    const proc = spawn(invocation.command, {
+      ...invocation.options,
+      windowsHide: true
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return output.trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function getOpenCodePath() {
+  const path = resolveOpenCodePath();
+  return path === "opencode" ? null : path;
+}
+
 // src/cli/operations/opencode.ts
 var PACKAGE_NAME = "thoth-agents";
 var EXECUTING_PACKAGE_VERSION = resolveExecutingPackageVersion();
 var EXPECTED_PLUGIN = EXECUTING_PACKAGE_VERSION.ok ? `${PACKAGE_NAME}@${EXECUTING_PACKAGE_VERSION.version}` : null;
-var OPENAI_PRESET = "openai";
-var APPLIED_MODELS_PRESET = "agents";
+var OPENAI_PROFILE = "openai";
+var APPLIED_MODELS_PROFILE = "agents";
 var ROLE_NAMES = [...ALL_AGENT_NAMES];
 var issuedOpenCodePlans = /* @__PURE__ */ new WeakMap();
 var NonCanonicalDataError = class extends Error {
@@ -6813,7 +7090,7 @@ var opencodeOperationAdapter = {
   id: "opencode",
   displayName: "OpenCode",
   available: true,
-  description: "OpenCode plugin and configuration surfaces.",
+  description: "OpenCode 2.2.6 or later: pinned plugin and configuration surfaces.",
   actions: openCodeActions
 };
 function targetForMainConfig(state) {
@@ -6822,7 +7099,7 @@ function targetForMainConfig(state) {
     path: getExistingConfigPath(),
     label: "OpenCode config",
     ...state ? { state } : {},
-    expected: EXPECTED_PLUGIN ? `plugin includes ${EXPECTED_PLUGIN}` : "plugin version unavailable"
+    expected: EXPECTED_PLUGIN ? `plugins includes ${EXPECTED_PLUGIN}` : "plugins version unavailable"
   };
 }
 function targetForLiteConfig(state) {
@@ -6831,7 +7108,26 @@ function targetForLiteConfig(state) {
     path: getExistingLiteConfigPath(),
     label: "thoth-agents config",
     ...state ? { state } : {},
-    expected: `six-role ${OPENAI_PRESET} roster`
+    expected: `six-role ${OPENAI_PROFILE} roster`
+  };
+}
+function targetForProfiles() {
+  return {
+    kind: "config",
+    path: openCodeProfileStore().paths.global,
+    label: "OpenCode model profiles",
+    expected: "complete active model profile"
+  };
+}
+function shippedProfilePlanItem() {
+  return {
+    title: "Sync built-in OpenAI model profile (preserve customized roles and valid active selection)",
+    target: targetForProfiles(),
+    preview: JSON.stringify(
+      { version: 1, profiles: { openai: { agents: MODEL_MAPPINGS.openai } } },
+      null,
+      2
+    )
   };
 }
 function titleCaseSkillName(value) {
@@ -6866,18 +7162,21 @@ function openCodeSkillTargets(context2) {
       observed: installed ? "required global skill installed" : "required global skill missing"
     };
   });
+  const legacyCopies = inspectLegacyOpenCodeSkills(homeDir);
   const ownedTargets = getOpenCodeOwnedSkillEntries({
     homeDir
   }).map((skill) => {
-    const path = join8(skill.destinationPath, "SKILL.md");
+    const path = join8(skill.sourcePath, "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"
+      expected: "package-provided OpenCode skill",
+      observed: `${installed ? "package-provided skill available" : "package-provided skill missing"}${legacyCopies.filter((copy) => copy.name === skill.name).map(
+        (copy) => `; Warning: ${copy.sourcePath} shadows packaged skills; planned move to ${getLegacyOpenCodeSkillBackupRoot(homeDir)}/<new-run>/${copy.label}/${copy.name}; confirm with --move-legacy-opencode-skills`
+      ).join("")}`
     };
   });
   const diagnostics = [];
@@ -6896,55 +7195,39 @@ function openCodeSkillTargets(context2) {
   };
 }
 function configPluginMarker(config) {
-  const plugins = Array.isArray(config?.plugin) ? config.plugin : [];
-  return plugins.length > 0 ? `plugin: ${JSON.stringify(plugins)}` : "plugin: []";
+  return `plugins: ${JSON.stringify(pluginEntries(config?.plugins))}; legacy plugin: ${JSON.stringify(pluginEntries(config?.plugin))}`;
 }
 function hasExpectedPlugin(config) {
-  return EXPECTED_PLUGIN !== null && Array.isArray(config?.plugin) && config.plugin.includes(EXPECTED_PLUGIN);
+  const current = pluginEntries(config?.plugins);
+  return EXPECTED_PLUGIN !== null && current.filter(isManagedOpenCodePlugin).length === 1 && current.includes(EXPECTED_PLUGIN) && !pluginEntries(config?.plugin).some(isManagedOpenCodePlugin);
 }
 function hasManagedPluginDrift(config) {
-  return Array.isArray(config?.plugin) && config.plugin.some(
-    (plugin) => plugin === PACKAGE_NAME || plugin.startsWith(`${PACKAGE_NAME}@`)
+  return [...pluginEntries(config?.plugins), ...pluginEntries(config?.plugin)].some(
+    isManagedOpenCodePlugin
   ) && !hasExpectedPlugin(config);
 }
-function liteConfigMarker(config) {
-  const preset = typeof config?.preset === "string" ? config.preset : void 0;
-  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 managedPreset || role in legacyAgents
-  );
-  return `preset: ${preset ?? "none"}; observed roles: ${roles.join(", ")}`;
+function liteConfigMarker(_config) {
+  const { name, profile } = activeOpenCodeProfile();
+  const roles = ROLE_NAMES.filter((role) => role in (profile?.agents ?? {}));
+  return `profile: ${name ?? "none"}; observed roles: ${roles.join(", ")}`;
 }
-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 hasManagedProfile(_config) {
+  const { name, profile } = activeOpenCodeProfile();
+  return (name === OPENAI_PROFILE || name === APPLIED_MODELS_PROFILE) && hasCompleteAgentRoster(profile?.agents);
 }
-function hasSelectedNamedPreset(config) {
-  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)) {
-    return false;
-  }
-  const presets = config.presets;
-  if (!Object.hasOwn(presets, config.preset)) return false;
-  const selectedPreset = presets[config.preset];
-  return selectedPreset !== null && typeof selectedPreset === "object" && !Array.isArray(selectedPreset);
+function hasSelectedNamedProfile(_config) {
+  const { name, profile } = activeOpenCodeProfile();
+  return !!profile && name !== OPENAI_PROFILE && name !== APPLIED_MODELS_PROFILE;
 }
 function hasLegacySevenAgentRoster(config) {
-  return config?.preset === APPLIED_MODELS_PRESET && !hasManagedSevenAgentPreset(config) && hasCompleteAgentRoster(config.agents);
+  return !hasManagedProfile(config) && hasCompleteAgentRoster(config?.agents);
 }
-var ACTIVE_PRESET_SELECTED_CODE = "opencode-active-preset-selected";
-function activePresetSelectedDiagnostic() {
+var ACTIVE_PROFILE_SELECTED_CODE = "opencode-active-profile-selected";
+function activeProfileSelectedDiagnostic() {
   return {
     severity: "important",
-    message: "A valid named preset is active; model configuration preserves it while sync or install may repair the managed roster.",
-    code: ACTIVE_PRESET_SELECTED_CODE
+    message: "A valid named profile is active; model configuration preserves it while sync or install may repair the managed roster.",
+    code: ACTIVE_PROFILE_SELECTED_CODE
   };
 }
 var REPAIRABLE_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
@@ -6952,7 +7235,7 @@ var REPAIRABLE_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
   "opencode-main-config-missing",
   "opencode-lite-config-missing",
   "opencode-roster-drift",
-  ACTIVE_PRESET_SELECTED_CODE,
+  ACTIVE_PROFILE_SELECTED_CODE,
   "opencode-required-skills-missing"
 ]);
 var MODEL_PRECONFIG_SKILL_CODES = /* @__PURE__ */ new Set([
@@ -6985,7 +7268,7 @@ function targetsForBlockingDiagnostic(diagnostic, status) {
   if (code === "opencode-plugin-drift" || code === "opencode-main-config-missing" || code === "opencode-config-parse-error" || code === "opencode-unmanaged-config") {
     return main ? [main] : [];
   }
-  if (code === "opencode-roster-drift" || code === ACTIVE_PRESET_SELECTED_CODE || code === "opencode-lite-config-missing" || code === "thoth-config-parse-error" || code === "opencode-roster-unrecognized") {
+  if (code === "opencode-roster-drift" || code === ACTIVE_PROFILE_SELECTED_CODE || code === "opencode-lite-config-missing" || code === "thoth-config-parse-error" || code === "opencode-roster-unrecognized") {
     return lite ? [lite] : [];
   }
   if (code === "opencode-required-skills-missing") {
@@ -7013,7 +7296,7 @@ function blockingDetails(action, status, includeRepairable = false) {
   const diagnostics = status.diagnostics.filter((diagnostic) => {
     if (diagnostic.severity === "critical") return true;
     if (diagnostic.severity === "minor") return false;
-    if (!includeRepairable && action === "model-config" && diagnostic.code === ACTIVE_PRESET_SELECTED_CODE) {
+    if (!includeRepairable && action === "model-config" && diagnostic.code === ACTIVE_PROFILE_SELECTED_CODE) {
       return false;
     }
     if (!includeRepairable && allowModelPreconfiguration && diagnostic.code !== void 0 && MODEL_PRECONFIG_SKILL_CODES.has(diagnostic.code)) {
@@ -7094,16 +7377,16 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
   };
   if (!mainExists || !hasExpectedPlugin(main.config)) {
     if (hasManagedPluginDrift(main.config)) {
-      const currentRoster = hasManagedSevenAgentPreset(lite.config);
+      const currentRoster = hasManagedProfile(lite.config);
       const legacyRoster = hasLegacySevenAgentRoster(lite.config);
-      const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
-      const recognizedRoster = currentRoster || legacyRoster || selectedNamedPreset;
+      const selectedNamedProfile = hasSelectedNamedProfile(lite.config);
+      const recognizedRoster = currentRoster || legacyRoster || selectedNamedProfile;
       let liteState = "unknown";
       if (!liteExists) {
         liteState = "missing";
       } else if (currentRoster) {
         liteState = "installed";
-      } else if (legacyRoster || selectedNamedPreset) {
+      } else if (legacyRoster || selectedNamedProfile) {
         liteState = "drift";
       }
       return {
@@ -7132,7 +7415,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
               code: "opencode-roster-drift"
             }
           ] : [],
-          ...selectedNamedPreset && !currentRoster ? [activePresetSelectedDiagnostic()] : [],
+          ...selectedNamedProfile && !currentRoster ? [activeProfileSelectedDiagnostic()] : [],
           ...!liteExists ? [
             {
               severity: "important",
@@ -7160,10 +7443,10 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
       };
     }
     if (!mainExists && liteExists) {
-      const currentRoster = hasManagedSevenAgentPreset(lite.config);
+      const currentRoster = hasManagedProfile(lite.config);
       const legacyRoster = hasLegacySevenAgentRoster(lite.config);
-      const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
-      if (!currentRoster && !legacyRoster && !selectedNamedPreset) {
+      const selectedNamedProfile = hasSelectedNamedProfile(lite.config);
+      if (!currentRoster && !legacyRoster && !selectedNamedProfile) {
         return {
           harness: "opencode",
           displayName: "OpenCode",
@@ -7185,12 +7468,12 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
           actions: openCodeActions
         };
       }
-      if (selectedNamedPreset && !currentRoster) {
+      if (selectedNamedProfile && !currentRoster) {
         return {
           harness: "opencode",
           displayName: "OpenCode",
           state: "drift",
-          summary: "OpenCode plugin is missing and a valid named preset is active.",
+          summary: "OpenCode plugin is missing and a valid named profile is active.",
           targets: [
             { ...mainTarget, state: "missing" },
             { ...liteTarget, state: "drift" },
@@ -7202,7 +7485,7 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
               message: "The managed OpenCode main config is missing and must be restored by install or sync.",
               code: "opencode-main-config-missing"
             },
-            activePresetSelectedDiagnostic(),
+            activeProfileSelectedDiagnostic(),
             ...skillStatus.diagnostics
           ],
           actions: openCodeActions
@@ -7303,20 +7586,20 @@ function getOpenCodeManagedStatus(context2 = { cwd: process.cwd() }) {
       actions: openCodeActions
     };
   }
-  if (!hasManagedSevenAgentPreset(lite.config)) {
-    const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
+  if (!hasManagedProfile(lite.config)) {
+    const selectedNamedProfile = hasSelectedNamedProfile(lite.config);
     return {
       harness: "opencode",
       displayName: "OpenCode",
       state: "drift",
-      summary: selectedNamedPreset ? "A valid named OpenCode preset is active outside the managed six-role roster." : "thoth-agents config does not match the expected six-role roster.",
+      summary: selectedNamedProfile ? "A valid named OpenCode profile is active outside the managed six-role roster." : "thoth-agents config does not match the expected six-role roster.",
       targets: [
         { ...mainTarget, state: "installed" },
         { ...liteTarget, state: "drift" },
         ...skillStatus.targets
       ],
       diagnostics: [
-        selectedNamedPreset ? activePresetSelectedDiagnostic() : {
+        selectedNamedProfile ? activeProfileSelectedDiagnostic() : {
           severity: "important",
           message: "Roster drift requires repair before applying generated plans.",
           code: "opencode-roster-drift"
@@ -7347,8 +7630,18 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }, evidence = {}) {
   const managedStatus = getOpenCodeManagedStatus(context2);
   return {
     ...managedStatus,
+    summary: `${managedStatus.summary} Requires OpenCode 2.2.6 or later.`,
     targets: [
       ...managedStatus.targets,
+      {
+        ...targetForProfiles(),
+        observed: JSON.stringify({
+          active: activeOpenCodeProfile().name ?? "default",
+          agents: effectiveOpenCodeProfile(
+            parseConfig(getExistingLiteConfigPath()).config
+          ).agents
+        })
+      },
       getCliManagedInstallVersionTarget("opencode", context2)
     ],
     providerCapability: classifyProviderCapabilityEvidence(evidence)
@@ -7479,7 +7772,6 @@ function buildOpenCodeCompletePlan(action, context2) {
   const expectedPlugin = `${PACKAGE_NAME}@${version}`;
   const generatedConfig = generateLiteConfig({
     agent: "opencode",
-    hasTmux: false,
     dryRun: true,
     reset: false
   });
@@ -7500,16 +7792,10 @@ function buildOpenCodeCompletePlan(action, context2) {
         title: `Ensure OpenCode plugin points at ${expectedPlugin}`,
         target: {
           ...targetForMainConfig(),
-          expected: `plugin includes ${expectedPlugin}`
+          expected: `plugins includes ${expectedPlugin}`
         },
         state: getOpenCodeStatus(context2).state,
-        preview: `plugin: ["${expectedPlugin}"]`,
-        backup: defaultBackup(getExistingConfigPath())
-      },
-      {
-        title: "Disable OpenCode default agents",
-        target: targetForMainConfig(),
-        preview: "agent.explore.disable = true; agent.general.disable = true",
+        preview: `plugins: ["${expectedPlugin}"]`,
         backup: defaultBackup(getExistingConfigPath())
       },
       {
@@ -7518,8 +7804,9 @@ function buildOpenCodeCompletePlan(action, context2) {
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(getExistingLiteConfigPath())
       },
+      shippedProfilePlanItem(),
       {
-        title: "Synchronize global thoth-owned OpenCode skills",
+        title: "Inspect package-provided thoth-owned OpenCode skills",
         target: {
           kind: "skill",
           label: "Thoth-owned OpenCode skills",
@@ -7585,7 +7872,6 @@ function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
   }
   const generatedConfig = generateLiteConfig({
     agent: "opencode",
-    hasTmux: false,
     dryRun: true,
     reset: false
   });
@@ -7598,19 +7884,13 @@ function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
     "opencode-sync-preview",
     "sync",
     "Sync OpenCode managed configuration",
-    "Preview OpenCode plugin entry, default-agent disablement, and thoth-agents config sync.",
+    "Preview pinned OpenCode plugins and thoth-agents config sync (requires OpenCode 2.2.6 or later).",
     [
       {
         title: `Ensure OpenCode plugin points at ${PACKAGE_NAME}@${packageVersion.version}`,
         target: targetForMainConfig(),
         state: getOpenCodeStatus(context2).state,
-        preview: `plugin: ["${PACKAGE_NAME}@${packageVersion.version}"]`,
-        backup: defaultBackup(getExistingConfigPath())
-      },
-      {
-        title: "Disable OpenCode default agents",
-        target: targetForMainConfig(),
-        preview: "agent.explore.disable = true; agent.general.disable = true",
+        preview: `plugins: ["${PACKAGE_NAME}@${packageVersion.version}"]`,
         backup: defaultBackup(getExistingConfigPath())
       },
       {
@@ -7619,8 +7899,9 @@ function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
       },
+      shippedProfilePlanItem(),
       {
-        title: "Synchronize global thoth-owned OpenCode skills",
+        title: "Inspect package-provided thoth-owned OpenCode skills",
         target: {
           kind: "skill",
           label: "Thoth-owned OpenCode skills",
@@ -7676,7 +7957,7 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
   const items = normalizedRoles.map(({ role, model, variant, effort }) => {
     return {
       title: `Set ${role} OpenCode model override`,
-      target: targetForLiteConfig(),
+      target: targetForProfiles(),
       preview: JSON.stringify({
         [role]: {
           model,
@@ -7699,8 +7980,21 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
     "opencode-model-config-preview",
     "model-config",
     "Configure OpenCode role model overrides",
-    "Preview thoth-agents role model overrides in the plugin config agents map.",
-    items,
+    "Preview complete agents profile materialization and global activation.",
+    [
+      ...items,
+      {
+        title: "Materialize and globally activate the complete agents profile",
+        target: targetForProfiles(),
+        preview: "All six effective roles; active: agents"
+      },
+      {
+        title: "Remove unsupported preset keys, preserving root configuration",
+        target: targetForLiteConfig(),
+        preview: "Retain unrelated config keys; remove preset/presets",
+        backup: defaultBackup(getExistingLiteConfigPath())
+      }
+    ],
     _context
   );
   const effortWarnings = items.flatMap((item) => item.warnings ?? []);
@@ -7725,7 +8019,7 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
   const unsupportedRoles = input.roles.filter(
     (role) => !ROLE_NAMES.includes(role.role)
   );
-  if (input.roles.length === 0 || unsupportedRoles.length > 0) {
+  if (unsupportedRoles.length > 0) {
     return {
       ...plan,
       canApply: false,
@@ -7733,7 +8027,7 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
         ...plan.warnings,
         {
           severity: "critical",
-          message: input.roles.length === 0 ? "Model plan must include at least one role override." : `Unsupported OpenCode model role(s): ${unsupportedRoles.map((role) => role.role).join(", ")}.`,
+          message: `Unsupported OpenCode model role(s): ${unsupportedRoles.map((role) => role.role).join(", ")}.`,
           code: "opencode-model-roster-incomplete"
         }
       ]
@@ -7857,8 +8151,8 @@ function validateApplyPlan(plan) {
   return null;
 }
 function invalidModelPayloadReason(roles) {
-  if (!Array.isArray(roles) || roles.length === 0) {
-    return "Model payload must contain at least one role override.";
+  if (!Array.isArray(roles)) {
+    return "Model payload must be a role override array.";
   }
   const seen = /* @__PURE__ */ new Set();
   for (const role of roles) {
@@ -7887,89 +8181,33 @@ function hasCompleteAgentRoster(value) {
     (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) => [
-      role.role,
-      { model: role.model, variant: role.variant }
-    ])
-  );
   ensureConfigDir();
   const targetPath = getExistingLiteConfigPath();
   const parsed = parseConfig(targetPath);
-  const generated = generateLiteConfig({
-    agent: "opencode",
-    hasTmux: false,
-    dryRun: false,
-    reset: false
-  });
-  const base = parsed.config ?? generated;
-  const agents = { ...configRecord(base.agents) };
-  const appliedPreset = effectiveRolePreset(base, generated);
+  if (parsed.error) throw new Error(parsed.error);
+  const base = parsed.config ?? generateLiteConfig({ agent: "opencode", reset: false });
+  const profile = effectiveOpenCodeProfile(base);
   const statePath = getOpenCodeManagedModelStatePath();
   const state = readManagedModelState(statePath, 1);
   const configuredEfforts = { ...state.configuredEfforts ?? {} };
   const warnings = [];
-  for (const [role, override] of roleModels) {
-    const current = {
-      ...configRecord(agents[role])
-    };
-    const presetRole = {
-      ...configRecord(appliedPreset[role])
+  for (const override of roles) {
+    const role = override.role;
+    profile.agents[role] = {
+      model: override.model,
+      ...override.variant !== null ? { variant: override.variant } : {}
     };
-    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",
-        code: "opencode-effort-user-owned",
-        message: `Preserved user-owned OpenCode variant ${currentVariant} for ${role}.`
-      });
-    } 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;
+    if (override.variant === null) delete configuredEfforts[role];
+    else configuredEfforts[role] = override.variant;
   }
-  base.agents = agents;
-  base.presets = {
-    ...configRecord(base.presets),
-    [APPLIED_MODELS_PRESET]: appliedPreset
-  };
-  base.preset = APPLIED_MODELS_PRESET;
-  writeConfig(targetPath, base);
+  const store = openCodeProfileStore();
+  store.save("global", APPLIED_MODELS_PROFILE, profile);
+  store.setGlobalActive(APPLIED_MODELS_PROFILE);
+  writeConfig(targetPath, withoutLegacyPresets(base));
   writeManagedModelState(statePath, 1, {
     models: state.models,
-    configuredEfforts: Object.keys(configuredEfforts).length > 0 ? configuredEfforts : void 0
+    configuredEfforts: Object.keys(configuredEfforts).length ? configuredEfforts : void 0
   });
   return {
     harness: "opencode",
@@ -7979,7 +8217,11 @@ function applyModelPlan(roles) {
     changedTargets: [
       {
         ...targetForLiteConfig("installed"),
-        observed: "agents role overrides updated"
+        observed: "root configuration preserved; unsupported preset keys removed"
+      },
+      {
+        ...targetForProfiles(),
+        observed: "complete agents profile activated"
       }
     ],
     backups: existsSync10(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
@@ -8014,16 +8256,25 @@ function applyRequiredSkills(context2) {
 function applyOwnedSkills(context2) {
   const syncOwned = context2.syncOpenCodeOwnedSkills ?? syncOpenCodeOwnedSkills;
   const result = syncOwned({
+    moveLegacyOpenCodeSkills: context2.moveLegacyOpenCodeSkills,
     homeDir: homeDirFromContext(context2)
   });
-  if (result.success) return { success: true, warnings: [] };
+  if (result.success)
+    return {
+      success: true,
+      warnings: (result.notices ?? []).map((message) => ({
+        severity: "minor",
+        code: "opencode-legacy-skill-copy",
+        message
+      }))
+    };
   return {
     success: false,
     warnings: [
       {
         severity: "critical",
         code: "opencode-owned-skills-sync-failed",
-        message: `Failed to synchronize thoth-owned OpenCode skills: ${result.error ?? "unknown error"}.`
+        message: `Failed to inspect package-provided thoth-owned OpenCode skills: ${result.error ?? "unknown error"}.`
       }
     ]
   };
@@ -8074,6 +8325,16 @@ function applyOpenCodePlan(plan) {
       issued.context
     );
   }
+  const hostVersion = (issued.runtimeContext.getOpenCodeVersion ?? getOpenCodeVersionSync)();
+  if (!isSupportedOpenCodeVersion(hostVersion)) {
+    return rejectPlan3(
+      plan,
+      `${OPENCODE_VERSION_REQUIREMENT} Detected: ${hostVersion ?? "unavailable"}.`,
+      "critical",
+      "opencode-host-version-unsupported",
+      issued.context
+    );
+  }
   if (issued.payload.kind === "model") {
     const invalidPayload = invalidModelPayloadReason(issued.payload.roles);
     if (invalidPayload) {
@@ -8085,7 +8346,17 @@ function applyOpenCodePlan(plan) {
         issued.context
       );
     }
-    return applyModelPlan(issued.payload.roles);
+    try {
+      return applyModelPlan(issued.payload.roles);
+    } catch (error) {
+      return rejectPlan3(
+        plan,
+        `Failed to apply OpenCode model profile: ${String(error)}`,
+        "critical",
+        "opencode-profile-write-failed",
+        issued.context
+      );
+    }
   }
   const changedTargets = [];
   const backups = [];
@@ -8093,8 +8364,7 @@ function applyOpenCodePlan(plan) {
   const updateMainConfig = issued.runtimeContext.updateOpenCodeMainConfig ?? updateOpenCodeMainConfig;
   const mainConfigResult = updateMainConfig({
     ensurePlugin: true,
-    pluginVersion: issued.payload.version,
-    disableDefaults: true
+    pluginVersion: issued.payload.version
   });
   if (!mainConfigResult.success) {
     return rejectPlan3(
@@ -8107,7 +8377,7 @@ function applyOpenCodePlan(plan) {
   }
   changedTargets.push({
     ...targetForMainConfig("installed"),
-    observed: `plugin includes ${PACKAGE_NAME}@${issued.payload.version}`
+    observed: `plugins includes ${PACKAGE_NAME}@${issued.payload.version}`
   });
   if (existsSync10(`${mainConfigResult.configPath}.bak`)) {
     backups.push({
@@ -8119,7 +8389,6 @@ function applyOpenCodePlan(plan) {
   const liteResult = writeLite(
     {
       agent: "opencode",
-      hasTmux: false,
       dryRun: false,
       reset: false
     },
@@ -8135,6 +8404,10 @@ function applyOpenCodePlan(plan) {
     ...targetForLiteConfig("installed"),
     observed: "six-role roster written"
   });
+  changedTargets.push({
+    ...targetForProfiles(),
+    observed: "built-in openai profile synchronized"
+  });
   if (existsSync10(`${liteResult.configPath}.bak`)) {
     backups.push({
       path: `${liteResult.configPath}.bak`,
@@ -8147,14 +8420,14 @@ function applyOpenCodePlan(plan) {
     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"
+    observed: ownedSkills.success ? "package-provided skills available" : "package-provided skill inspection failed"
   });
   if (!ownedSkills.success) {
     return {
       harness: "opencode",
       action: plan.action,
       applied: false,
-      summary: "OpenCode configuration was written, but thoth-owned skills failed to synchronize.",
+      summary: "OpenCode configuration was written, but package-provided skills failed inspection.",
       changedTargets,
       backups,
       warnings,
@@ -8224,28 +8497,28 @@ function applyOpenCodePlan(plan) {
 }
 
 // src/cli/operations/pi.ts
-import { spawnSync as spawnSync7 } from "child_process";
+import { spawnSync as spawnSync8 } from "child_process";
 import { createHash as createHash7 } from "crypto";
 import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
 import { basename as basename4, dirname as dirname11, isAbsolute as isAbsolute5, join as join15 } from "path";
 
 // src/cli/pi-install.ts
-import { spawnSync as spawnSync6 } from "child_process";
+import { spawnSync as spawnSync7 } from "child_process";
 import { createHash as createHash6 } from "crypto";
 import {
   existsSync as existsSync14,
   lstatSync as lstatSync6,
   readdirSync as readdirSync3,
   readFileSync as readFileSync13,
-  realpathSync as realpathSync3,
-  statSync as statSync3
+  realpathSync as realpathSync4,
+  statSync as statSync4
 } from "fs";
-import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute4, join as join14, resolve as resolve9, sep as sep3 } from "path";
+import { basename as basename3, dirname as dirname10, isAbsolute as isAbsolute4, join as join14, resolve as resolve10, sep as sep4 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { lt } from "semver";
 
 // src/cli/pi-external-package.ts
-import { readFileSync as readFileSync9, realpathSync as realpathSync2 } from "fs";
+import { readFileSync as readFileSync9, realpathSync as realpathSync3 } from "fs";
 import { isAbsolute as isAbsolute2, join as join9 } from "path";
 import { satisfies, valid } from "semver";
 function npmPackageName(source) {
@@ -8274,7 +8547,7 @@ function piExternalSourceMatches(candidate, expectedSource) {
   if (candidate.source === expectedSource) return true;
   if (!isAbsolute2(expectedSource) || !candidate.installedPath) return false;
   try {
-    return realpathSync2(candidate.installedPath) === realpathSync2(expectedSource);
+    return realpathSync3(candidate.installedPath) === realpathSync3(expectedSource);
   } catch {
     return false;
   }
@@ -8360,7 +8633,7 @@ function inspectPiExternalPackage(packages, spec, requireManagedSource = true) {
 }
 
 // src/cli/pi-git-source.ts
-import { resolve as resolve5, sep as sep2 } from "path";
+import { resolve as resolve6, sep as sep3 } from "path";
 import hostedGitInfo from "hosted-git-info";
 function splitRef(url) {
   const scpLikeMatch = url.match(/^git@([^:]+):(.+)$/);
@@ -8502,9 +8775,9 @@ function projectGitPackagePath(source, projectRoot) {
     return void 0;
   const parsed = parseGitUrl(source);
   if (!parsed) return void 0;
-  const installRoot = resolve5(projectRoot, "git");
-  const installedPath = resolve5(installRoot, parsed.host, parsed.path);
-  if (installedPath !== installRoot && !installedPath.startsWith(`${installRoot}${sep2}`))
+  const installRoot = resolve6(projectRoot, "git");
+  const installedPath = resolve6(installRoot, parsed.host, parsed.path);
+  if (installedPath !== installRoot && !installedPath.startsWith(`${installRoot}${sep3}`))
     return void 0;
   return installedPath;
 }
@@ -8517,7 +8790,7 @@ import {
   readdirSync as readdirSync2,
   readFileSync as readFileSync10,
   renameSync as renameSync4,
-  statSync as statSync2,
+  statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "fs";
 import { dirname as dirname7, join as join10 } from "path";
@@ -8561,7 +8834,7 @@ function migrateLegacyPiResources(options) {
     if (!existsSync11(source)) continue;
     const canonical = join10(options.packageRoot, "skills", name);
     const backup = `${source}.thoth-agents-legacy.bak`;
-    if (!statSync2(source).isDirectory() || !identicalTrees(source, canonical) || existsSync11(backup)) {
+    if (!statSync3(source).isDirectory() || !identicalTrees(source, canonical) || existsSync11(backup)) {
       manualActions.push(
         `Legacy Pi skill ${name} is modified or has ambiguous backup ownership; remove it manually after review.`
       );
@@ -8611,16 +8884,16 @@ function migrateLegacyPiResources(options) {
 }
 
 // src/cli/pi-native-probe.ts
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 import {
   existsSync as existsSync12,
-  mkdtempSync as mkdtempSync2,
+  mkdtempSync,
   readFileSync as readFileSync11,
-  rmSync as rmSync5,
+  rmSync as rmSync4,
   writeFileSync as writeFileSync4
 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname8, join as join11, resolve as resolve6, win32 } from "path";
+import { dirname as dirname8, join as join11, resolve as resolve7, win32 } from "path";
 function resolvePiWindowsCliFromShim(shimPath, shimContents) {
   const target = shimContents.match(
     /"([^"\r\n]*@earendil-works[\\/]+pi-coding-agent[\\/]+dist[\\/]+bundle[\\/]+cli\.js)"\s+%\*/i
@@ -8633,7 +8906,7 @@ function resolvePiWindowsCliFromShim(shimPath, shimContents) {
   return win32.isAbsolute(expanded) ? win32.normalize(expanded) : void 0;
 }
 function findPiWindowsCli() {
-  const located = spawnSync5("where.exe", ["pi.cmd"], {
+  const located = spawnSync6("where.exe", ["pi.cmd"], {
     windowsHide: true,
     encoding: "utf8"
   }).stdout?.split(/\r?\n/).find(Boolean);
@@ -8667,7 +8940,7 @@ function defaultExecutor(command, args, env) {
       executableArgs = [cli, ...args];
     }
   }
-  const result = spawnSync5(executable, executableArgs, {
+  const result = spawnSync6(executable, executableArgs, {
     windowsHide: true,
     encoding: "utf8",
     timeout: 3e4,
@@ -8685,7 +8958,7 @@ function occurrences(text, marker) {
 }
 function observePiNativeRoot(options) {
   const ownsIsolatedRoot = options.piHome === void 0;
-  const isolatedRoot = options.piHome ?? mkdtempSync2(join11(tmpdir(), "thoth-pi-observer-"));
+  const isolatedRoot = options.piHome ?? mkdtempSync(join11(tmpdir(), "thoth-pi-observer-"));
   const observerPath = join11(
     isolatedRoot,
     `observer-${process.pid}-${Date.now()}.mjs`
@@ -8765,7 +9038,7 @@ export default function observer(pi) {
       "--offline",
       "--no-extensions",
       "--extension",
-      resolve6(options.extensionPath),
+      resolve7(options.extensionPath),
       "--extension",
       observerPath,
       "--provider",
@@ -8838,8 +9111,8 @@ ${result.stderr}`.split(/\r?\n/).flatMap((line) => {
     };
   } finally {
     if (ownsIsolatedRoot)
-      rmSync5(isolatedRoot, { recursive: true, force: true });
-    else rmSync5(observerPath, { force: true });
+      rmSync4(isolatedRoot, { recursive: true, force: true });
+    else rmSync4(observerPath, { force: true });
   }
 }
 
@@ -8849,11 +9122,11 @@ import {
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync12,
   renameSync as renameSync5,
-  rmSync as rmSync6,
+  rmSync as rmSync5,
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname9, isAbsolute as isAbsolute3, join as join12, normalize, resolve as resolve7 } from "path";
+import { dirname as dirname9, isAbsolute as isAbsolute3, join as join12, normalize, resolve as resolve8 } from "path";
 var keys = [
   "schemaVersion",
   "owner",
@@ -8868,8 +9141,8 @@ var keys = [
 var semver = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 var digest = /^[0-9a-f]{64}$/;
 function piPackagePathsEqual(left, right) {
-  const normalizedLeft = normalize(resolve7(left));
-  const normalizedRight = normalize(resolve7(right));
+  const normalizedLeft = normalize(resolve8(left));
+  const normalizedRight = normalize(resolve8(right));
   return process.platform === "win32" ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase() : normalizedLeft === normalizedRight;
 }
 function getPiPackageReceiptPath(options = {}) {
@@ -8926,7 +9199,7 @@ function writePiPackageReceipt(receipt, options = {}) {
     try {
       renameSync5(temporary, path);
     } catch (error) {
-      rmSync6(temporary, { force: true });
+      rmSync5(temporary, { force: true });
       throw error;
     }
     return { success: true, path };
@@ -8961,17 +9234,17 @@ function classifyPiPackageOwnership(input) {
 
 // src/cli/pi-paths.ts
 import { homedir as homedir6 } from "os";
-import { join as join13, resolve as resolve8 } from "path";
+import { join as join13, resolve as resolve9 } from "path";
 function resolvePiPaths(options = {}) {
   const env = options.env ?? process.env;
-  const homeDir = resolve8(
+  const homeDir = resolve9(
     options.homeDir ?? env.HOME ?? env.USERPROFILE ?? homedir6()
   );
   const defaultPiRoot = join13(homeDir, ".pi", "agent");
   const configured = env.PI_CODING_AGENT_DIR?.trim();
-  const piRoot = configured ? resolve8(configured) : defaultPiRoot;
-  const cwd = resolve8(options.cwd ?? process.cwd());
-  const configRoot = env.XDG_CONFIG_HOME?.trim() ? resolve8(env.XDG_CONFIG_HOME) : join13(homeDir, ".config");
+  const piRoot = configured ? resolve9(configured) : defaultPiRoot;
+  const cwd = resolve9(options.cwd ?? process.cwd());
+  const configRoot = env.XDG_CONFIG_HOME?.trim() ? resolve9(env.XDG_CONFIG_HOME) : join13(homeDir, ".config");
   return {
     homeDir,
     piRoot,
@@ -9299,7 +9572,7 @@ function projectLocalPackagePath(source, projectRoot, homeDir) {
   else if (path.startsWith("~/") || process.platform === "win32" && path.startsWith("~\\"))
     path = join14(homeDir, path.slice(2));
   else if (path.startsWith("file://")) path = fileURLToPath5(path);
-  return resolve9(projectRoot, path);
+  return resolve10(projectRoot, path);
 }
 function legacyPiNpmPackagePath(name, settings, execute) {
   try {
@@ -9310,7 +9583,7 @@ function legacyPiNpmPackagePath(name, settings, execute) {
     if (/[\0\r\n&|<>^%"'`$;!]/.test(command)) return void 0;
     const manager = basename3(command).replace(/\.(cmd|exe)$/i, "");
     if (!["npm", "pnpm", "bun"].includes(manager)) return void 0;
-    if (/\s/.test(command) && !statSync3(command, { throwIfNoEntry: false })?.isFile())
+    if (/\s/.test(command) && !statSync4(command, { throwIfNoEntry: false })?.isFile())
       return void 0;
     const query = (args) => {
       const result = execute(command, args);
@@ -9357,7 +9630,7 @@ function resolvePiPackage(candidate, options, userSettings) {
   candidate = { ...candidate, resourceOnly };
   if (candidate.installedPath) return candidate;
   const paths = resolvePiPaths(options);
-  const baseDir = candidate.scope === "user" ? paths.piRoot : join14(resolve9(options.cwd ?? process.cwd()), ".pi");
+  const baseDir = candidate.scope === "user" ? paths.piRoot : join14(resolve10(options.cwd ?? process.cwd()), ".pi");
   const parsed = parsePiPackageSource(candidate.source, baseDir);
   const npmName = parsed.type === "npm" ? parsed.name : void 0;
   let path = npmName ? join14(baseDir, "npm", "node_modules", npmName) : parsed.type === "git" ? parsed.path : projectLocalPackagePath(candidate.source, baseDir, paths.homeDir);
@@ -9365,7 +9638,7 @@ function resolvePiPackage(candidate, options, userSettings) {
     path = legacyPiNpmPackagePath(
       npmName,
       userSettings,
-      options.commandExecutor ?? defaultCommandExecutor4
+      options.commandExecutor ?? defaultCommandExecutor3
     ) ?? path;
   return {
     ...candidate,
@@ -9381,7 +9654,7 @@ function resolvePiListedPackages(output, options) {
   const packages = parsePiPackageList(output);
   const paths = resolvePiPaths(options);
   const settings = readJsonObject(paths.settingsPath);
-  const projectRoot = join14(resolve9(options.cwd ?? process.cwd()), ".pi");
+  const projectRoot = join14(resolve10(options.cwd ?? process.cwd()), ".pi");
   let projectSettings;
   for (const { scope, source, installedPath } of packages) {
     const baseDir = scope === "user" ? paths.piRoot : projectRoot;
@@ -9407,7 +9680,7 @@ function resolvePiListedPackages(output, options) {
   });
 }
 function readPiProjectPackages(options) {
-  const projectRoot = join14(resolve9(options.cwd ?? process.cwd()), ".pi");
+  const projectRoot = join14(resolve10(options.cwd ?? process.cwd()), ".pi");
   return resolvePiConfiguredPackages(
     readJsonObject(join14(projectRoot, "settings.json")),
     "project",
@@ -9435,28 +9708,28 @@ function resolvePiPreservationPackages(output, options) {
   ];
 }
 function scanPiProjectInstalledIncumbents(options, configuredPackages) {
-  const projectRoot = join14(resolve9(options.cwd ?? process.cwd()), ".pi");
+  const projectRoot = join14(resolve10(options.cwd ?? process.cwd()), ".pi");
   const incumbents = [];
   const visited = /* @__PURE__ */ new Set();
   const pathKey = (path) => process.platform === "win32" ? path.toLowerCase() : path;
   const knownPaths = new Set(
     configuredPackages.flatMap(
-      ({ installedPath }) => installedPath ? [pathKey(realpathSync3(installedPath))] : []
+      ({ installedPath }) => installedPath ? [pathKey(realpathSync4(installedPath))] : []
     )
   );
   for (const root of [join14(projectRoot, "git"), join14(projectRoot, "npm")]) {
     if (!existsSync14(root)) continue;
-    const rootKey = pathKey(realpathSync3(root));
+    const rootKey = pathKey(realpathSync4(root));
     const pending = [root];
     while (pending.length > 0) {
       const path = pending.pop();
-      if (!path || !statSync3(path, { throwIfNoEntry: false })?.isDirectory())
+      if (!path || !statSync4(path, { throwIfNoEntry: false })?.isDirectory())
         continue;
-      const key = pathKey(realpathSync3(path));
+      const key = pathKey(realpathSync4(path));
       if (visited.has(key)) continue;
       visited.add(key);
       const manifestPath = join14(path, "package.json");
-      if (existsSync14(manifestPath) && statSync3(manifestPath).isFile()) {
+      if (existsSync14(manifestPath) && statSync4(manifestPath).isFile()) {
         const candidate = {
           scope: "project",
           source: path,
@@ -9471,7 +9744,7 @@ function scanPiProjectInstalledIncumbents(options, configuredPackages) {
             identityLimitation: `Installed manifest at ${path} identifies ${identity.packageName}, but no configured settings source maps to this directory.`
           });
       }
-      if (key !== rootKey && !key.startsWith(`${rootKey}${sep3}`)) continue;
+      if (key !== rootKey && !key.startsWith(`${rootKey}${sep4}`)) continue;
       for (const entry of readdirSync3(path, { withFileTypes: true }))
         if (entry.isDirectory() || entry.isSymbolicLink())
           pending.push(join14(path, entry.name));
@@ -9585,7 +9858,7 @@ function buildPiSetupPlan(options = {}) {
   if (options.runtimePackageRoot) {
     const runtimeRoot = options.runtimePackageRoot;
     const spec = getPiExternalPackageSpecs(options)[0];
-    const sourceIsNormalizedAbsolutePath = isAbsolute4(runtimeRoot) && resolve9(runtimeRoot) === runtimeRoot;
+    const sourceIsNormalizedAbsolutePath = isAbsolute4(runtimeRoot) && resolve10(runtimeRoot) === runtimeRoot;
     const inspection = sourceIsNormalizedAbsolutePath ? inspectPiExternalPackage(
       [{ scope: "user", source: runtimeRoot, installedPath: runtimeRoot }],
       spec
@@ -9643,7 +9916,7 @@ function buildPiSetupPlan(options = {}) {
     blockers.push(error instanceof Error ? error.message : String(error));
   }
   const projectSettingsPath = join14(
-    resolve9(options.cwd ?? process.cwd()),
+    resolve10(options.cwd ?? process.cwd()),
     ".pi",
     "settings.json"
   );
@@ -9935,7 +10208,7 @@ function getPiFirstPartyPackages(packages, knownSource) {
 function matchesInstallSource(candidate, installSource) {
   return isAbsolute4(installSource) ? candidate.installedPath !== void 0 && piPackagePathsEqual(candidate.installedPath, installSource) : candidate.source === installSource;
 }
-function defaultCommandExecutor4(command, args) {
+function defaultCommandExecutor3(command, args) {
   let executable = command;
   let executableArgs = [...args];
   if (process.platform === "win32" && command === "pi") {
@@ -9945,7 +10218,7 @@ function defaultCommandExecutor4(command, args) {
       executableArgs = [cli, ...args];
     }
   }
-  const result = spawnSync6(executable, executableArgs, {
+  const result = spawnSync7(executable, executableArgs, {
     windowsHide: true,
     encoding: "utf8",
     timeout: PI_COMMAND_TIMEOUT_MS,
@@ -9973,7 +10246,7 @@ function applyPiSetup(plan) {
     };
   if (plan.dryRun)
     return { success: true, changed: [], diagnostics, installedPackages: [] };
-  const execute = plan.options.commandExecutor ?? defaultCommandExecutor4;
+  const execute = plan.options.commandExecutor ?? defaultCommandExecutor3;
   const changed = [];
   const installedPackages = [];
   let receiptCommitted = false;
@@ -10613,7 +10886,7 @@ function statusFromPlan(plan, context2, evidence = {}) {
     description: item.kind === "package" ? "Validated installed-package manifest evidence; this does not prove live tool availability." : void 0
   }));
   const execute = context2.piCommandExecutor ?? ((command, args) => {
-    const result = spawnSync7(command, [...args], {
+    const result = spawnSync8(command, [...args], {
       windowsHide: true,
       encoding: "utf8",
       timeout: 5e3,
@@ -11371,11 +11644,19 @@ function applyPiPlan(plan) {
         homeDir: source.context.homeDir
       }
     });
-    if (!completion.success)
-      return reject(
+    const completionEvidence = getInstallCompletionEvidence(completion, {
+      codePrefix: "pi",
+      version: source.version,
+      fallbackError: "Pi provider setup or ledger commit failed."
+    });
+    if (!completion.success) {
+      const rejected = reject(
         completion.error ?? "Pi provider setup or ledger commit failed.",
-        [...setupTargets, ...skillTargets]
+        [...setupTargets, ...skillTargets, ...completionEvidence.targets]
       );
+      rejected.warnings.push(...completionEvidence.warnings);
+      return rejected;
+    }
     return {
       harness: "pi",
       action: plan.action,
@@ -11384,12 +11665,7 @@ function applyPiPlan(plan) {
       changedTargets: [
         ...setupTargets,
         ...skillTargets,
-        {
-          kind: "file",
-          path: completion.ledger.path,
-          label: "CLI-managed install version",
-          state: "installed"
-        }
+        ...completionEvidence.targets
       ],
       diagnosticTargets: packageSkills.skills.map((skill) => ({
         kind: "skill",
@@ -11398,7 +11674,7 @@ function applyPiPlan(plan) {
         state: "installed"
       })),
       backups: [],
-      warnings: [],
+      warnings: completionEvidence.warnings,
       disclaimers: disclaimers()
     };
   }
@@ -11902,35 +12178,15 @@ function getClaudeCodeModelRoles(_source = claudeCodeContext) {
 function getPiModelRoles() {
   return defaultPiModelRoles(context);
 }
-function readRoleField(config, role, field) {
-  if (!config || typeof config !== "object" || Array.isArray(config)) {
-    return void 0;
-  }
-  const record = config;
-  const value = record[role];
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return void 0;
-  }
-  const fieldValue = value[field];
-  return typeof fieldValue === "string" && fieldValue.length > 0 ? fieldValue : void 0;
-}
 function getOpenCodeModelRoles() {
   const parsed = parseConfig(getExistingLiteConfigPath());
-  const agents = parsed.config?.agents && typeof parsed.config.agents === "object" ? parsed.config.agents : void 0;
-  const presets = parsed.config?.presets && typeof parsed.config.presets === "object" && !Array.isArray(parsed.config.presets) ? parsed.config.presets : {};
-  const presetName = typeof parsed.config?.preset === "string" ? parsed.config.preset : void 0;
-  const selectedPreset = presetName !== void 0 ? presets[presetName] : void 0;
-  const activePreset = selectedPreset && typeof selectedPreset === "object" && !Array.isArray(selectedPreset) ? selectedPreset : void 0;
+  const profile = effectiveOpenCodeProfile(parsed.config);
   return ALL_AGENT_NAMES.map((role) => {
-    const defaultModel = getDefaultOpenCodeModel(role);
-    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 ?? (configuredModel === void 0 ? getDefaultOpenCodeVariant(role) : void 0);
+    const value = profile.agents[role];
     return {
       role,
-      model,
-      effort: variant ? { kind: "effort", value: variant } : { kind: "inherit" }
+      model: value?.model ?? getDefaultOpenCodeModel(role),
+      effort: value?.variant ? { kind: "effort", value: value.variant } : { kind: "inherit" }
     };
   });
 }
@@ -11962,6 +12218,7 @@ function buildRestoreModelPlan(harness, options, source = context) {
   return buildTuiModelPlan(harness, roles, source);
 }
 var defaultTuiOperations = {
+  legacyOpenCodeSkillCopies: () => inspectLegacyOpenCodeSkills().map((copy) => copy.sourcePath),
   status(harness, evidence) {
     if (harness === "opencode") return getOpenCodeStatus(context, evidence);
     if (harness === "claude") {
@@ -11983,8 +12240,12 @@ var defaultTuiOperations = {
   },
   plan(harness, action, options) {
     if (harness === "opencode") {
-      if (action === "install") return buildOpenCodeInstallPlan(context);
-      if (action === "update") return buildOpenCodeUpdatePlan(context);
+      const consentContext2 = {
+        ...context,
+        moveLegacyOpenCodeSkills: options?.moveLegacyOpenCodeSkills === true
+      };
+      if (action === "install") return buildOpenCodeInstallPlan(consentContext2);
+      if (action === "update") return buildOpenCodeUpdatePlan(consentContext2);
       if (action === "sync") return buildOpenCodeSyncPlan(context);
       return buildTuiModelPlan(harness, getOpenCodeModelRoles());
     }
@@ -12061,8 +12322,15 @@ export {
   buildClaudeCodeSetupPlan,
   applyClaudeCodeSetup,
   formatClaudeCodeSetupPlan,
+  isOpenCodeInstalled,
+  OPENCODE_VERSION_REQUIREMENT,
+  isSupportedOpenCodeVersion,
+  getOpenCodeVersion,
+  getOpenCodePath,
   recordHarnessInstallCompletion,
   finalizeHarnessInstall,
+  getLegacyOpenCodeSkillBackupRoot,
+  inspectLegacyOpenCodeSkills,
   syncOpenCodeOwnedSkills,
   inspectPiPackageSkills,
   buildPiSetupPlan,