thoth-agents 0.11.0 → 0.13.0

package/dist/{chunk-DNPKVFOB.js → chunk-YCWGTDFE.js}

@@ -19,19 +19,107 @@ function findPackageRoot(startDir) {
   }
 }
 
-// src/config/loader.ts
-import * as fs from "fs";
-import * as path from "path";
+// src/config/schema.ts
+import { z } from "zod";
+var AGENT_NAMES = [
+  "orchestrator",
+  "oracle",
+  "designer",
+  "explorer",
+  "librarian",
+  "worker"
+];
+var FALLBACK_AGENT_NAMES = [...AGENT_NAMES];
+var MANUAL_AGENT_NAMES = [...AGENT_NAMES];
+var ProviderModelIdSchema = z.string().regex(
+  /^[^/\s]+\/[^\s]+$/,
+  "Expected provider/model format (provider/.../model)"
+);
+var ManualAgentPlanSchema = z.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = /* @__PURE__ */ new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = z.object({
+  orchestrator: ManualAgentPlanSchema,
+  oracle: ManualAgentPlanSchema,
+  designer: ManualAgentPlanSchema,
+  explorer: ManualAgentPlanSchema,
+  librarian: ManualAgentPlanSchema,
+  worker: ManualAgentPlanSchema
+}).strict();
+var AgentModelChainSchema = z.array(z.string()).min(1);
+var SupportedAgentRecordKeySchema = z.string().regex(/^(?!quick$|deep$).+$/, "Unsupported removed agent role");
+var FallbackChainsSchema = z.record(
+  SupportedAgentRecordKeySchema,
+  AgentModelChainSchema
+);
+var AgentOverrideConfigSchema = z.object({
+  model: z.union([
+    z.string(),
+    z.array(
+      z.union([
+        z.string(),
+        z.object({
+          id: z.string(),
+          variant: z.string().optional()
+        })
+      ])
+    )
+  ]).optional(),
+  /** Pi specialist catalog filter; omitted discovers all, [] discovers none. */
+  skills: z.array(z.string().trim().min(1)).optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  steps: z.number().int().min(1).optional(),
+  variant: z.string().optional().catch(void 0)
+});
+var AgentNameSchema = z.enum(AGENT_NAMES);
+var McpNameSchema = z.enum(["exa", "context7", "grep_app"]);
+var CodexGenerationConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  outputRoot: z.string().optional(),
+  dryRun: z.boolean().default(true)
+});
+var ClaudeCodeGenerationConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  outputRoot: z.string().optional(),
+  dryRun: z.boolean().default(true)
+});
+var FailoverConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  timeoutMs: z.number().min(0).default(15e3),
+  retryDelayMs: z.number().min(0).default(500),
+  chains: FallbackChainsSchema.default({})
+});
+var PluginConfigSchema = z.object({
+  $schema: z.string().optional(),
+  setDefaultAgent: z.boolean().optional(),
+  scoringEngineVersion: z.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: z.boolean().optional(),
+  manualPlan: ManualPlanSchema.optional(),
+  agents: z.record(SupportedAgentRecordKeySchema, AgentOverrideConfigSchema).optional(),
+  disabled_mcps: z.array(z.string()).optional(),
+  fallback: FailoverConfigSchema.optional(),
+  codex: CodexGenerationConfigSchema.optional(),
+  claudeCode: ClaudeCodeGenerationConfigSchema.optional()
+});
 
-// src/cli/config-io.ts
-import {
-  copyFileSync,
-  existsSync as existsSync3,
-  readFileSync as readFileSync2,
-  renameSync,
-  statSync,
-  writeFileSync
-} from "fs";
+// src/opencode/profiles/types.ts
+var PROFILE_ROLES = AgentNameSchema.options;
 
 // src/config/constants.ts
 var SUBAGENT_NAMES = [
@@ -99,10 +187,305 @@ function getDefaultOpenCodeVariant(name) {
   }
   return CONFIRMED_OPENAI_SUBAGENT_PRESET[name].effort;
 }
-var POLL_INTERVAL_BACKGROUND_MS = 2e3;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1e3;
 var MAX_POLL_TIME_MS = 5 * 60 * 1e3;
 
+// src/opencode/profiles/resolver.ts
+function configuredModelChain(config) {
+  const models = config?.model;
+  return (typeof models === "string" ? [models] : models ?? []).map(
+    (entry) => {
+      const value = typeof entry === "string" ? { id: entry } : { ...entry };
+      const variant = Array.isArray(models) ? value.variant : config?.variant;
+      return { ...value, ...variant ? { variant } : {} };
+    }
+  );
+}
+function resolveModelPair(config, inherited = {}) {
+  const first = configuredModelChain(config)[0];
+  const model = first?.id ?? inherited.model;
+  const variant = config?.model !== void 0 ? first?.variant : config?.variant ?? inherited.variant;
+  return { ...model ? { model } : {}, ...variant ? { variant } : {} };
+}
+function resolveRoleProfile(role, profile, roster) {
+  return resolveModelPair(profile.agents[role], resolveModelPair(roster[role]));
+}
+function defaultModelProfile(roster) {
+  return {
+    agents: Object.fromEntries(
+      PROFILE_ROLES.map((role) => [
+        role,
+        resolveRoleProfile(role, { agents: {} }, roster)
+      ])
+    )
+  };
+}
+function mergeProfileModelChain(profile, configured) {
+  const entries = profile.model ? [
+    {
+      id: profile.model,
+      ...profile.variant ? { variant: profile.variant } : {}
+    },
+    ...configured
+  ] : configured;
+  const seen = /* @__PURE__ */ new Set();
+  return entries.filter(({ id }) => {
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  }).map((entry) => ({ ...entry }));
+}
+function formatModelString(profile) {
+  return profile.model ? `${profile.model}${profile.variant ? `#${profile.variant}` : ""}` : void 0;
+}
+
+// src/opencode/profiles/store.ts
+import { randomUUID } from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { isDeepStrictEqual } from "util";
+var DEFAULT_PROFILE = "default";
+function modelProfilePaths(options) {
+  if (options.paths) return { ...options.paths };
+  const env = options.env ?? process.env;
+  const configDir = options.configDir ?? (env.OPENCODE_CONFIG_DIR?.trim() || path.join(
+    env.XDG_CONFIG_HOME || path.join(options.homeDir ?? os.homedir(), ".config"),
+    "opencode"
+  ));
+  return {
+    global: path.join(configDir, "thoth", "profiles.json"),
+    project: path.join(options.cwd, ".opencode", "thoth", "profiles.json")
+  };
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateProfileName(value, writable = false) {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error("Profile name must be non-empty");
+  const name = value.trim();
+  if (writable && name === DEFAULT_PROFILE)
+    throw new Error("default is a reserved read-only virtual profile");
+  return name;
+}
+function parseRoleProfile(value) {
+  if (!object(value)) throw new Error("Role override must be an object");
+  if (value.model !== void 0 && (typeof value.model !== "string" || !/^[^/\s#]+\/[^\s#]+$/.test(value.model)))
+    throw new Error("Invalid model; expected provider/id without #variant");
+  if (value.variant !== void 0 && (typeof value.variant !== "string" || !/^[^\s#]+$/.test(value.variant)))
+    throw new Error(
+      "Invalid variant; expected a non-empty string without whitespace or #"
+    );
+  return {
+    ...value.model !== void 0 ? { model: value.model } : {},
+    ...value.variant !== void 0 ? { variant: value.variant } : {}
+  };
+}
+function parseNamedModelProfile(value) {
+  if (!object(value) || !object(value.agents))
+    throw new Error("Profile must contain an agents object");
+  const agents = {};
+  for (const [role, override] of Object.entries(value.agents)) {
+    const canonical = PROFILE_ROLES.find((name) => name === role);
+    if (!canonical) throw new Error(`Unknown profile role: ${role}`);
+    agents[canonical] = parseRoleProfile(override);
+  }
+  return { agents };
+}
+function parseModelProfilesDocument(raw) {
+  if (!object(raw) || raw.version !== 1 || !object(raw.profiles))
+    throw new Error("Expected version 1 and a profiles object");
+  const profiles = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(raw.profiles)) {
+    const name = validateProfileName(key, true);
+    if (Object.hasOwn(profiles, name))
+      throw new Error(`Duplicate profile: ${name}`);
+    profiles[name] = parseNamedModelProfile(value);
+  }
+  return {
+    version: 1,
+    ...raw.active !== void 0 ? { active: validateProfileName(raw.active) } : {},
+    profiles
+  };
+}
+var emptyDocument = () => ({
+  version: 1,
+  profiles: /* @__PURE__ */ Object.create(null)
+});
+var ProfileConflictError = class extends Error {
+  constructor(scope, profileName) {
+    super(
+      `Profile changed on disk: ${scope}:${profileName}; reload before saving.`
+    );
+    this.scope = scope;
+    this.profileName = profileName;
+    this.name = "ProfileConflictError";
+  }
+  scope;
+  profileName;
+  code = "PROFILE_CONFLICT";
+};
+var ModelProfileStore = class {
+  constructor(options) {
+    this.options = options;
+    this.paths = modelProfilePaths(options);
+  }
+  options;
+  paths;
+  defaultProfile() {
+    return defaultModelProfile(this.options.roster ?? {});
+  }
+  load(scope) {
+    try {
+      return parseModelProfilesDocument(
+        JSON.parse(fs.readFileSync(this.paths[scope], "utf8"))
+      );
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return emptyDocument();
+      throw new Error(
+        `Cannot read model profiles ${this.paths[scope]}: ${String(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  read(scope, warnings = []) {
+    try {
+      return this.load(scope);
+    } catch (error) {
+      const warning = String(error);
+      warnings.push(warning);
+      this.options.warn?.(warning);
+      return emptyDocument();
+    }
+  }
+  lookup(name, scope) {
+    const key = validateProfileName(name);
+    if (key === DEFAULT_PROFILE) return { profile: this.defaultProfile() };
+    for (const source of scope ? [scope] : ["project", "global"]) {
+      const profiles = this.read(source).profiles;
+      if (Object.hasOwn(profiles, key))
+        return { profile: profiles[key], scope: source };
+    }
+    return void 0;
+  }
+  write(scope, document) {
+    const validated = parseModelProfilesDocument(document);
+    const file = this.paths[scope];
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${randomUUID()}.tmp`;
+    try {
+      fs.writeFileSync(temp, `${JSON.stringify(validated, null, 2)}
+`, {
+        encoding: "utf8",
+        flag: "wx"
+      });
+      fs.renameSync(temp, file);
+    } finally {
+      if (fs.existsSync(temp)) fs.unlinkSync(temp);
+    }
+  }
+  /** Re-read before writing. An expected baseline enables same-profile conflict detection. */
+  save(scope, name, value, options = {}) {
+    const key = validateProfileName(name, true);
+    const next = parseNamedModelProfile(value);
+    const document = this.load(scope);
+    const existing = Object.hasOwn(document.profiles, key) ? document.profiles[key] : null;
+    if (Object.hasOwn(options, "expected") && !isDeepStrictEqual(existing, options.expected))
+      throw new ProfileConflictError(scope, key);
+    document.profiles[key] = next;
+    this.write(scope, document);
+  }
+  create(scope, name, value) {
+    const key = validateProfileName(name, true);
+    if (Object.hasOwn(this.load(scope).profiles, key))
+      throw new Error(`Profile already exists: ${key}`);
+    this.save(scope, key, value, { expected: null });
+  }
+  /** Pins that actually resolved to a global profile follow rename/delete. */
+  projectPointsToGlobal(name) {
+    const project = this.load("project");
+    return project.active === name && !Object.hasOwn(project.profiles, name);
+  }
+  rename(scope, source, target) {
+    const from = validateProfileName(source, true);
+    const to = validateProfileName(target, true);
+    const document = this.load(scope);
+    if (!Object.hasOwn(document.profiles, from))
+      throw new Error(`Profile not found: ${from}`);
+    if (Object.hasOwn(document.profiles, to))
+      throw new Error(`Profile already exists: ${to}`);
+    const followPin = scope === "global" && this.projectPointsToGlobal(from);
+    document.profiles[to] = document.profiles[from];
+    delete document.profiles[from];
+    if (document.active === from) document.active = to;
+    this.write(scope, document);
+    if (followPin) this.setProjectPin(to);
+  }
+  delete(scope, name) {
+    const key = validateProfileName(name, true);
+    const document = this.load(scope);
+    if (!Object.hasOwn(document.profiles, key))
+      throw new Error(`Profile not found: ${key}`);
+    const clearPin = scope === "global" && this.projectPointsToGlobal(key);
+    delete document.profiles[key];
+    const clearedActive = document.active === key;
+    if (clearedActive) delete document.active;
+    this.write(scope, document);
+    if (clearPin) this.setProjectPin();
+    return { clearedActive };
+  }
+  setActive(scope, name) {
+    const document = this.load(scope);
+    if (name === void 0) delete document.active;
+    else {
+      const key = validateProfileName(name);
+      if (key !== DEFAULT_PROFILE && !(scope === "global" ? Object.hasOwn(document.profiles, key) : this.lookup(key)))
+        throw new Error(`Profile not found: ${key}`);
+      document.active = key;
+    }
+    this.write(scope, document);
+  }
+  setGlobalActive(name) {
+    this.setActive("global", name);
+  }
+  setProjectPin(name) {
+    this.setActive("project", name);
+  }
+  resolve(sessionSelection) {
+    const warnings = [];
+    const documents = {
+      global: this.read("global", warnings),
+      project: this.read("project", warnings)
+    };
+    for (const [level, name] of [
+      ["session", sessionSelection],
+      ["project", documents.project.active],
+      ["global", documents.global.active]
+    ]) {
+      if (!name) continue;
+      if (name === DEFAULT_PROFILE)
+        return { name, profile: this.defaultProfile(), warnings };
+      const scope = Object.hasOwn(documents.project.profiles, name) ? "project" : "global";
+      if (Object.hasOwn(documents[scope].profiles, name) && (level !== "global" || Object.hasOwn(documents.global.profiles, name)))
+        return {
+          name,
+          scope,
+          profile: documents[scope].profiles[name],
+          warnings
+        };
+      const warning = `Missing ${level} model profile "${name}"; falling back.`;
+      warnings.push(warning);
+      this.options.warn?.(warning);
+    }
+    return { name: DEFAULT_PROFILE, profile: this.defaultProfile(), warnings };
+  }
+};
+
+// src/opencode/profiles/editor.ts
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+
 // src/cli/package-version.ts
 import { readFileSync } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
@@ -195,27 +578,41 @@ function resolveExecutingPackageVersion(options = {}) {
   return { ok: true, version, packageRoot };
 }
 
+// src/config/loader.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/cli/config-io.ts
+import {
+  copyFileSync,
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+
 // src/cli/paths.ts
 import { existsSync as existsSync2, mkdirSync } from "fs";
 import { homedir } from "os";
 import { dirname as dirname3, join as join3 } from "path";
-function getDefaultOpenCodeConfigDir() {
-  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join3(homedir(), ".config");
+function getDefaultOpenCodeConfigDir(homeDir) {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join3(homeDir, ".config");
   return join3(userConfigDir, "opencode");
 }
 function getCustomOpenCodeConfigDir() {
   const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   return configDir || void 0;
 }
-function getConfigDir() {
+function getConfigDir(homeDir = homedir()) {
   const customConfigDir = getCustomOpenCodeConfigDir();
   if (customConfigDir) {
     return customConfigDir;
   }
-  return getDefaultOpenCodeConfigDir();
+  return getDefaultOpenCodeConfigDir(homeDir);
 }
 function getOpenCodeConfigPaths() {
-  const configDir = getDefaultOpenCodeConfigDir();
+  const configDir = getConfigDir();
   return [join3(configDir, "opencode.json"), join3(configDir, "opencode.jsonc")];
 }
 function getConfigJson() {
@@ -260,130 +657,6 @@ function ensureOpenCodeConfigDir() {
   }
 }
 
-// src/config/schema.ts
-import { z } from "zod";
-var AGENT_NAMES = [
-  "orchestrator",
-  "oracle",
-  "designer",
-  "explorer",
-  "librarian",
-  "worker"
-];
-var FALLBACK_AGENT_NAMES = [...AGENT_NAMES];
-var MANUAL_AGENT_NAMES = [...AGENT_NAMES];
-var ProviderModelIdSchema = z.string().regex(
-  /^[^/\s]+\/[^\s]+$/,
-  "Expected provider/model format (provider/.../model)"
-);
-var ManualAgentPlanSchema = z.object({
-  primary: ProviderModelIdSchema,
-  fallback1: ProviderModelIdSchema,
-  fallback2: ProviderModelIdSchema,
-  fallback3: ProviderModelIdSchema
-}).superRefine((value, ctx) => {
-  const unique = /* @__PURE__ */ new Set([
-    value.primary,
-    value.fallback1,
-    value.fallback2,
-    value.fallback3
-  ]);
-  if (unique.size !== 4) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "primary and fallbacks must be unique per agent"
-    });
-  }
-});
-var ManualPlanSchema = z.object({
-  orchestrator: ManualAgentPlanSchema,
-  oracle: ManualAgentPlanSchema,
-  designer: ManualAgentPlanSchema,
-  explorer: ManualAgentPlanSchema,
-  librarian: ManualAgentPlanSchema,
-  worker: ManualAgentPlanSchema
-}).strict();
-var AgentModelChainSchema = z.array(z.string()).min(1);
-var SupportedAgentRecordKeySchema = z.string().regex(/^(?!quick$|deep$).+$/, "Unsupported removed agent role");
-var FallbackChainsSchema = z.record(
-  SupportedAgentRecordKeySchema,
-  AgentModelChainSchema
-);
-var AgentOverrideConfigSchema = z.object({
-  model: z.union([
-    z.string(),
-    z.array(
-      z.union([
-        z.string(),
-        z.object({
-          id: z.string(),
-          variant: z.string().optional()
-        })
-      ])
-    )
-  ]).optional(),
-  /** Pi specialist catalog filter; omitted discovers all, [] discovers none. */
-  skills: z.array(z.string().trim().min(1)).optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  steps: z.number().int().min(1).optional(),
-  variant: z.string().optional().catch(void 0)
-});
-var TmuxLayoutSchema = z.enum([
-  "main-horizontal",
-  // Main pane on top, agents stacked below
-  "main-vertical",
-  // Main pane on left, agents stacked on right
-  "tiled",
-  // All panes equal size grid
-  "even-horizontal",
-  // All panes side by side
-  "even-vertical"
-  // All panes stacked vertically
-]);
-var TmuxConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  layout: TmuxLayoutSchema.default("main-vertical"),
-  main_pane_size: z.number().min(20).max(80).default(60)
-  // percentage for main pane
-});
-var PresetSchema = z.record(
-  SupportedAgentRecordKeySchema,
-  AgentOverrideConfigSchema
-);
-var AgentNameSchema = z.enum(AGENT_NAMES);
-var McpNameSchema = z.enum(["exa", "context7", "grep_app"]);
-var CodexGenerationConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  outputRoot: z.string().optional(),
-  dryRun: z.boolean().default(true)
-});
-var ClaudeCodeGenerationConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  outputRoot: z.string().optional(),
-  dryRun: z.boolean().default(true)
-});
-var FailoverConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  timeoutMs: z.number().min(0).default(15e3),
-  retryDelayMs: z.number().min(0).default(500),
-  chains: FallbackChainsSchema.default({})
-});
-var PluginConfigSchema = z.object({
-  $schema: z.string().optional(),
-  preset: z.string().optional(),
-  setDefaultAgent: z.boolean().optional(),
-  scoringEngineVersion: z.enum(["v1", "v2-shadow", "v2"]).optional(),
-  balanceProviderUsage: z.boolean().optional(),
-  manualPlan: ManualPlanSchema.optional(),
-  presets: z.record(z.string(), PresetSchema).optional(),
-  agents: z.record(SupportedAgentRecordKeySchema, AgentOverrideConfigSchema).optional(),
-  disabled_mcps: z.array(z.string()).optional(),
-  tmux: TmuxConfigSchema.optional(),
-  fallback: FailoverConfigSchema.optional(),
-  codex: CodexGenerationConfigSchema.optional(),
-  claudeCode: ClaudeCodeGenerationConfigSchema.optional()
-});
-
 // src/config/utils.ts
 function getAgentOverride(config, name) {
   return config?.agents?.[name];
@@ -418,36 +691,75 @@ function buildOpenAIModelMappings() {
 var MODEL_MAPPINGS = {
   openai: buildOpenAIModelMappings()
 };
-function generateLiteConfig(installConfig) {
-  const config = {
-    $schema: THOTH_AGENTS_CONFIG_SCHEMA_URL,
-    preset: "openai",
-    presets: {}
-  };
-  const createAgentConfig = (modelInfo) => {
-    return {
-      model: modelInfo.model,
-      variant: modelInfo.variant
-    };
+function generateLiteConfig(_installConfig) {
+  return { $schema: THOTH_AGENTS_CONFIG_SCHEMA_URL };
+}
+
+// src/cli/opencode-profiles.ts
+function openCodeProfileStore(roster) {
+  return new ModelProfileStore({
+    cwd: process.cwd(),
+    configDir: getConfigDir(),
+    roster
+  });
+}
+function activeOpenCodeProfile() {
+  const store = openCodeProfileStore();
+  const document = store.read("global");
+  return {
+    name: document.active,
+    profile: document.active ? store.lookup(document.active, "global")?.profile : void 0
   };
-  const buildPreset = (mappingName) => {
-    const mapping = MODEL_MAPPINGS[mappingName];
-    return Object.fromEntries(
-      Object.entries(mapping).map(([agentName, modelInfo]) => [
-        agentName,
-        createAgentConfig(modelInfo)
+}
+function effectiveOpenCodeProfile(config) {
+  const root = config?.agents ?? {};
+  const roster = Object.fromEntries(
+    PROFILE_ROLES.map((role) => [
+      role,
+      resolveModelPair(root[role], MODEL_MAPPINGS.openai[role])
+    ])
+  );
+  const selected = activeOpenCodeProfile().profile ?? { agents: {} };
+  return {
+    agents: Object.fromEntries(
+      PROFILE_ROLES.map((role) => [
+        role,
+        resolveRoleProfile(role, selected, roster)
       ])
-    );
+    )
   };
-  config.presets.openai = buildPreset("openai");
-  if (installConfig.hasTmux) {
-    config.tmux = {
-      enabled: true,
-      layout: "main-vertical",
-      main_pane_size: 60
-    };
+}
+function syncOpenCodeProfile(reset = false) {
+  const store = openCodeProfileStore();
+  const document = store.read("global");
+  const names = ["openai"];
+  if (document.active === "agents" && document.profiles.agents)
+    names.push("agents");
+  for (const name of names) {
+    const previous = document.profiles[name]?.agents ?? {};
+    const agents = Object.fromEntries(
+      PROFILE_ROLES.map((role) => {
+        const current = previous[role];
+        const legacy = LEGACY_OPENAI_PRESET[role];
+        const advance = current?.model === `openai/${legacy.model}` && current?.variant === legacy.effort;
+        return [
+          role,
+          reset && name === "openai" || advance ? MODEL_MAPPINGS.openai[role] : resolveRoleProfile(
+            role,
+            { agents: previous },
+            MODEL_MAPPINGS.openai
+          )
+        ];
+      })
+    );
+    store.save("global", name, { agents });
   }
-  return config;
+  if (!document.active || !store.lookup(document.active, "global"))
+    store.setGlobalActive("openai");
+}
+function withoutLegacyPresets(config) {
+  const { preset: _preset, presets: _presets, ...rest } = config;
+  return rest;
 }
 
 // src/cli/config-io.ts
@@ -463,23 +775,23 @@ function stripJsonComments(json) {
     (match, comma, closing) => comma ? closing : match
   );
 }
-function parseConfigFile(path2) {
+function parseConfigFile(path3) {
   try {
-    if (!existsSync3(path2)) return { config: null };
-    const stat = statSync(path2);
+    if (!existsSync3(path3)) return { config: null };
+    const stat = statSync(path3);
     if (stat.size === 0) return { config: null };
-    const content = readFileSync2(path2, "utf-8");
+    const content = readFileSync2(path3, "utf-8");
     if (content.trim().length === 0) return { config: null };
     return { config: JSON.parse(stripJsonComments(content)) };
   } catch (err) {
     return { config: null, error: String(err) };
   }
 }
-function parseConfig(path2) {
-  const result = parseConfigFile(path2);
+function parseConfig(path3) {
+  const result = parseConfigFile(path3);
   if (result.config || result.error) return result;
-  if (path2.endsWith(".json")) {
-    const jsoncPath = path2.replace(/\.json$/, ".jsonc");
+  if (path3.endsWith(".json")) {
+    const jsoncPath = path3.replace(/\.json$/, ".jsonc");
     return parseConfigFile(jsoncPath);
   }
   return { config: null };
@@ -500,24 +812,32 @@ function writeConfig(configPath, config) {
   writeFileSync(tmpPath, content);
   renameSync(tmpPath, configPath);
 }
+function pluginEntries(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isManagedOpenCodePlugin(entry) {
+  const name = typeof entry === "string" ? entry : Array.isArray(entry) ? entry[0] : entry && typeof entry === "object" && "package" in entry ? entry.package : void 0;
+  return typeof name === "string" && (name === PACKAGE_NAME || name.startsWith(`${PACKAGE_NAME}@`));
+}
+function hasManagedPluginOptions(entry) {
+  if (!isManagedOpenCodePlugin(entry)) return false;
+  const options = Array.isArray(entry) ? entry[1] : entry && typeof entry === "object" && "options" in entry ? entry.options : void 0;
+  return !!options && typeof options === "object" && Object.keys(options).length > 0;
+}
 function mergeOpenCodeMainConfig(config, update) {
   if (update.ensurePlugin) {
-    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-    config.plugin = [
-      ...plugins.filter(
-        (plugin) => plugin !== PACKAGE_NAME && !plugin.startsWith(`${PACKAGE_NAME}@`)
+    const legacy = pluginEntries(config.plugin).filter(
+      (entry) => !isManagedOpenCodePlugin(entry)
+    );
+    if (legacy.length > 0) config.plugin = legacy;
+    else delete config.plugin;
+    config.plugins = [
+      ...pluginEntries(config.plugins).filter(
+        (entry) => !isManagedOpenCodePlugin(entry)
       ),
       `${PACKAGE_NAME}@${update.pluginVersion}`
     ];
   }
-  if (update.disableDefaults) {
-    const agent = config.agent && typeof config.agent === "object" ? { ...config.agent } : {};
-    const explore = agent.explore && typeof agent.explore === "object" ? { ...agent.explore } : {};
-    const general = agent.general && typeof agent.general === "object" ? { ...agent.general } : {};
-    agent.explore = { ...explore, disable: true };
-    agent.general = { ...general, disable: true };
-    config.agent = agent;
-  }
   return config;
 }
 function updateOpenCodeMainConfig(update) {
@@ -547,10 +867,19 @@ function updateOpenCodeMainConfig(update) {
         error: `Failed to parse config: ${error}`
       };
     }
+    const removedOptions = update.ensurePlugin && [
+      ...pluginEntries(parsedConfig?.plugin),
+      ...pluginEntries(parsedConfig?.plugins)
+    ].some(hasManagedPluginOptions);
     writeConfig(
       configPath,
       mergeOpenCodeMainConfig(parsedConfig ?? {}, update)
     );
+    if (removedOptions) {
+      console.warn(
+        `[config-manager] Removed non-empty thoth-agents plugin options while pinning the v2 plugin. Original entries are preserved in ${configPath}.bak; configure the plugin via thoth-agents.json instead.`
+      );
+    }
     return { success: true, configPath };
   } catch (err) {
     return {
@@ -566,43 +895,6 @@ function configObject(value) {
     throw new Error("Expected an object in managed lite configuration.");
   return value;
 }
-function mergeLiteConfig(defaults, installed) {
-  const presets = { ...configObject(installed.presets) };
-  const shipped = configObject(configObject(defaults.presets).openai);
-  const activeName = typeof installed.preset === "string" ? installed.preset : "openai";
-  const rootAgents = { ...configObject(installed.agents) };
-  for (const name of /* @__PURE__ */ new Set(["openai", activeName])) {
-    const roles = { ...configObject(presets[name]) };
-    for (const [role, legacy] of Object.entries(LEGACY_OPENAI_PRESET)) {
-      const rootRole = name === activeName ? rootAgents[role] : void 0;
-      const current = {
-        ...configObject(roles[role]),
-        ...configObject(rootRole)
-      };
-      const advancesLegacy = current.model === `openai/${legacy.model}` && current.variant === legacy.effort;
-      if (roles[role] === void 0 && rootRole === void 0) {
-        roles[role] = shipped[role];
-      } else if (advancesLegacy) {
-        roles[role] = { ...current, ...configObject(shipped[role]) };
-        if (rootRole !== void 0)
-          rootAgents[role] = {
-            ...configObject(rootRole),
-            ...configObject(shipped[role])
-          };
-      } else {
-        roles[role] = current;
-      }
-    }
-    presets[name] = roles;
-  }
-  return {
-    ...defaults,
-    ...installed,
-    preset: activeName,
-    presets,
-    ...installed.agents !== void 0 ? { agents: rootAgents } : {}
-  };
-}
 function writeLiteConfig(installConfig, targetPath) {
   const configPath = targetPath ?? getLiteConfig();
   try {
@@ -611,8 +903,10 @@ function writeLiteConfig(installConfig, targetPath) {
     if (!installConfig.reset && existsSync3(configPath)) {
       const { config: installed, error } = parseConfigFile(configPath);
       if (error) throw new Error(`Failed to parse lite config: ${error}`);
-      if (installed) config = mergeLiteConfig(config, configObject(installed));
+      if (installed) config = { ...config, ...configObject(installed) };
     }
+    config = withoutLegacyPresets(config);
+    syncOpenCodeProfile(installConfig.reset);
     const tmpPath = `${configPath}.tmp`;
     const bakPath = `${configPath}.bak`;
     const content = `${JSON.stringify(config, null, 2)}
@@ -634,37 +928,35 @@ function writeLiteConfig(installConfig, targetPath) {
 function detectCurrentConfig() {
   const result = {
     isInstalled: false,
-    hasOpenAI: false,
-    hasTmux: false
+    hasOpenAI: false
   };
   const { config } = parseConfig(getExistingConfigPath());
   if (!config) return result;
-  const plugins = config.plugin ?? [];
-  result.isInstalled = plugins.some((p) => p.startsWith(PACKAGE_NAME));
+  result.isInstalled = [
+    ...pluginEntries(config.plugin),
+    ...pluginEntries(config.plugins)
+  ].some(isManagedOpenCodePlugin);
   const { config: liteConfig } = parseConfig(getLiteConfig());
   if (liteConfig && typeof liteConfig === "object") {
     const configObj = liteConfig;
-    const presetName = configObj.preset;
-    const presets = configObj.presets;
-    const agents = presets?.[presetName];
+    const agents = effectiveOpenCodeProfile(configObj).agents;
     if (agents) {
       const models = Object.values(agents).map((a) => a?.model).filter(Boolean);
       result.hasOpenAI = models.some((m) => m?.startsWith("openai/"));
     }
-    if (configObj.tmux && typeof configObj.tmux === "object") {
-      const tmuxConfig = configObj.tmux;
-      result.hasTmux = tmuxConfig.enabled === true;
-    }
   }
   return result;
 }
 
 // src/config/loader.ts
 var PROMPTS_DIR_NAME = "thoth-agents";
-function loadConfigFromPath(configPath) {
+function loadConfigFromPath(configPath, unsupportedKeyPaths) {
   try {
-    const content = fs.readFileSync(configPath, "utf-8");
+    const content = fs2.readFileSync(configPath, "utf-8");
     const rawConfig = JSON.parse(stripJsonComments(content));
+    if (rawConfig !== null && typeof rawConfig === "object" && ("preset" in rawConfig || "presets" in rawConfig)) {
+      unsupportedKeyPaths.add(configPath);
+    }
     const result = PluginConfigSchema.safeParse(rawConfig);
     if (!result.success) {
       console.warn(`[thoth-agents] Invalid config at ${configPath}:`);
@@ -685,10 +977,10 @@ function loadConfigFromPath(configPath) {
 function findConfigPath(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (fs.existsSync(jsoncPath)) {
+  if (fs2.existsSync(jsoncPath)) {
     return jsoncPath;
   }
-  if (fs.existsSync(jsonPath)) {
+  if (fs2.existsSync(jsonPath)) {
     return jsonPath;
   }
   return null;
@@ -712,72 +1004,52 @@ function deepMerge(base, override) {
   return result;
 }
 function loadPluginConfig(directory) {
-  const userConfigBasePath = path.join(getConfigDir(), "thoth-agents");
-  const projectConfigBasePath = path.join(
+  const userConfigBasePath = path2.join(getConfigDir(), "thoth-agents");
+  const projectConfigBasePath = path2.join(
     directory,
     ".opencode",
     "thoth-agents"
   );
   const userConfigPath = findConfigPath(userConfigBasePath);
   const projectConfigPath = findConfigPath(projectConfigBasePath);
-  let config = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
-  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
+  const unsupportedKeyPaths = /* @__PURE__ */ new Set();
+  let config = userConfigPath ? loadConfigFromPath(userConfigPath, unsupportedKeyPaths) ?? {} : {};
+  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath, unsupportedKeyPaths) : null;
   if (projectConfig) {
     config = {
       ...config,
       ...projectConfig,
       agents: deepMerge(config.agents, projectConfig.agents),
-      tmux: deepMerge(config.tmux, projectConfig.tmux),
       fallback: deepMerge(config.fallback, projectConfig.fallback),
       codex: deepMerge(config.codex, projectConfig.codex),
       claudeCode: deepMerge(config.claudeCode, projectConfig.claudeCode)
     };
   }
-  const envPreset = process.env.THOTH_AGENTS_PRESET;
-  if (envPreset) {
-    config.preset = envPreset;
-  }
-  if (config.preset) {
-    const preset = config.presets?.[config.preset];
-    if (preset) {
-      config.agents = deepMerge(preset, config.agents);
-    } else {
-      const presetSource = envPreset === config.preset ? "environment variable" : "config file";
-      const availablePresets = config.presets ? Object.keys(config.presets).join(", ") : "none";
-      console.warn(
-        `[thoth-agents] Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`
-      );
-    }
+  if (unsupportedKeyPaths.size > 0) {
+    console.warn(
+      `[thoth-agents] Config keys preset/presets are unsupported and ignored (${[...unsupportedKeyPaths].join(", ")}).`
+    );
   }
   return config;
 }
-function loadAgentPrompt(agentName, preset) {
-  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : void 0;
-  const promptsDir = path.join(getConfigDir(), PROMPTS_DIR_NAME);
-  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
+function loadAgentPrompt(agentName) {
+  const promptsDir = path2.join(getConfigDir(), PROMPTS_DIR_NAME);
   const result = {};
-  const readFirstPrompt = (fileName, errorPrefix) => {
-    for (const dir of promptSearchDirs) {
-      const promptPath = path.join(dir, fileName);
-      if (!fs.existsSync(promptPath)) {
-        continue;
-      }
-      try {
-        return fs.readFileSync(promptPath, "utf-8");
-      } catch (error) {
-        console.warn(
-          `[thoth-agents] ${errorPrefix} ${promptPath}:`,
-          error instanceof Error ? error.message : String(error)
-        );
-      }
+  const readPrompt = (fileName, errorPrefix) => {
+    const promptPath = path2.join(promptsDir, fileName);
+    if (!fs2.existsSync(promptPath)) return void 0;
+    try {
+      return fs2.readFileSync(promptPath, "utf-8");
+    } catch (error) {
+      console.warn(
+        `[thoth-agents] ${errorPrefix} ${promptPath}:`,
+        error instanceof Error ? error.message : String(error)
+      );
+      return void 0;
     }
-    return void 0;
   };
-  result.prompt = readFirstPrompt(
-    `${agentName}.md`,
-    "Error reading prompt file"
-  );
-  result.appendPrompt = readFirstPrompt(
+  result.prompt = readPrompt(`${agentName}.md`, "Error reading prompt file");
+  result.appendPrompt = readPrompt(
     `${agentName}_append.md`,
     "Error reading append prompt file"
   );
@@ -788,7 +1060,7 @@ function loadAgentPrompt(agentName, preset) {
 var text = { type: "string" };
 var texts = { type: "array", items: text };
 var nullableText = { type: ["string", "null"] };
-function object(properties) {
+function object2(properties) {
   return {
     type: "object",
     properties,
@@ -799,7 +1071,7 @@ function object(properties) {
 function array(items) {
   return { type: "array", items };
 }
-var common = object({
+var common = object2({
   schemaVersion: { type: "number", const: 1 },
   role: {
     type: "string",
@@ -811,7 +1083,7 @@ var common = object({
   },
   conclusion: text,
   evidence: array(
-    object({
+    object2({
       id: { type: "string", minLength: 1 },
       kind: text,
       locator: text,
@@ -821,7 +1093,7 @@ var common = object({
     })
   ),
   verification: array(
-    object({
+    object2({
       check: text,
       method: text,
       outcome: { type: "string", enum: ["pass", "fail", "not-run"] },
@@ -830,7 +1102,7 @@ var common = object({
     })
   ),
   risks: array(
-    object({
+    object2({
       description: text,
       severity: { type: "string", enum: ["low", "medium", "high", "critical"] },
       blocking: { type: "boolean" },
@@ -838,11 +1110,11 @@ var common = object({
     })
   ),
   openQuestions: array(
-    object({ question: text, owner: text, options: texts, facts: texts })
+    object2({ question: text, owner: text, options: texts, facts: texts })
   )
 });
 var review = {
-  ...object({
+  ...object2({
     kind: {
       type: "string",
       enum: ["plan-review", "final-verification"]
@@ -858,7 +1130,7 @@ var SPECIALIST_RESULT_CONTRACT = {
   fence: "thoth-result",
   common,
   roles: {
-    oracle: object({ nextAction: nullableText, review })
+    oracle: object2({ nextAction: nullableText, review })
   },
   reviewKinds: {
     "plan-review": { verdicts: ["OKAY", "REJECT"] },
@@ -1381,25 +1653,30 @@ function piCapabilityDisclosure(capability) {
 }
 var OPENCODE_PROMPT_DIALECT = {
   harness: "opencode",
-  gateDeliveryInstruction: "Delivery verdicts are appended to Oracle `task` output.",
+  gateDeliveryInstruction: "Foreground Oracle `subagent` gates get one `thoth-gate-verdict` line; background completions have none: use the explicit compact validator fallback.",
   tools: {
-    delegationTool: "task",
-    backgroundDelegationTool: "task(background=true)",
-    backgroundStatusTool: "task_status",
+    delegationTool: "subagent",
+    backgroundDelegationTool: "subagent(background:true)",
+    backgroundWaitInstruction: 'Native `<subagent sessionID=... state="completed">` completion wakes root. No status polling tool exists; never poll/sleep.',
     userQuestionTool: "question",
     progressTool: "todowrite",
-    hostStatusSurface: "task_status",
+    hostStatusSurface: "native subagent completion messages",
     lifecycle: {
-      freshDelegation: "`task` without `task_id`",
-      sameAssignmentContinuation: "`task` with the prior `task_id`",
-      independentContext: "omitting `task_id` creates an isolated child session",
-      statusAction: "wait, poll, and collect",
-      terminalState: "terminal task_status result",
-      nonterminalState: "nonterminal task_status result",
-      sameSessionProbe: "task_status on the same task session",
+      rootInstructions: [
+        "- New objectives, phases, work units, mutable surfaces or independent judgments require fresh specialist sessions via `subagent` (agent, description, prompt; omit sessionID). These are fresh-session boundaries, not permission for root execution; never pool completed agents.",
+        "- Use sessionID only to continue/clarify the same assignment, including while running. Optional model; background:true for independent work. Default nesting depth is 1.",
+        "- Every Oracle plan review, verification round, and PASS judgment uses a fresh Oracle instance. Existing ones only clarify their findings."
+      ].join("\n"),
+      freshDelegation: "`subagent` with agent, description and prompt, omitting sessionID",
+      sameAssignmentContinuation: "`subagent` with the prior sessionID, including while running",
+      independentContext: "omitting sessionID creates an isolated child session",
+      statusAction: "receive native completion automatically; never poll",
+      terminalState: "a completed subagent result/message",
+      nonterminalState: "a running placeholder",
+      sameSessionProbe: "continue or clarify with subagent and the same sessionID; never ask for status",
       enforcement: "runtime-supported"
     },
-    roleReference: (role) => `@${role}`
+    roleReference: (role) => `subagent agent:"${role}"`
   },
   capabilities: supportedCapabilityProfile(OPENCODE_CAPABILITIES),
   dispatchLabel(method) {
@@ -1407,11 +1684,11 @@ var OPENCODE_PROMPT_DIALECT = {
       case "root-coordinator":
         return "root coordinator";
       case "task":
-        return "task";
+        return "subagent";
     }
   },
   renderRoleInvocation(role) {
-    return `@${role}`;
+    return `subagent agent:"${role}"`;
   }
 };
 var CODEX_PROMPT_DIALECT = {
@@ -2231,7 +2508,7 @@ Use \`${dialect.tools.userQuestionTool}\` only for a blocking material choice, d
 }
 function renderSubagentRules(section, dialect) {
   const rules = [
-    dialect.tools.progressTool ? `- Do not delegate further or call \`${dialect.tools.progressTool}\`; root owns progress.` : "- Do not delegate further; root owns progress.",
+    dialect.harness === "opencode" ? "- Do not delegate further; no `todowrite` (root-owned)." : dialect.tools.progressTool ? `- Do not delegate further or call \`${dialect.tools.progressTool}\`; root owns progress.` : "- Do not delegate further; root owns progress.",
     "- Use terminating checks; avoid watch processes and indefinite waits.",
     "- Preserve operator-selected model/effort. Stop after the assigned outcome and checks; never expand scope to fill a timeout.",
     "- After two consecutive attempts without new evidence or progress, return partial evidence and the smallest blocker; do not repeat searches or unchanged failing commands.",
@@ -2420,6 +2697,7 @@ function composeAgentPrompt({
 }
 
 export {
+  PROFILE_ROLES,
   SUBAGENT_NAMES,
   ALL_AGENT_NAMES,
   LEGACY_OPENAI_PRESET,
@@ -2428,19 +2706,30 @@ export {
   DEFAULT_MODELS,
   getDefaultOpenCodeModel,
   getDefaultOpenCodeVariant,
-  POLL_INTERVAL_BACKGROUND_MS,
-  findPackageRoot,
-  isValidPackageVersion,
-  resolveExecutingPackageVersion,
-  getOpenCodeConfigPaths,
+  resolveRoleProfile,
+  mergeProfileModelChain,
+  formatModelString,
+  validateProfileName,
+  ProfileConflictError,
+  ModelProfileStore,
+  getConfigDir,
   getOpenCodeManagedModelStatePath,
   getExistingLiteConfigPath,
   getExistingConfigPath,
   ensureConfigDir,
+  MODEL_MAPPINGS,
   generateLiteConfig,
-  stripJsonComments,
+  openCodeProfileStore,
+  activeOpenCodeProfile,
+  effectiveOpenCodeProfile,
+  withoutLegacyPresets,
+  findPackageRoot,
+  isValidPackageVersion,
+  resolveExecutingPackageVersion,
   parseConfig,
   writeConfig,
+  pluginEntries,
+  isManagedOpenCodePlugin,
   updateOpenCodeMainConfig,
   writeLiteConfig,
   detectCurrentConfig,