thoth-agents 0.11.0 → 0.12.0

package/dist/{chunk-I5TXGNSG.js → chunk-SEF6PFM6.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-7F33WUSD.js";
 import {
   ALL_AGENT_NAMES,
   CLAUDE_CODE_PROMPT_DIALECT,
@@ -33,22 +34,25 @@ import {
   generateLiteConfig,
   getAgentOverride,
   getAgentPackContract,
+  getConfigDir,
   getDefaultOpenCodeModel,
   getDefaultOpenCodeVariant,
   getExistingConfigPath,
   getExistingLiteConfigPath,
   getOpenCodeManagedModelStatePath,
   getPrimaryModelId,
+  isManagedOpenCodePlugin,
   isPiSpecialistRole,
   isValidPackageVersion,
   parseConfig,
   piSpecialistName,
+  pluginEntries,
   renderAgentRoutingDescription,
   resolveExecutingPackageVersion,
   updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-DNPKVFOB.js";
+} from "./chunk-NY2IPJ7V.js";
 
 // src/cli/model-effort.ts
 function normalizeEffortSelection(value) {
@@ -4387,47 +4391,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 +4430,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 +4459,9 @@ function invalidResult(harness, command, args, exitCode, error) {
     status: "invalid",
     changed: false,
     harness,
-    steps: [],
+    actions: [],
+    warnings: [],
     diagnostics: [],
-    manualActions: [],
     receipt: null,
     command,
     args,
@@ -4477,24 +4470,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 +4532,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 +4607,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 +4633,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 +4790,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 +6417,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 +6521,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 +6543,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,6 +6704,178 @@ 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();
@@ -6813,7 +7085,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 +7094,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) {
@@ -6866,18 +7138,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,15 +7171,15 @@ 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) {
@@ -7347,6 +7622,7 @@ 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,
       getCliManagedInstallVersionTarget("opencode", context2)
@@ -7479,7 +7755,6 @@ function buildOpenCodeCompletePlan(action, context2) {
   const expectedPlugin = `${PACKAGE_NAME}@${version}`;
   const generatedConfig = generateLiteConfig({
     agent: "opencode",
-    hasTmux: false,
     dryRun: true,
     reset: false
   });
@@ -7500,16 +7775,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())
       },
       {
@@ -7519,7 +7788,7 @@ function buildOpenCodeCompletePlan(action, context2) {
         backup: defaultBackup(getExistingLiteConfigPath())
       },
       {
-        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 +7854,6 @@ function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
   }
   const generatedConfig = generateLiteConfig({
     agent: "opencode",
-    hasTmux: false,
     dryRun: true,
     reset: false
   });
@@ -7598,19 +7866,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())
       },
       {
@@ -7620,7 +7882,7 @@ function buildOpenCodeSyncPlan(context2 = { cwd: process.cwd() }) {
         backup: defaultBackup(litePath)
       },
       {
-        title: "Synchronize global thoth-owned OpenCode skills",
+        title: "Inspect package-provided thoth-owned OpenCode skills",
         target: {
           kind: "skill",
           label: "Thoth-owned OpenCode skills",
@@ -7917,7 +8179,6 @@ function applyModelPlan(roles) {
   const parsed = parseConfig(targetPath);
   const generated = generateLiteConfig({
     agent: "opencode",
-    hasTmux: false,
     dryRun: false,
     reset: false
   });
@@ -8014,16 +8275,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 +8344,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) {
@@ -8093,8 +8373,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 +8386,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 +8398,6 @@ function applyOpenCodePlan(plan) {
   const liteResult = writeLite(
     {
       agent: "opencode",
-      hasTmux: false,
       dryRun: false,
       reset: false
     },
@@ -8147,14 +8425,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 +8502,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 +8552,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 +8638,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 +8780,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 +8795,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 +8839,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 +8889,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 +8911,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 +8945,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 +8963,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 +9043,7 @@ export default function observer(pi) {
       "--offline",
       "--no-extensions",
       "--extension",
-      resolve6(options.extensionPath),
+      resolve7(options.extensionPath),
       "--extension",
       observerPath,
       "--provider",
@@ -8838,8 +9116,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 +9127,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 +9146,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 +9204,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 +9239,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 +9577,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 +9588,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 +9635,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 +9643,7 @@ function resolvePiPackage(candidate, options, userSettings) {
     path = legacyPiNpmPackagePath(
       npmName,
       userSettings,
-      options.commandExecutor ?? defaultCommandExecutor4
+      options.commandExecutor ?? defaultCommandExecutor3
     ) ?? path;
   return {
     ...candidate,
@@ -9381,7 +9659,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 +9685,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 +9713,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 +9749,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 +9863,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 +9921,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 +10213,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 +10223,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 +10251,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 +10891,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 +11649,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 +11670,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 +11679,7 @@ function applyPiPlan(plan) {
         state: "installed"
       })),
       backups: [],
-      warnings: [],
+      warnings: completionEvidence.warnings,
       disclaimers: disclaimers()
     };
   }
@@ -11962,6 +12243,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 +12265,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 +12347,15 @@ export {
   buildClaudeCodeSetupPlan,
   applyClaudeCodeSetup,
   formatClaudeCodeSetupPlan,
+  isOpenCodeInstalled,
+  OPENCODE_VERSION_REQUIREMENT,
+  isSupportedOpenCodeVersion,
+  getOpenCodeVersion,
+  getOpenCodePath,
   recordHarnessInstallCompletion,
   finalizeHarnessInstall,
+  getLegacyOpenCodeSkillBackupRoot,
+  inspectLegacyOpenCodeSkills,
   syncOpenCodeOwnedSkills,
   inspectPiPackageSkills,
   buildPiSetupPlan,