thoth-agents 0.2.9 → 0.2.11

package/dist/{chunk-6NMPKYWY.js → chunk-ASKXWU6E.js}

@@ -10,6 +10,7 @@ import {
   DEFAULT_THOTH_COMMAND,
   GREP_APP_MCP_URL,
   appendPromptSections,
+  checkCustomSkillsNeedUpdate,
   claudeCodeSubagentType,
   composeAgentPrompt,
   createModelFamilySection,
@@ -17,9 +18,7 @@ import {
   createReadOnlySpecialistPromptSections,
   createStepBudgetSection,
   createWriteCapableSpecialistPromptSections,
-  disableDefaultAgents,
   ensureConfigDir,
-  ensureOpenCodeConfigDir,
   exa,
   findPackageRoot,
   generateLiteConfig,
@@ -35,9 +34,10 @@ import {
   parseConfig,
   renderPromptSection,
   renderRolePrompt,
+  updateOpenCodeMainConfig,
   writeConfig,
   writeLiteConfig
-} from "./chunk-YLRPDTU7.js";
+} from "./chunk-OZE7JVGS.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -611,26 +611,31 @@ var CODEX_SURFACES = [
     id: "per-agent-runtime-permissions",
     target: "permission-control",
     status: "unsupported",
-    fields: ["per-agent tool allow/deny equivalent to OpenCode permissions"],
+    fields: [
+      "named installed-role selection",
+      "per-role permission enforcement",
+      "per-agent tool allow/deny equivalent to OpenCode permissions"
+    ],
     diagnosticCode: "codex.permission.memory.enforcement_gap",
-    summary: "Codex sandbox and approval policy can constrain sessions, but OpenCode-style per-agent MCP/tool deny maps are not validated.",
+    summary: "Named installed-role selection and per-role permission enforcement are instruction-only because collaboration.spawn_agent has no role selector; OpenCode-style per-agent MCP/tool deny maps are not validated.",
     evidence: "Codex approvals/security docs cover sandbox and approval policies, not exact OpenCode per-agent permission maps.",
     fallback: "instruction-only"
   },
   {
     id: "programmatic-delegation-runtime",
     target: "delegation-runtime",
-    status: "unsupported",
+    status: "validated",
     fields: [
-      "task API",
-      "background task sessions",
-      "tmux lifecycle hooks",
-      "automatic subagent session close"
+      "collaboration.spawn_agent",
+      "collaboration.wait_agent",
+      "collaboration.list_agents",
+      "collaboration.send_message",
+      "collaboration.followup_task",
+      "collaboration.interrupt_agent"
     ],
-    diagnosticCode: "codex.delegation.runtime.unsupported",
-    summary: "Codex subagents are user/instruction-triggered; no OpenCode plugin task API or automatic subagent session close parity is validated.",
-    evidence: "Codex subagents docs describe manual spawning and agent threads, not this plugin runtime task API or a validated runtime close hook.",
-    fallback: "instruction-only"
+    diagnosticCode: "codex.delegation.runtime.validated",
+    summary: "The current Codex collaboration surface supports generic programmatic delegation, mailbox waits, live task-tree inspection, messages, follow-up turns, and explicit interruption.",
+    evidence: "The callable runtime exposes collaboration.spawn_agent with task_name, message, and optional fork_turns plus wait_agent, list_agents, send_message, followup_task, and interrupt_agent."
   },
   {
     id: "parent-context-injection",
@@ -1432,15 +1437,18 @@ function renderCodexRolePrompt(roleName, config, model) {
 function codexInternalHandoffGuidance() {
   return [
     "<codex-delegation-guidance>",
-    "- The user has explicitly authorized this generated Codex orchestrator to use `multi_agent_v1.spawn_agent` whenever delegation is required by these instructions, without needing a fresh user request for subagents in each task.",
-    "- Delegate by calling `multi_agent_v1.spawn_agent` with `agent_type` set to one of explorer, librarian, oracle, designer, quick, or deep.",
+    "- The user has explicitly authorized this generated Codex orchestrator to use `collaboration.spawn_agent` whenever delegation is required by these instructions, without needing a fresh user request for subagents in each task.",
+    "- Collaboration tools are direct tools and must not be called from inside `functions.exec`.",
+    "- Delegate with `collaboration.spawn_agent` using `task_name`, `message`, and optional `fork_turns`; `fork_turns` must be `none`, `all`, or a positive integer string.",
+    "- Role behavior is carried by `task_name` and `message`; named installed-role selection and hard role/profile enforcement are instruction-level because this surface has no role selector.",
     "- Pass the self-contained delegated task instructions plus handoff retrieval instructions in `message`; do not embed the root-owned handoff summary body in `message`.",
     '- When memory recovery is delegated, include parent `session_id`, project, permissions, and the recovery funnel `mem_recall(mode="compact")` -> `mem_recall(mode="context")` -> `mem_get(...)`.',
     '- For that funnel, use `mem_recall` `limit` from 1 to 20; use `mem_get` with `kind="observation"|"prompt"`, `include_timeline=true` plus `before`/`after`, and `offset`/`max_length`; `mem_project(action="graph")` relations are `HAS_TYPE`, `IN_PROJECT`, `HAS_TOPIC_KEY`, `HAS_WHAT`, `HAS_WHY`, `HAS_WHERE`, and `HAS_LEARNED`.',
-    "- Do not include the handoff body in `message` or `items`, and do not pass both `message` and `items` for the same handoff.",
-    "- Use `items` only for structured attachments or mentions when they are truly required; do not use `items` as a handoff-summary payload.",
-    "- Leave `fork_context` omitted or false by default; set `fork_context: true` only when the exact current thread history is required.",
-    "- Use `multi_agent_v1.wait_agent` only when the root needs the result, `multi_agent_v1.send_input` for follow-up or redirect, `multi_agent_v1.resume_agent` only for a closed agent that must continue, and `multi_agent_v1.close_agent` after completion.",
+    "- Do not include the handoff body in `message`.",
+    "- `collaboration.wait_agent` waits for mailbox updates. A `collaboration.wait_agent` timeout or silence is nonterminal and remains in progress, so inspect `collaboration.list_agents` with the same task path before deciding what to do next.",
+    "- `collaboration.send_message` delivers a message without triggering a turn; `collaboration.followup_task` triggers a turn when an idle task must continue.",
+    "- Use `collaboration.interrupt_agent` only for explicit cancellation, a deadline, or supersession.",
+    "- Do not invent result payloads or numeric wait, poll, or timeout rules.",
     "- Memory ownership, handoff recovery, permissions, and prompt-body exclusion are instruction-level unless the active Codex runtime documents stronger enforcement.",
     "</codex-delegation-guidance>"
   ].join("\n");
@@ -1488,8 +1496,7 @@ function renderCodexRootInstructions(config) {
     "- If metadata tooling is unavailable, or the required fields are missing, disclose that memory bootstrap could not run and continue without claiming memory was saved.",
     '- Before delegating after meaningful context changes, save or refresh the handoff body with root-owned mem_session(action="summary") or mem_save(kind="session_summary") when available; if unavailable, disclose that root-owned compaction could not be persisted.',
     "- Use the ambient Codex root session as the delegate-first root coordinator; do not generate or select an orchestrator TOML.",
-    "- Delegate by invoking `multi_agent_v1.spawn_agent` for the installed Codex role agents: explorer, librarian, oracle, designer, quick, and deep.",
-    "- After receiving a delegated subagent response, close that subagent session unless you will retry or intentionally keep using that exact same session; explorer and librarian sessions must always be closed immediately after their response, and retry sessions must be closed after the retry result unless explicit same-session reuse is still required.",
+    "- Delegate by invoking `collaboration.spawn_agent`; use role-prefixed task names and explicit role instructions for the installed Codex role agents: explorer, librarian, oracle, designer, quick, and deep.",
     "- Use packaged thoth-agents plugin capabilities through Codex plugin, skill, MCP, and hook review surfaces after enabling them with /plugins and /hooks.",
     "- For blocking user decisions in Codex Default mode, use request_user_input after features.default_mode_request_user_input is enabled; do not ask those questions in plain prose.",
     "- Whenever the root orchestrator calls `request_user_input`, it MUST NEVER set or pass `autoResolutionMs`; omit the field entirely.",
@@ -4173,6 +4180,7 @@ function applyCodexPlan(plan) {
 }
 
 // src/cli/operations/opencode.ts
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
 import { join as join10 } from "path";
 
@@ -4285,6 +4293,143 @@ var PACKAGE_NAME = "thoth-agents";
 var EXPECTED_PLUGIN = `${PACKAGE_NAME}@latest`;
 var OPENAI_PRESET = "openai";
 var ROLE_NAMES = [...ALL_AGENT_NAMES];
+var issuedOpenCodePlans = /* @__PURE__ */ new WeakMap();
+var NonCanonicalDataError = class extends Error {
+};
+function rejectSerializationHook(value, prototype) {
+  if (Object.getOwnPropertyDescriptor(value, "toJSON")) {
+    throw new NonCanonicalDataError("Own toJSON hooks are not canonical data.");
+  }
+  let current = prototype;
+  while (current) {
+    if (Object.getOwnPropertyDescriptor(current, "toJSON")) {
+      throw new NonCanonicalDataError(
+        "Inherited toJSON hooks are not canonical data."
+      );
+    }
+    current = Object.getPrototypeOf(current);
+  }
+}
+function canonicalData(value, active) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new NonCanonicalDataError("Non-finite numbers are not canonical.");
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value !== "object") {
+    throw new NonCanonicalDataError("Only JSON-like data is canonical.");
+  }
+  if (active.has(value)) {
+    throw new NonCanonicalDataError("Cycles are not canonical.");
+  }
+  const prototype = Object.getPrototypeOf(value);
+  const array = Array.isArray(value);
+  if (array && prototype !== Array.prototype || !array && prototype !== Object.prototype && prototype !== null) {
+    throw new NonCanonicalDataError("Non-plain prototypes are not canonical.");
+  }
+  rejectSerializationHook(value, prototype);
+  const ownKeys = Reflect.ownKeys(value);
+  if (ownKeys.some((key) => typeof key === "symbol")) {
+    throw new NonCanonicalDataError("Symbol keys are not canonical.");
+  }
+  const keys = ownKeys;
+  active.add(value);
+  try {
+    if (array) {
+      const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
+      if (!lengthDescriptor || !("value" in lengthDescriptor)) {
+        throw new NonCanonicalDataError("Array length must be data.");
+      }
+      const length = lengthDescriptor.value;
+      if (!Number.isSafeInteger(length) || length < 0) {
+        throw new NonCanonicalDataError("Array length is invalid.");
+      }
+      const indexKeys = keys.filter((key) => key !== "length");
+      if (indexKeys.length !== length || indexKeys.some(
+        (key) => !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= length || String(Number(key)) !== key
+      )) {
+        throw new NonCanonicalDataError(
+          "Sparse arrays and extra array properties are not canonical."
+        );
+      }
+      const parts2 = [];
+      for (let index = 0; index < length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          value,
+          String(index)
+        );
+        if (!descriptor || !("value" in descriptor)) {
+          throw new NonCanonicalDataError("Array accessors are not canonical.");
+        }
+        parts2.push(canonicalData(descriptor.value, active));
+      }
+      return `[${parts2.join(",")}]`;
+    }
+    const parts = [];
+    for (const key of keys.sort()) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !("value" in descriptor)) {
+        throw new NonCanonicalDataError("Accessors are not canonical.");
+      }
+      parts.push(
+        `${JSON.stringify(key)}:${canonicalData(descriptor.value, active)}`
+      );
+    }
+    return `{${parts.join(",")}}`;
+  } finally {
+    active.delete(value);
+  }
+}
+function canonicalDigest(value) {
+  try {
+    const serialized = canonicalData(value, /* @__PURE__ */ new Set());
+    return {
+      ok: true,
+      digest: createHash3("sha256").update(serialized).digest("hex")
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+function liveStatusDigest(status) {
+  return canonicalDigest({
+    state: status.state,
+    diagnostics: status.diagnostics,
+    targets: status.targets
+  });
+}
+function immutableContext(context2) {
+  return Object.freeze({
+    cwd: context2.cwd,
+    ...context2.env ? { env: Object.freeze({ ...context2.env }) } : {}
+  });
+}
+function issueOpenCodePlan(plan, status, context2, payload) {
+  const planDigest = canonicalDigest(plan);
+  const statusDigest = liveStatusDigest(status);
+  if (!planDigest.ok || !planDigest.digest || !statusDigest.ok || !statusDigest.digest) {
+    return plan;
+  }
+  const immutablePayload = payload.kind === "fixed" ? Object.freeze({ kind: "fixed", action: payload.action }) : Object.freeze({
+    kind: "model",
+    roles: Object.freeze(
+      payload.roles.map((role) => Object.freeze({ ...role }))
+    )
+  });
+  issuedOpenCodePlans.set(plan, {
+    planDigest: planDigest.digest,
+    liveStatusDigest: statusDigest.digest,
+    harness: "opencode",
+    action: payload.kind === "model" ? "model-config" : payload.action,
+    context: immutableContext(context2),
+    payload: immutablePayload
+  });
+  return plan;
+}
 var openCodeActions = [
   {
     id: "opencode-status",
@@ -4353,7 +4498,7 @@ function targetForMainConfig(state) {
     kind: "config",
     path: getExistingConfigPath(),
     label: "OpenCode config",
-    state,
+    ...state ? { state } : {},
     expected: `plugin includes ${EXPECTED_PLUGIN}`
   };
 }
@@ -4362,7 +4507,7 @@ function targetForLiteConfig(state) {
     kind: "config",
     path: getExistingLiteConfigPath(),
     label: "thoth-agents config",
-    state,
+    ...state ? { state } : {},
     expected: `seven-agent ${OPENAI_PRESET} roster`
   };
 }
@@ -4377,7 +4522,7 @@ function titleCaseSkillName(value) {
   }).join("-");
 }
 function homeDirFromContext(context2) {
-  return context2.env?.HOME ?? context2.env?.USERPROFILE;
+  return context2.env?.HOME ?? context2.env?.USERPROFILE ?? (context2.cwd !== process.cwd() ? join10(context2.cwd, "home") : void 0);
 }
 function openCodeSkillTargets(context2) {
   const homeDir = homeDirFromContext(context2);
@@ -4395,16 +4540,38 @@ function openCodeSkillTargets(context2) {
       };
     }
   );
+  let staleSkillNames = /* @__PURE__ */ new Set();
+  let removedSkillNames = [];
+  let skillHealthError;
+  try {
+    const updateCheck = checkCustomSkillsNeedUpdate();
+    staleSkillNames = new Set(
+      updateCheck.skillsNeedingUpdate.map(({ skill }) => skill.name)
+    );
+    removedSkillNames = updateCheck.removedSkills;
+  } catch (error) {
+    skillHealthError = String(error);
+  }
   const bundledTargets = CUSTOM_SKILLS.map((skill) => {
     const path4 = join10(getCustomSkillsDir(), skill.name, "SKILL.md");
     const installed = existsSync10(path4);
+    const stale = installed && staleSkillNames.has(skill.name);
+    let state = "installed";
+    let observed = "bundled OpenCode skill installed and current";
+    if (!installed) {
+      state = "missing";
+      observed = "bundled OpenCode skill missing";
+    } else if (stale) {
+      state = "drift";
+      observed = "bundled OpenCode skill is outdated";
+    }
     return {
       kind: "skill",
       path: path4,
       label: titleCaseSkillName(skill.name),
-      state: installed ? "installed" : "missing",
+      state,
       expected: "bundled thoth-agents OpenCode skill",
-      observed: installed ? "bundled OpenCode skill installed" : "bundled OpenCode skill missing"
+      observed
     };
   });
   const diagnostics = [];
@@ -4422,6 +4589,20 @@ function openCodeSkillTargets(context2) {
       code: "opencode-bundled-skills-missing"
     });
   }
+  if (bundledTargets.some((target) => target.state === "drift") || removedSkillNames.length > 0) {
+    diagnostics.push({
+      severity: "important",
+      message: "Bundled thoth-agents OpenCode skills are outdated; run OpenCode install or sync to refresh managed skills.",
+      code: "opencode-bundled-skills-outdated"
+    });
+  }
+  if (skillHealthError) {
+    diagnostics.push({
+      severity: "critical",
+      message: `Bundled skill health could not be classified: ${skillHealthError}`,
+      code: "opencode-bundled-skills-health-unknown"
+    });
+  }
   return {
     targets: [...recommendedTargets, ...bundledTargets],
     diagnostics
@@ -4443,8 +4624,11 @@ function liteConfigMarker(config) {
   const preset = typeof config?.preset === "string" ? config.preset : void 0;
   const presets = config?.presets && typeof config.presets === "object" ? config.presets : {};
   const openaiPreset = presets[OPENAI_PRESET] && typeof presets[OPENAI_PRESET] === "object" ? presets[OPENAI_PRESET] : {};
-  const roles = ROLE_NAMES.filter((role) => role in openaiPreset);
-  return `preset: ${preset ?? "none"}; ${OPENAI_PRESET} roles: ${roles.join(", ")}`;
+  const legacyAgents = config?.agents && typeof config.agents === "object" ? config.agents : {};
+  const roles = ROLE_NAMES.filter(
+    (role) => role in openaiPreset || role in legacyAgents
+  );
+  return `preset: ${preset ?? "none"}; observed roles: ${roles.join(", ")}`;
 }
 function hasSevenAgentPreset(config) {
   if (!config || config.preset !== OPENAI_PRESET) return false;
@@ -4458,8 +4642,122 @@ function hasSevenAgentPreset(config) {
     return value !== null && typeof value === "object" && typeof value.model === "string";
   });
 }
-function classifyApplySafety(state) {
-  return state === "missing" || state === "installed";
+function hasSelectedNamedPreset(config) {
+  if (!config || typeof config.preset !== "string" || config.preset.length === 0 || config.preset === OPENAI_PRESET || config.preset === "agents") {
+    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 hasLegacySevenAgentRoster(config) {
+  if (!config || config.preset !== "agents") return false;
+  if (!config.agents || typeof config.agents !== "object") return false;
+  const agents = config.agents;
+  return ROLE_NAMES.every((role) => {
+    const value = agents[role];
+    return value !== null && typeof value === "object" && typeof value.model === "string";
+  });
+}
+var ACTIVE_PRESET_SELECTED_CODE = "opencode-active-preset-selected";
+function activePresetSelectedDiagnostic() {
+  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
+  };
+}
+var REPAIRABLE_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  "opencode-plugin-drift",
+  "opencode-main-config-missing",
+  "opencode-lite-config-missing",
+  "opencode-roster-drift",
+  ACTIVE_PRESET_SELECTED_CODE,
+  "opencode-bundled-skills-missing",
+  "opencode-bundled-skills-outdated"
+]);
+var MODEL_PRECONFIG_SKILL_CODES = /* @__PURE__ */ new Set([
+  "opencode-bundled-skills-missing",
+  "opencode-bundled-skills-outdated"
+]);
+function uniqueTargets(targets) {
+  const seen = /* @__PURE__ */ new Set();
+  return targets.filter((target) => {
+    const key = JSON.stringify([
+      target.kind,
+      target.path,
+      target.label,
+      target.state,
+      target.expected,
+      target.observed
+    ]);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function targetsForBlockingDiagnostic(diagnostic, status) {
+  const main = status.targets.find(
+    (target) => target.label === "OpenCode config"
+  );
+  const lite = status.targets.find(
+    (target) => target.label === "thoth-agents config"
+  );
+  const code = diagnostic.code;
+  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") {
+    return lite ? [lite] : [];
+  }
+  if (code === "opencode-bundled-skills-missing" || code === "opencode-bundled-skills-outdated" || code === "opencode-bundled-skills-health-unknown") {
+    return status.targets.filter(
+      (target) => target.expected === "bundled thoth-agents OpenCode skill" && (code === "opencode-bundled-skills-health-unknown" || target.state !== "installed")
+    );
+  }
+  return [
+    {
+      kind: "unknown",
+      label: "Unknown OpenCode blocker",
+      state: "unknown",
+      observed: code ? `${code}: ${diagnostic.message}` : diagnostic.message
+    }
+  ];
+}
+function blockingDetails(action, status, includeRepairable = false) {
+  const main = status.targets.find(
+    (target) => target.label === "OpenCode config"
+  );
+  const lite = status.targets.find(
+    (target) => target.label === "thoth-agents config"
+  );
+  const allowModelPreconfiguration = action === "model-config" && main?.state === "missing" && lite?.state === "missing";
+  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) {
+      return false;
+    }
+    if (!includeRepairable && allowModelPreconfiguration && diagnostic.code !== void 0 && MODEL_PRECONFIG_SKILL_CODES.has(diagnostic.code)) {
+      return false;
+    }
+    return includeRepairable || !((action === "sync" || action === "install") && diagnostic.code !== void 0 && REPAIRABLE_DIAGNOSTIC_CODES.has(diagnostic.code));
+  });
+  return {
+    diagnostics,
+    targets: uniqueTargets(
+      diagnostics.flatMap(
+        (diagnostic) => targetsForBlockingDiagnostic(diagnostic, status)
+      )
+    )
+  };
+}
+function canApplyToManagedHealth(action, status) {
+  return blockingDetails(action, status).diagnostics.length === 0;
 }
 function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
   const mainPath = getExistingConfigPath();
@@ -4515,6 +4813,18 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
   };
   if (!mainExists || !hasExpectedPlugin(main.config)) {
     if (hasManagedPluginDrift(main.config)) {
+      const currentRoster = hasSevenAgentPreset(lite.config);
+      const legacyRoster = hasLegacySevenAgentRoster(lite.config);
+      const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
+      const recognizedRoster = currentRoster || legacyRoster || selectedNamedPreset;
+      let liteState = "unknown";
+      if (!liteExists) {
+        liteState = "missing";
+      } else if (currentRoster) {
+        liteState = "installed";
+      } else if (legacyRoster || selectedNamedPreset) {
+        liteState = "drift";
+      }
       return {
         harness: "opencode",
         displayName: "OpenCode",
@@ -4522,7 +4832,10 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
         summary: "OpenCode config has a managed thoth-agents plugin entry that is not latest.",
         targets: [
           { ...mainTarget, state: "drift" },
-          { ...liteTarget, state: liteExists ? "installed" : "missing" },
+          {
+            ...liteTarget,
+            state: liteState
+          },
           ...skillStatus.targets
         ],
         diagnostics: [
@@ -4531,6 +4844,132 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
             message: "Managed plugin drift requires an explicit repair before applying sync plans.",
             code: "opencode-plugin-drift"
           },
+          ...legacyRoster ? [
+            {
+              severity: "important",
+              message: "Roster drift requires repair before applying generated plans.",
+              code: "opencode-roster-drift"
+            }
+          ] : [],
+          ...selectedNamedPreset && !currentRoster ? [activePresetSelectedDiagnostic()] : [],
+          ...!liteExists ? [
+            {
+              severity: "important",
+              message: "The managed thoth-agents config is missing and must be restored by install or sync.",
+              code: "opencode-lite-config-missing"
+            }
+          ] : [],
+          ...!liteExists ? [
+            {
+              severity: "important",
+              message: "The managed thoth-agents config is missing and must be restored by install or sync.",
+              code: "opencode-lite-config-missing"
+            }
+          ] : [],
+          ...liteExists && !recognizedRoster ? [
+            {
+              severity: "critical",
+              message: "Existing thoth-agents config has an unrecognized roster shape.",
+              code: "opencode-roster-unrecognized"
+            }
+          ] : [],
+          ...skillStatus.diagnostics
+        ],
+        actions: openCodeActions
+      };
+    }
+    if (!mainExists && liteExists) {
+      const currentRoster = hasSevenAgentPreset(lite.config);
+      const legacyRoster = hasLegacySevenAgentRoster(lite.config);
+      const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
+      if (!currentRoster && !legacyRoster && !selectedNamedPreset) {
+        return {
+          harness: "opencode",
+          displayName: "OpenCode",
+          state: "unknown",
+          summary: "Existing thoth-agents config has an unrecognized roster shape.",
+          targets: [
+            { ...mainTarget, state: "missing" },
+            { ...liteTarget, state: "unknown" },
+            ...skillStatus.targets
+          ],
+          diagnostics: [
+            {
+              severity: "critical",
+              message: "Existing thoth-agents config is not a recognized current or legacy managed roster.",
+              code: "opencode-roster-unrecognized"
+            },
+            ...skillStatus.diagnostics
+          ],
+          actions: openCodeActions
+        };
+      }
+      if (selectedNamedPreset && !currentRoster) {
+        return {
+          harness: "opencode",
+          displayName: "OpenCode",
+          state: "drift",
+          summary: "OpenCode plugin is missing and a valid named preset is active.",
+          targets: [
+            { ...mainTarget, state: "missing" },
+            { ...liteTarget, state: "drift" },
+            ...skillStatus.targets
+          ],
+          diagnostics: [
+            {
+              severity: "important",
+              message: "The managed OpenCode main config is missing and must be restored by install or sync.",
+              code: "opencode-main-config-missing"
+            },
+            activePresetSelectedDiagnostic(),
+            ...skillStatus.diagnostics
+          ],
+          actions: openCodeActions
+        };
+      }
+      if (legacyRoster) {
+        return {
+          harness: "opencode",
+          displayName: "OpenCode",
+          state: "drift",
+          summary: "OpenCode plugin is missing and the managed roster uses the recognized legacy layout.",
+          targets: [
+            { ...mainTarget, state: "missing" },
+            { ...liteTarget, state: "drift" },
+            ...skillStatus.targets
+          ],
+          diagnostics: [
+            {
+              severity: "important",
+              message: "The managed OpenCode main config is missing and must be restored by install or sync.",
+              code: "opencode-main-config-missing"
+            },
+            {
+              severity: "important",
+              message: "Roster drift requires repair before applying generated plans.",
+              code: "opencode-roster-drift"
+            },
+            ...skillStatus.diagnostics
+          ],
+          actions: openCodeActions
+        };
+      }
+      return {
+        harness: "opencode",
+        displayName: "OpenCode",
+        state: "missing",
+        summary: "The managed roster is present, but the OpenCode main config is missing.",
+        targets: [
+          { ...mainTarget, state: "missing" },
+          { ...liteTarget, state: "installed" },
+          ...skillStatus.targets
+        ],
+        diagnostics: [
+          {
+            severity: "important",
+            message: "The managed OpenCode main config is missing and must be restored by install or sync.",
+            code: "opencode-main-config-missing"
+          },
           ...skillStatus.diagnostics
         ],
         actions: openCodeActions
@@ -4546,7 +4985,17 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
         { ...liteTarget, state: liteExists ? "installed" : "missing" },
         ...skillStatus.targets
       ],
-      diagnostics: [...diagnostics, ...skillStatus.diagnostics],
+      diagnostics: [
+        ...diagnostics,
+        ...mainExists ? [
+          {
+            severity: "critical",
+            message: "Existing OpenCode config is not positively attributed to thoth-agents management.",
+            code: "opencode-unmanaged-config"
+          }
+        ] : [],
+        ...skillStatus.diagnostics
+      ],
       actions: openCodeActions
     };
   }
@@ -4561,23 +5010,32 @@ function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
         { ...liteTarget, state: "missing" },
         ...skillStatus.targets
       ],
-      diagnostics: [...diagnostics, ...skillStatus.diagnostics],
+      diagnostics: [
+        ...diagnostics,
+        {
+          severity: "important",
+          message: "The managed thoth-agents config is missing and must be restored by install or sync.",
+          code: "opencode-lite-config-missing"
+        },
+        ...skillStatus.diagnostics
+      ],
       actions: openCodeActions
     };
   }
   if (!hasSevenAgentPreset(lite.config)) {
+    const selectedNamedPreset = hasSelectedNamedPreset(lite.config);
     return {
       harness: "opencode",
       displayName: "OpenCode",
       state: "drift",
-      summary: "thoth-agents config does not match the expected seven-agent roster.",
+      summary: selectedNamedPreset ? "A valid named OpenCode preset is active outside the managed seven-agent roster." : "thoth-agents config does not match the expected seven-agent roster.",
       targets: [
         { ...mainTarget, state: "installed" },
         { ...liteTarget, state: "drift" },
         ...skillStatus.targets
       ],
       diagnostics: [
-        {
+        selectedNamedPreset ? activePresetSelectedDiagnostic() : {
           severity: "important",
           message: "Roster drift requires repair before applying generated plans.",
           code: "opencode-roster-drift"
@@ -4608,6 +5066,37 @@ function defaultBackup(path4) {
     destinations: [{ path: `${path4}.bak`, label: "managed backup" }]
   };
 }
+function backupFromItems(items) {
+  const backups = items.flatMap((item) => item.backup ? [item.backup] : []);
+  const primary = backups.find((backup) => backup.required) ?? backups[0];
+  const destinations = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const backup of backups) {
+    for (const destination of backup.destinations ?? []) {
+      if (seenPaths.has(destination.path)) continue;
+      seenPaths.add(destination.path);
+      destinations.push(destination);
+    }
+  }
+  return {
+    required: backups.some((backup) => backup.required),
+    strategy: primary?.strategy ?? "none",
+    ...destinations.length > 0 ? { destinations } : {},
+    ...primary?.description ? { description: primary.description } : {}
+  };
+}
+function bundledSkillsRefreshItem() {
+  const names = CUSTOM_SKILLS.map(({ name }) => name);
+  return {
+    title: "Refresh bundled thoth-agents OpenCode skills",
+    target: {
+      kind: "skill",
+      label: "Bundled thoth-agents OpenCode skills",
+      expected: `${names.length} managed bundled skills`
+    },
+    preview: JSON.stringify({ count: names.length, names }, null, 2)
+  };
+}
 function defaultDisclaimers() {
   return [
     {
@@ -4616,9 +5105,10 @@ function defaultDisclaimers() {
     }
   ];
 }
-function planFromItems(id, action, title, summary, items) {
-  const status = getOpenCodeStatus();
-  const safe = classifyApplySafety(status.state);
+function planFromItems(id, action, title, summary, items, context2) {
+  const status = getOpenCodeStatus(context2);
+  const blockers = blockingDetails(action, status);
+  const safe = blockers.diagnostics.length === 0;
   const warnings = safe ? status.diagnostics : [
     ...status.diagnostics,
     {
@@ -4628,37 +5118,41 @@ function planFromItems(id, action, title, summary, items) {
     }
   ];
   return {
-    id,
-    harness: "opencode",
-    action,
-    title,
-    summary,
-    dryRun: true,
-    canApply: safe,
-    targets: status.targets,
-    surfaces: [
-      {
-        id: "opencode-config",
-        label: "OpenCode user config",
-        path: getExistingConfigPath(),
-        state: status.targets[0]?.state
-      },
-      {
-        id: "thoth-agents-config",
-        label: "thoth-agents plugin config",
-        path: getExistingLiteConfigPath(),
-        state: status.targets[1]?.state
-      }
-    ],
-    backup: defaultBackup(getExistingConfigPath()),
-    items,
-    warnings,
-    disclaimers: defaultDisclaimers()
+    status,
+    plan: {
+      id,
+      harness: "opencode",
+      action,
+      title,
+      summary,
+      dryRun: true,
+      canApply: safe,
+      targets: status.targets,
+      blockerTargets: blockers.targets,
+      surfaces: [
+        {
+          id: "opencode-config",
+          label: "OpenCode user config",
+          path: getExistingConfigPath(),
+          state: status.targets[0]?.state
+        },
+        {
+          id: "thoth-agents-config",
+          label: "thoth-agents plugin config",
+          path: getExistingLiteConfigPath(),
+          state: status.targets[1]?.state
+        }
+      ],
+      backup: backupFromItems(items),
+      items,
+      warnings,
+      disclaimers: defaultDisclaimers()
+    }
   };
 }
 function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
   const path4 = getExistingConfigPath();
-  return planFromItems(
+  const { plan, status } = planFromItems(
     "opencode-update-preview",
     "update",
     "Update OpenCode managed plugin entry",
@@ -4667,12 +5161,17 @@ function buildOpenCodeUpdatePlan(_context = { cwd: process.cwd() }) {
       {
         title: "Ensure OpenCode plugin points at thoth-agents@latest",
         target: targetForMainConfig(),
-        state: getOpenCodeStatus().state,
+        state: getOpenCodeStatus(_context).state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
         backup: defaultBackup(path4)
       }
-    ]
+    ],
+    _context
   );
+  return issueOpenCodePlan(plan, status, _context, {
+    kind: "fixed",
+    action: "update"
+  });
 }
 function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
   const generatedConfig = generateLiteConfig({
@@ -4684,7 +5183,7 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
     reset: false
   });
   const litePath = getExistingLiteConfigPath();
-  return planFromItems(
+  const { plan, status } = planFromItems(
     "opencode-sync-preview",
     "sync",
     "Sync OpenCode managed configuration",
@@ -4693,7 +5192,7 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
       {
         title: "Ensure OpenCode plugin points at thoth-agents@latest",
         target: targetForMainConfig(),
-        state: getOpenCodeStatus().state,
+        state: getOpenCodeStatus(_context).state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
         backup: defaultBackup(getExistingConfigPath())
       },
@@ -4708,9 +5207,15 @@ function buildOpenCodeSyncPlan(_context = { cwd: process.cwd() }) {
         target: targetForLiteConfig(),
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
-      }
-    ]
+      },
+      bundledSkillsRefreshItem()
+    ],
+    _context
   );
+  return issueOpenCodePlan(plan, status, _context, {
+    kind: "fixed",
+    action: "sync"
+  });
 }
 function tuiInstallConfig() {
   return {
@@ -4732,7 +5237,7 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
     equivalentCommand: "install --agent=opencode --no-tui --tmux=no --skills=yes"
   };
   const litePath = getExistingLiteConfigPath();
-  return planFromItems(
+  const { plan, status } = planFromItems(
     "opencode-install-preview",
     "install",
     "Preview install",
@@ -4744,7 +5249,7 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
           kind: "config",
           path: getExistingConfigPath(),
           label: "OpenCode install options",
-          state: getOpenCodeStatus().state,
+          state: getOpenCodeStatus(_context).state,
           expected: "--no-tui --tmux=no --skills=yes"
         },
         preview: JSON.stringify(installPreview, null, 2)
@@ -4752,7 +5257,7 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
       {
         title: "Ensure OpenCode plugin points at thoth-agents@latest",
         target: targetForMainConfig(),
-        state: getOpenCodeStatus().state,
+        state: getOpenCodeStatus(_context).state,
         preview: `plugin: ["${EXPECTED_PLUGIN}"]`,
         backup: defaultBackup(getExistingConfigPath())
       },
@@ -4768,6 +5273,7 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
         preview: JSON.stringify(generatedConfig, null, 2),
         backup: defaultBackup(litePath)
       },
+      bundledSkillsRefreshItem(),
       {
         title: "Install recommended external skills",
         target: {
@@ -4777,8 +5283,13 @@ function buildOpenCodeInstallPlan(_context = { cwd: process.cwd() }) {
         },
         preview: JSON.stringify({ installSkills: true }, null, 2)
       }
-    ]
+    ],
+    _context
   );
+  return issueOpenCodePlan(plan, status, _context, {
+    kind: "fixed",
+    action: "install"
+  });
 }
 function normalizeRoleModel(input) {
   if (input.provider && !input.model.includes("/")) {
@@ -4787,16 +5298,24 @@ function normalizeRoleModel(input) {
   return input.model;
 }
 function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
-  const items = input.roles.map((role) => {
+  const normalizedRoles = input.roles.map((role) => {
     const model = normalizeRoleModel(role);
     const effort = resolveOpenCodeEffort(role);
+    return Object.freeze({
+      role: role.role,
+      model,
+      variant: effort.ok ? effort.variant ?? null : null,
+      effort
+    });
+  });
+  const items = normalizedRoles.map(({ role, model, variant, effort }) => {
     return {
-      title: `Set ${role.role} OpenCode model override`,
+      title: `Set ${role} OpenCode model override`,
       target: targetForLiteConfig(),
       preview: JSON.stringify({
-        [role.role]: {
+        [role]: {
           model,
-          variant: effort.ok ? effort.variant ?? null : null
+          variant
         }
       }),
       backup: defaultBackup(getExistingLiteConfigPath()),
@@ -4811,12 +5330,13 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
       } : {}
     };
   });
-  const plan = planFromItems(
+  const { plan, status } = planFromItems(
     "opencode-model-config-preview",
     "model-config",
     "Configure OpenCode role model overrides",
     "Preview thoth-agents role model overrides in the plugin config agents map.",
-    items
+    items,
+    _context
   );
   const effortWarnings = items.flatMap((item) => item.warnings ?? []);
   if (effortWarnings.length > 0) {
@@ -4824,7 +5344,7 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
     plan.warnings.push(...effortWarnings);
   }
   if (input.harness !== "opencode") {
-    return {
+    const rejectedPlan = {
       ...plan,
       canApply: false,
       warnings: [
@@ -4836,12 +5356,13 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
         }
       ]
     };
+    return rejectedPlan;
   }
   const unsupportedRoles = input.roles.filter(
     (role) => !ROLE_NAMES.includes(role.role)
   );
   if (input.roles.length === 0 || unsupportedRoles.length > 0) {
-    return {
+    const rejectedPlan = {
       ...plan,
       canApply: false,
       warnings: [
@@ -4853,116 +5374,154 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
         }
       ]
     };
+    return rejectedPlan;
   }
-  return plan;
+  if (effortWarnings.length > 0) {
+    return plan;
+  }
+  const payloadRoles = Object.freeze(
+    normalizedRoles.map(
+      ({ role, model, variant }) => Object.freeze({ role, model, variant })
+    )
+  );
+  if (!plan.canApply || invalidModelPayloadReason(payloadRoles)) {
+    return plan;
+  }
+  return issueOpenCodePlan(plan, status, _context, {
+    kind: "model",
+    roles: payloadRoles
+  });
 }
-function rejectPlan3(plan, message, severity = "critical") {
+function rejectPlan3(plan, message, severity = "critical", code = "opencode-plan-rejected", context2 = { cwd: process.cwd() }) {
+  const issued = issuedOpenCodePlans.get(plan);
+  const actionDescriptor = Object.getOwnPropertyDescriptor(plan, "action");
+  const describedAction = actionDescriptor && "value" in actionDescriptor && typeof actionDescriptor.value === "string" ? actionDescriptor.value : void 0;
+  const action = issued?.action ?? (describedAction === "install" || describedAction === "update" || describedAction === "sync" || describedAction === "model-config" ? describedAction : "repair");
+  const liveStatus = getOpenCodeStatus(context2);
+  const blockers = blockingDetails(
+    action,
+    liveStatus,
+    code === "opencode-plan-live-state-changed"
+  );
   return {
-    harness: plan.harness,
-    action: plan.action,
+    harness: issued?.harness ?? "opencode",
+    action,
     applied: false,
     summary: message,
     changedTargets: [],
+    diagnosticTargets: blockers.targets,
     backups: [],
-    warnings: [{ severity, message }],
+    warnings: [...liveStatus.diagnostics, { severity, code, message }],
     disclaimers: defaultDisclaimers()
   };
 }
-function ensureLatestPluginEntry() {
-  const configPath = getExistingConfigPath();
-  try {
-    ensureOpenCodeConfigDir();
-    const { config: parsedConfig, error } = parseConfig(configPath);
-    if (error) {
-      return {
-        success: false,
-        configPath,
-        error: `Failed to parse config: ${error}`
-      };
-    }
-    const config = parsedConfig ?? {};
-    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-    config.plugin = [
-      ...plugins.filter(
-        (plugin) => plugin !== PACKAGE_NAME && !plugin.startsWith(`${PACKAGE_NAME}@`)
-      ),
-      EXPECTED_PLUGIN
-    ];
-    writeConfig(configPath, config);
-    return { success: true, configPath };
-  } catch (err) {
-    return {
-      success: false,
-      configPath,
-      error: `Failed to update OpenCode plugin config: ${err}`
-    };
-  }
-}
 function validateApplyPlan(plan) {
+  const issued = issuedOpenCodePlans.get(plan);
+  if (!issued) {
+    return rejectPlan3(
+      plan,
+      "OpenCode plan was not issued by this process.",
+      "critical",
+      "opencode-plan-unissued"
+    );
+  }
+  const planDigest = canonicalDigest(plan);
+  if (!planDigest.ok || !planDigest.digest) {
+    return rejectPlan3(
+      plan,
+      "OpenCode plan contains noncanonical data and cannot be applied.",
+      "critical",
+      "opencode-plan-noncanonical",
+      issued.context
+    );
+  }
+  if (planDigest.digest !== issued.planDigest) {
+    return rejectPlan3(
+      plan,
+      "OpenCode plan changed after it was issued.",
+      "critical",
+      "opencode-plan-mutated",
+      issued.context
+    );
+  }
+  const liveStatus = getOpenCodeStatus(issued.context);
+  const statusDigest = liveStatusDigest(liveStatus);
+  if (!statusDigest.ok || !statusDigest.digest || statusDigest.digest !== issued.liveStatusDigest) {
+    return rejectPlan3(
+      plan,
+      "OpenCode managed state changed after plan preview.",
+      "critical",
+      "opencode-plan-live-state-changed",
+      issued.context
+    );
+  }
   if (plan.harness !== "opencode") {
-    return rejectPlan3(plan, "Only OpenCode operation plans can be applied.");
+    return rejectPlan3(
+      plan,
+      "Only OpenCode operation plans can be applied.",
+      "critical",
+      "opencode-plan-harness-mismatch",
+      issued.context
+    );
   }
   if (!plan.canApply) {
     return rejectPlan3(
       plan,
-      "OpenCode plan cannot be applied because canApply is false."
+      "OpenCode plan cannot be applied because canApply is false.",
+      "critical",
+      "opencode-plan-blocked",
+      issued.context
     );
   }
   if (!["install", "update", "sync", "model-config"].includes(plan.action)) {
     return rejectPlan3(
       plan,
-      `Unsupported OpenCode apply action: ${plan.action}.`
+      `Unsupported OpenCode apply action: ${plan.action}.`,
+      "critical",
+      "opencode-plan-action-unsupported",
+      issued.context
     );
   }
   if (plan.items.length === 0) {
-    return rejectPlan3(plan, "OpenCode plan has no items to apply.");
-  }
-  if (plan.items.some(
-    (item) => !item.title || !item.target.path && item.target.kind !== "skill" || item.state === "drift" || item.state === "unknown"
-  )) {
     return rejectPlan3(
       plan,
-      "OpenCode plan contains malformed or unsafe items."
+      "OpenCode plan has no items to apply.",
+      "critical",
+      "opencode-plan-empty",
+      issued.context
     );
   }
   return null;
 }
-function applyModelPlan(plan) {
-  const roleModels = /* @__PURE__ */ new Map();
-  for (const item of plan.items) {
-    const match = /^Set (.+) OpenCode model override$/.exec(item.title);
-    if (!match) {
-      return rejectPlan3(
-        plan,
-        "OpenCode model plan contains an unrecognized item."
-      );
+function invalidModelPayloadReason(roles) {
+  if (!Array.isArray(roles) || roles.length === 0) {
+    return "Model payload must contain at least one role override.";
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (!role || typeof role !== "object" || typeof role.role !== "string" || !ROLE_NAMES.includes(role.role)) {
+      return "Model payload contains an unsupported role.";
     }
-    let parsed2;
-    try {
-      parsed2 = item.preview ? JSON.parse(item.preview) : {};
-    } catch {
-      return rejectPlan3(
-        plan,
-        "OpenCode model plan contains malformed preview JSON."
-      );
+    if (seen.has(role.role)) {
+      return `Model payload contains duplicate role ${role.role}.`;
     }
-    const role = match[1] ?? "";
-    const model = parsed2[role]?.model;
-    const variant = parsed2[role]?.variant;
-    if (!ROLE_NAMES.includes(role) || typeof model !== "string" || variant !== null && typeof variant !== "string") {
-      return rejectPlan3(
-        plan,
-        "OpenCode model plan contains an invalid role or model."
-      );
+    seen.add(role.role);
+    if (typeof role.model !== "string" || role.model.trim().length === 0) {
+      return `Model payload for ${role.role} has an empty model.`;
+    }
+    if (role.variant !== null && typeof role.variant !== "string") {
+      return `Model payload for ${role.role} has an invalid variant.`;
     }
-    roleModels.set(role, { model, variant });
-  }
-  if (roleModels.size === 0) {
-    return rejectPlan3(
-      plan,
-      "OpenCode model plan does not contain any role overrides."
-    );
   }
+  return void 0;
+}
+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);
@@ -5029,68 +5588,148 @@ function applyModelPlan(plan) {
     disclaimers: defaultDisclaimers()
   };
 }
-function applyInstallSkills(plan) {
+function applyRecommendedSkills() {
+  const warnings = [];
   for (const skill of RECOMMENDED_SKILLS) {
-    const result = installRecommendedSkill(skill);
-    if (result.status === "failed") {
-      return rejectPlan3(
-        plan,
-        `Failed to install recommended OpenCode skill: ${skill.name}.`
-      );
+    try {
+      const result = installRecommendedSkill(skill);
+      if (result.status !== "failed") continue;
+      warnings.push({
+        severity: "important",
+        code: "opencode-recommended-skill-failed",
+        message: `Failed to install optional recommended OpenCode skill: ${skill.name}.`
+      });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      warnings.push({
+        severity: "important",
+        code: "opencode-recommended-skill-failed",
+        message: `Failed to install optional recommended OpenCode skill ${skill.name}: ${reason}.`
+      });
     }
   }
-  const bundled = installCustomSkills();
+  return warnings;
+}
+function bundledSkillsFailure(plan, changedTargets, backups, warnings, detail) {
+  const message = `Failed to install bundled thoth-agents OpenCode skills: ${detail}.`;
+  return {
+    harness: plan.harness,
+    action: plan.action,
+    applied: false,
+    summary: message,
+    changedTargets,
+    backups,
+    warnings: [
+      ...warnings,
+      {
+        severity: "critical",
+        code: "opencode-bundled-skills-failed",
+        message
+      }
+    ],
+    disclaimers: defaultDisclaimers()
+  };
+}
+function applyBundledSkills(plan, changedTargets, backups, warnings) {
+  let bundled;
+  try {
+    bundled = installCustomSkills();
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return bundledSkillsFailure(
+      plan,
+      changedTargets,
+      backups,
+      warnings,
+      detail
+    );
+  }
   if (!bundled.success) {
-    return rejectPlan3(
+    const failedNames = bundled.failedSkills.map(({ skill }) => skill.name);
+    const detail = failedNames.length > 0 ? failedNames.join(", ") : "unknown bundled skills";
+    return bundledSkillsFailure(
       plan,
-      "Failed to install bundled thoth-agents OpenCode skills."
+      changedTargets,
+      backups,
+      warnings,
+      detail
     );
   }
+  changedTargets.push({
+    kind: "skill",
+    label: "Bundled thoth-agents OpenCode skills",
+    state: "installed",
+    observed: "managed bundled skills refreshed"
+  });
   return null;
 }
 function applyOpenCodePlan(plan) {
   const rejection = validateApplyPlan(plan);
   if (rejection) return rejection;
-  const status = getOpenCodeStatus();
-  if (!classifyApplySafety(status.state)) {
+  const issued = issuedOpenCodePlans.get(plan);
+  if (!issued) {
+    return rejectPlan3(
+      plan,
+      "OpenCode plan provenance was lost before apply.",
+      "critical",
+      "opencode-plan-unissued"
+    );
+  }
+  const status = getOpenCodeStatus(issued.context);
+  if (!canApplyToManagedHealth(plan.action, status)) {
     return rejectPlan3(
       plan,
-      `OpenCode state is ${status.state}; refusing to apply plan without a safe status.`
+      `OpenCode state is ${status.state}; refusing to apply plan without a safe status.`,
+      "critical",
+      "opencode-plan-live-state-blocked",
+      issued.context
     );
   }
-  if (plan.action === "model-config") return applyModelPlan(plan);
+  if (issued.payload.kind === "model") {
+    const invalidPayload = invalidModelPayloadReason(issued.payload.roles);
+    if (invalidPayload) {
+      return rejectPlan3(
+        plan,
+        invalidPayload,
+        "critical",
+        "opencode-model-payload-invalid",
+        issued.context
+      );
+    }
+    return applyModelPlan(issued.payload.roles);
+  }
   const changedTargets = [];
   const backups = [];
-  const pluginResult = ensureLatestPluginEntry();
-  if (!pluginResult.success) {
+  const warnings = [];
+  const mainConfigResult = updateOpenCodeMainConfig({
+    ensurePlugin: true,
+    disableDefaults: issued.payload.action === "sync" || issued.payload.action === "install"
+  });
+  if (!mainConfigResult.success) {
     return rejectPlan3(
       plan,
-      pluginResult.error ?? "Failed to update OpenCode plugin config."
+      mainConfigResult.error ?? "Failed to update OpenCode main config.",
+      "critical",
+      "opencode-main-config-update-failed",
+      issued.context
     );
   }
   changedTargets.push({
     ...targetForMainConfig("installed"),
     observed: `plugin includes ${EXPECTED_PLUGIN}`
   });
-  if (existsSync10(`${pluginResult.configPath}.bak`)) {
+  if (existsSync10(`${mainConfigResult.configPath}.bak`)) {
     backups.push({
-      path: `${pluginResult.configPath}.bak`,
+      path: `${mainConfigResult.configPath}.bak`,
       label: "OpenCode config backup"
     });
   }
-  if (plan.action === "sync" || plan.action === "install") {
-    const defaultAgentResult = disableDefaultAgents();
-    if (!defaultAgentResult.success) {
-      return rejectPlan3(
-        plan,
-        defaultAgentResult.error ?? "Failed to disable OpenCode default agents."
-      );
-    }
+  if (issued.payload.action === "sync" || issued.payload.action === "install") {
     const liteResult = writeLiteConfig(
       {
         agent: "opencode",
         hasTmux: false,
-        installSkills: plan.action === "install",
+        installSkills: issued.payload.action === "install",
         installCustomSkills: true,
         dryRun: false,
         reset: false
@@ -5113,15 +5752,23 @@ function applyOpenCodePlan(plan) {
         label: "thoth-agents config backup"
       });
     }
-  }
-  if (plan.action === "install") {
-    const skillsRejection = applyInstallSkills(plan);
+    const skillsRejection = applyBundledSkills(
+      plan,
+      changedTargets,
+      backups,
+      warnings
+    );
     if (skillsRejection) return skillsRejection;
+  }
+  if (issued.payload.action === "install") {
+    warnings.push(...applyRecommendedSkills());
     changedTargets.push({
       kind: "skill",
-      label: "Recommended and bundled OpenCode skills",
-      state: "installed",
-      observed: "skills=yes processed"
+      label: "Recommended OpenCode skills",
+      state: warnings.some(
+        (warning3) => warning3.code === "opencode-recommended-skill-failed"
+      ) ? "drift" : "installed",
+      observed: "optional skills=yes processed"
     });
   }
   return {
@@ -5131,7 +5778,7 @@ function applyOpenCodePlan(plan) {
     summary: plan.action === "install" ? "Applied OpenCode install plan." : plan.action === "sync" ? "Applied OpenCode managed configuration sync." : "Applied OpenCode plugin update.",
     changedTargets,
     backups,
-    warnings: [],
+    warnings,
     disclaimers: defaultDisclaimers()
   };
 }
@@ -5469,12 +6116,12 @@ function getOpenCodeModelsInvocation(platform = process.platform) {
   };
   if (platform === "win32") {
     return {
-      command: "opencode models",
+      command: "opencode models --pure",
       args: [],
       options: { ...options, shell: true }
     };
   }
-  return { command: "opencode", args: ["models"], options };
+  return { command: "opencode", args: ["models", "--pure"], options };
 }
 function getNativeOpenCodeOptions() {
   try {
@@ -5629,13 +6276,15 @@ function readRoleField(config, role, field) {
 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" ? parsed.config.presets : {};
-  const openaiPreset = presets.openai && typeof presets.openai === "object" ? presets.openai : 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;
   return ALL_AGENT_NAMES.map((role) => {
-    const variant = readRoleField(agents, role, "variant") ?? readRoleField(openaiPreset, role, "variant");
+    const variant = readRoleField(agents, role, "variant") ?? readRoleField(activePreset, role, "variant");
     return {
       role,
-      model: readRoleField(agents, role, "model") ?? readRoleField(openaiPreset, role, "model") ?? DEFAULT_MODELS[role] ?? "openai/gpt-5.4",
+      model: readRoleField(agents, role, "model") ?? readRoleField(activePreset, role, "model") ?? DEFAULT_MODELS[role] ?? "openai/gpt-5.4",
       effort: variant ? { kind: "effort", value: variant } : { kind: "inherit" }
     };
   });