opencode-resolve 0.1.3 → 0.1.4

package/dist/index.js

@@ -1,11 +1,25 @@
+import { readFileSync } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const PLUGIN_VERSION = readPluginVersion();
+function readPluginVersion() {
+    try {
+        const pkgRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+        const pkg = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf8"));
+        return typeof pkg?.version === "string" ? pkg.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+console.log(`[opencode-resolve] v${PLUGIN_VERSION} loaded`);
 const DEFAULT_MODELS = {};
-const DEFAULT_ENABLED = ["coder", "reviewer", "resolver"];
-const VALID_AGENT_NAMES = ["coder", "reviewer", "resolver", "architect", "gpt-coder", "debugger", "researcher"];
+const DEFAULT_ENABLED = ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"];
+const VALID_AGENT_NAMES = ["coder", "reviewer", "resolver", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer"];
 const VALID_AGENT_NAME_SET = new Set(VALID_AGENT_NAMES);
-const VALID_MODEL_ALIASES = [...VALID_AGENT_NAMES, "glm", "gpt"];
+const VALID_MODEL_ALIASES = [...VALID_AGENT_NAMES, "glm", "gpt", "quick", "deep", "fast", "strong", "mini", "codex"];
 const VALID_MODEL_ALIAS_SET = new Set(VALID_MODEL_ALIASES);
 const VALID_MODES = new Set(["subagent", "primary", "all"]);
 const VALID_PERMISSION_VALUES = new Set(["ask", "allow", "deny"]);
@@ -35,22 +49,34 @@ const VALID_AGENT_KEYS = new Set([
 function buildResolverPrompt(maxParallelSubagents) {
     const limit = Math.max(1, Math.trunc(maxParallelSubagents));
     const parallelRule = limit === 1
-        ? "CRITICAL: Dispatch at most ONE subagent of each role concurrently. Never run two coders in parallel, and never run two reviewers in parallel. A coder and a reviewer MAY run concurrently when they are doing genuinely independent work (e.g. coder is implementing the next change while reviewer audits the previous one). Wait for an in-flight subagent of a given role to finish before dispatching another of the same role."
-        : `CRITICAL: Dispatch at most ${limit} subagents of the same role concurrently. Never exceed ${limit} coders in parallel, and never exceed ${limit} reviewers in parallel. Subagents of different roles may run concurrently when they are doing genuinely independent work. Wait for in-flight subagents of a given role to finish before dispatching more of that role.`;
+        ? "CRITICAL: Dispatch at most ONE subagent of each role concurrently. Never run two coders in parallel. Wait for an in-flight coder to finish before dispatching another."
+        : `CRITICAL: Dispatch at most ${limit} subagents of the same role concurrently. Never exceed ${limit} coders in parallel. Wait for in-flight subagents of a given role to finish before dispatching more of that role.`;
     return [
-        "You are Resolver, the primary orchestrator agent for OpenCode Resolve.",
-        "Your job is to drive the user's task to a verified resolution end-to-end without unnecessary stops.",
-        "Workflow:",
-        "1. Understand the requirement. Inspect the relevant files briefly before planning.",
-        "2. Plan the smallest correct change.",
-        "3. Dispatch the coder subagent to implement the change. Pass a focused instruction with the exact files and behavior.",
-        `4. ${parallelRule}`,
-        "5. After implementation, verify when practical (run tests, type checks, or targeted checks).",
-        "6. If issues remain, dispatch the coder again with a focused fix, or apply a small direct edit yourself when it is clearly trivial.",
-        "7. Optionally consult the reviewer subagent for an independent read-only review on risky changes. The reviewer cannot modify anything; treat its output as advice and route any required fixes back through the coder. The same per-role parallel limit applies to the reviewer.",
-        "8. Repeat until the task is resolved or clearly blocked.",
-        "Return a concise summary of what changed, verification results, and any remaining blockers.",
-        "Note: this parallel rule is enforced via prompt only — there is no runtime cap on subagent dispatches. Honor it strictly to avoid file conflicts and wasted work.",
+        "You are Resolver, the context-efficient orchestrator agent for OpenCode Resolve.",
+        "Your job is to drive the user's task to a verified resolution using minimal context and the fewest LLM calls possible.",
+        "",
+        "Core path: You and Coder form the fixed-role verified resolve loop — this is the default path.",
+        "Internal specialist subagents (explorer, reviewer, deep-reviewer) are available by default as subagents, but they are NOT the default path.",
+        "Dispatch them only when justified — avoid context waste.",
+        "",
+        "Checkpointed execution: for large tasks, decompose work into small verified checkpoints. For each checkpoint, iterate up to 3 attempts on the same failing checkpoint. When a checkpoint passes verification, carry forward only: decisions, changed files, verification results, and blockers — then proceed to the next checkpoint. If blocked after max 3 attempts on one checkpoint, report the exact blocker with evidence. This preserves context and handles arbitrarily long tasks.",
+        "",
+        "Workflow (default fixed-role path):",
+        "1. CLASSIFY the work as quick (trivial fix), normal (standard feature), deep (complex refactor), or risky (security/architecture/high-impact).",
+        "2. INSPECT only relevant files — avoid broad exploration. Use local tools (read, grep, glob) to gather facts, not subagents.",
+        "3. For trivial/quick work: inspect relevant files directly and apply a small edit yourself. No subagent needed.",
+        "4. PLAN the smallest correct patch. Dispatch coder with exact file paths and focused behavior instructions.",
+        `5. ${parallelRule}`,
+        "6. VERIFY with the cheapest meaningful check first (targeted test, type check, or lint). Do not run full suites unless the change is wide.",
+        "7. If issues remain, RETRY from verification logs: dispatch coder again with a focused fix. Max 3 attempts for the same failing checkpoint; then move forward or report the blocker.",
+        "8. REPORT a concise evidence summary: what changed, verification results, and any remaining blockers.",
+        "",
+        "Internal specialist subagents (available by default, but NOT the default path — use only when justified):",
+        "- explorer: fast read-only codebase scout. Prefer local read/grep/glob for narrow scope; dispatch explorer only when scope is genuinely unknown and local tools are insufficient.",
+        "- reviewer: lightweight read-only audit. Dispatch only for post-change verification gaps on non-trivial changes.",
+        "- deep-reviewer: thorough read-only review. Dispatch ONLY for risky, security-sensitive, architectural, or high-impact changes.",
+        "",
+        "Note: this parallel rule is enforced via prompt only — there is no runtime cap on subagent dispatches. Honor it strictly to avoid file conflicts and wasted context.",
     ].join("\n");
 }
 const DEFAULT_AGENT_CONFIG = {
@@ -61,10 +87,14 @@ const DEFAULT_AGENT_CONFIG = {
         description: "Use for focused implementation, file edits, test runs, and fixing issues until the task is resolved.",
         prompt: [
             "You are Coder, a focused implementation subagent for OpenCode Resolve.",
+            "You are one of two default agents. Together with Resolver you form a verified resolve loop.",
+            "",
+            "Context budget: read ONLY the files you need. Avoid broad exploration or discovering the entire codebase.",
             "Preserve native OpenCode behavior and make the smallest correct change.",
-            "Before editing, inspect the relevant files and existing patterns.",
-            "Implement, run targeted verification when practical, and keep iterating on failures until the task is resolved or clearly blocked.",
-            "Return a concise summary of changed files, verification results, and any remaining blockers.",
+            "Before editing, inspect only the relevant files and existing patterns in those files.",
+            "Implement the smallest patch that satisfies the requirement.",
+            "Run targeted verification when practical (single test file, type check, or lint — not full suites).",
+            "Return a concise summary: changed files list + command results. No unnecessary prose.",
         ].join("\n"),
         permission: {
             edit: "ask",
@@ -76,9 +106,10 @@ const DEFAULT_AGENT_CONFIG = {
         mode: "subagent",
         color: "#8A7CFF",
         maxSteps: 8,
-        description: "Read-only Oracle-style reviewer. Inspects code for requirements fit, correctness, security, tests, and maintainability risks. Never modifies anything.",
+        description: "Internal read-only verification-gap auditor. Enabled as subagent by default but not part of the core resolver→coder path. Resolver dispatches only when it judges a verification gap exists on non-trivial changes.",
         prompt: [
-            "You are Reviewer, a strictly read-only review subagent for OpenCode Resolve.",
+            "You are Reviewer, a strictly read-only internal review subagent for OpenCode Resolve.",
+            "You are NOT part of the core path (resolver→coder). You are injected as an internal subagent so the resolver can dispatch you when it judges a verification gap exists on non-trivial changes.",
             "You MUST NOT modify the project by any means: no file edits, no writes, no shell commands that change state, no git commits, no package installs.",
             "Use read-only tools (read, grep, glob, list, web fetch for documentation) to inspect the work against the user's requirements and the repository's existing patterns.",
             "Prioritize concrete bugs, behavioral regressions, security risks, missing tests, and maintainability issues.",
@@ -95,7 +126,7 @@ const DEFAULT_AGENT_CONFIG = {
         mode: "all",
         color: "#FF7AC6",
         maxSteps: 30,
-        description: "Primary orchestrator. Drives a task to completion by planning, dispatching subagents (one at a time by default), and verifying results. Iterates until the task is resolved or clearly blocked.",
+        description: "Primary orchestrator in the fixed-role verified loop (resolver→coder). Decomposes work into verified checkpoints, dispatches coder, verifies each, and carries forward progress. Internal subagents (explorer, reviewer, deep-reviewer) are available by default but dispatched only when justified.",
         prompt: buildResolverPrompt(DEFAULT_MAX_PARALLEL_SUBAGENTS),
         permission: {
             edit: "ask",
@@ -167,6 +198,44 @@ const DEFAULT_AGENT_CONFIG = {
             webfetch: "ask",
         },
     },
+    explorer: {
+        mode: "subagent",
+        color: "#33CCFF",
+        maxSteps: 6,
+        description: "Internal pre-change fast scout for codebase/file/pattern/doc discovery. Enabled as subagent by default but not part of the core path. Read-only; quick model.",
+        prompt: [
+            "You are Explorer, a fast codebase scout subagent for OpenCode Resolve.",
+            "Your job is to quickly discover files, patterns, APIs, and relevant code locations before implementation begins.",
+            "You MUST NOT modify the project by any means: no file edits, no writes, no shell commands that change state.",
+            "Use read-only tools (read, grep, glob, list) and documentation tools (web fetch, Context7) to find what matters.",
+            "Return concise findings with file paths, relevant code snippets, APIs, and constraints.",
+            "Be fast and targeted — the resolver needs your discoveries to plan efficiently.",
+        ].join("\n"),
+        permission: {
+            edit: "deny",
+            bash: "ask",
+            webfetch: "ask",
+        },
+    },
+    "deep-reviewer": {
+        mode: "subagent",
+        color: "#6A0DAD",
+        maxSteps: 12,
+        description: "Internal post-change strong read-only review for risky/security/architecture/high-impact changes. Enabled as subagent by default but not part of the core path. Read-only; deep model.",
+        prompt: [
+            "You are Deep Reviewer, a thorough read-only review subagent for risky, security-sensitive, or high-impact changes.",
+            "You MUST NOT modify the project by any means: no file edits, no writes, no shell commands that change state, no git commits.",
+            "Use read-only tools to deeply inspect the work against requirements, security best practices, architectural soundness, and behavioral correctness.",
+            "Focus on security vulnerabilities, data integrity risks, breaking API changes, performance regressions, and architectural drift.",
+            "Return findings ordered by severity with file and line references. For each finding, explain the risk and recommend a concrete fix.",
+            "If a fix is needed, describe it precisely and recommend dispatching the coder or resolver agent. Never apply fixes yourself.",
+        ].join("\n"),
+        permission: {
+            edit: "deny",
+            bash: "deny",
+            webfetch: "ask",
+        },
+    },
 };
 export const OpencodeResolve = async ({ directory }, options) => {
     return {
@@ -230,7 +299,7 @@ function applyResolveConfig(config, resolveConfig) {
     if (resolveConfig.commands) {
         config.command ??= {};
         config.command["resolve"] ??= {
-            template: "Drive this task to a verified resolution end-to-end. Plan, dispatch one coder at a time, verify, and iterate. $ARGUMENTS",
+            template: "Drive this task to a verified resolution end-to-end. Classify, explore when needed, dispatch focused subagents within the configured per-role limit, verify, and iterate. $ARGUMENTS",
             description: "Run the OpenCode Resolve resolver agent end-to-end",
             agent: "resolver",
             subtask: true,

package/opencode-resolve.example.json

@@ -1,5 +1,5 @@
 {
-  "enabled": ["coder", "reviewer", "resolver"],
+  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
   "preserveNative": true,
   "context7": true,
   "commands": false,
@@ -8,14 +8,24 @@
   "models": {},
   "agents": {
     "coder": {
-      "mode": "all"
-    },
-    "reviewer": {
+      "enabled": true,
       "mode": "all"
     },
     "resolver": {
       "enabled": true
     },
+    "explorer": {
+      "enabled": true,
+      "mode": "subagent"
+    },
+    "reviewer": {
+      "enabled": true,
+      "mode": "subagent"
+    },
+    "deep-reviewer": {
+      "enabled": true,
+      "mode": "subagent"
+    },
     "architect": {
       "enabled": false
     },
@@ -30,4 +40,3 @@
     }
   }
 }
-

package/opencode-resolve.reference.jsonc

@@ -19,11 +19,18 @@
 {
   // -----------------------------------------------------------------------
   // enabled (string[])
-  // Which resolve agents to inject. Default: ["coder", "reviewer", "resolver"].
+  // Which resolve agents to inject.
+  // Default: ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"].
+  //
+  // Core path: resolver + coder form the fixed-role verified resolve loop.
+  // Internal specialists: explorer, reviewer, deep-reviewer are injected as
+  // subagents by default (OpenCode-native composition), but are NOT the
+  // default execution path. The resolver dispatches them only when justified.
+  //
   // Native OpenCode agents (plan, build) are always preserved and never
   // touched by this list. Per-agent `agents.<name>.enabled` overrides this.
   // -----------------------------------------------------------------------
-  "enabled": ["coder", "reviewer", "resolver"],
+  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
 
   // -----------------------------------------------------------------------
   // preserveNative (boolean)
@@ -59,11 +66,8 @@
   // -----------------------------------------------------------------------
   // maxParallelSubagents (positive integer)
   // Maximum number of subagents of the SAME ROLE the resolver may dispatch
-  // concurrently. Default: 2 — at most two coders in parallel and at most
-  // two reviewers in parallel. Subagents of different roles may always run
-  // concurrently. This is a soft prompt-level limit, not a runtime cap —
-  // pair with `maxSteps` if you need a stricter ceiling.
-  //   1 = strict per-role serial (one of each role at a time)
+  // concurrently. Default: 2 — at most two coders in parallel.
+  //   1 = strict per-role serial
   //   2 = default
   //   N = up to N of each role
   // -----------------------------------------------------------------------
@@ -72,22 +76,58 @@
   // -----------------------------------------------------------------------
   // models (object)
   // Alias map. Keys are either an agent name (coder, reviewer, resolver,
-  // architect, gpt-coder, debugger, researcher) OR one of the well-known
-  // aliases (`glm`, `gpt`). Values are model identifiers OR another alias.
+  // architect, gpt-coder, debugger, researcher, explorer, deep-reviewer)
+  // OR one of the well-known aliases (`glm`, `gpt`, `quick`, `deep`,
+  // `fast`, `strong`, `mini`, `codex`).
+  // Values are model identifiers OR another alias.
   //
   // Resolution order for a given agent:
   //   1. agents.<name>.model
   //   2. models.<name> (resolved through the alias map)
   //   3. top-level OpenCode `model`
   //   4. OpenCode's own fallback
+  //
+  // By default the models map is empty — all agents inherit the top-level
+  // OpenCode default model. Pin models only when you have measured a
+  // benefit from role-specific model selection.
+  //
+  // When resolve.json is created for the first time by postinstall, the
+  // plugin inspects your OpenCode model config and writes an adaptive
+  // preset:
+  //   - GLM/ZAI detected → mixed GLM + GPT aliases
+  //   - OpenAI/GPT detected → single-provider GPT aliases using your model
+  //   - Other or no model → empty (model-neutral inheritance)
+  // Existing resolve.json files are never overwritten. Delete resolve.json
+  // and reinstall to regenerate the preset.
+  //
+  // Example — one efficient model for everything (recommended default):
+  //   "models": {}
+  //
+  // Example — pin roles to specific models when needed:
+  //   "models": {
+  //     "fast": "openai/gpt-5-mini",
+  //     "strong": "openai/gpt-5.3-codex",
+  //     "coder": "fast",
+  //     "resolver": "strong"
+  //   }
+  //
+  // Example — GLM + GPT mixed preset (auto-generated for GLM/ZAI users):
+  //   "models": {
+  //     "glm": "zai-coding-plan/glm-5.1",
+  //     "gpt": "openai/gpt-5.5",
+  //     "fast": "glm",
+  //     "strong": "gpt",
+  //     "coder": "glm",
+  //     "resolver": "gpt",
+  //     "reviewer": "gpt",
+  //     "deep-reviewer": "gpt",
+  //     "explorer": "fast"
+  //   }
+  //
+  // Legacy aliases (glm, gpt, quick, deep) remain supported for backward
+  // compatibility. New configs should prefer provider-neutral aliases.
   // -----------------------------------------------------------------------
-  "models": {
-    "glm": "zai-coding-plan/glm-5.1",
-    "gpt": "openai/gpt-5.5",
-    "coder": "glm",
-    "resolver": "gpt",
-    "reviewer": "gpt"
-  },
+  "models": {},
 
   // -----------------------------------------------------------------------
   // agents (object)
@@ -104,7 +144,6 @@
   "agents": {
     "coder": {
       "enabled": true,
-      "model": "glm",
       "mode": "subagent",
       "maxSteps": 20,
       "permission": {
@@ -114,9 +153,37 @@
       }
     },
 
-    "reviewer": {
+    "resolver": {
       "enabled": true,
-      "model": "gpt",
+      "mode": "all",
+      "maxSteps": 30,
+      "permission": {
+        "edit": "allow",
+        "bash": "allow",
+        "webfetch": "allow"
+      }
+    },
+
+    // Internal specialist subagents — enabled by default as subagents only.
+    // Core path is resolver→coder. These are dispatched only when justified.
+
+    // Explorer: internal pre-change fast scout for codebase/file/pattern
+    // discovery. Resolver prefers local read/grep/glob for narrow scope;
+    // dispatches explorer only when scope is genuinely unknown.
+    "explorer": {
+      "mode": "subagent",
+      "maxSteps": 6,
+      "permission": {
+        "edit": "deny",
+        "bash": "allow",
+        "webfetch": "allow"
+      }
+    },
+
+    // Reviewer: internal read-only verification-gap auditor. Not part of
+    // the core path. Resolver dispatches only for verification gaps on
+    // non-trivial changes.
+    "reviewer": {
       "mode": "subagent",
       "maxSteps": 8,
       // Reviewer is read-only by design. edit and bash are denied even when
@@ -128,40 +195,38 @@
       }
     },
 
-    "resolver": {
-      "enabled": true,
-      "model": "gpt",
-      "mode": "all",
-      "maxSteps": 30,
+    // Deep Reviewer: internal post-change strong read-only review for
+    // risky/security/architecture/high-impact changes. Resolver dispatches
+    // ONLY for risky, security-sensitive, or high-impact work.
+    "deep-reviewer": {
+      "mode": "subagent",
+      "maxSteps": 12,
       "permission": {
-        "edit": "allow",
-        "bash": "allow",
+        "edit": "deny",
+        "bash": "deny",
         "webfetch": "allow"
       }
     },
 
-    // Optional agents — disabled by default. Flip enabled:true to use them.
+    // Disabled by default — enable explicitly when needed.
+
     "architect": {
       "enabled": false,
-      "model": "gpt",
       "mode": "subagent",
       "maxSteps": 10
     },
     "gpt-coder": {
       "enabled": false,
-      "model": "gpt",
       "mode": "subagent",
       "maxSteps": 20
     },
     "debugger": {
       "enabled": false,
-      "model": "glm",
       "mode": "subagent",
       "maxSteps": 14
     },
     "researcher": {
       "enabled": false,
-      "model": "glm",
       "mode": "subagent",
       "maxSteps": 8
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-resolve",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "OpenCode plugin that adds a small coder/reviewer agent set while preserving native plan/build behavior.",
   "type": "module",
   "homepage": "https://github.com/jshsakura/opencode-resolve#readme",

package/scripts/install-local.mjs

@@ -1,5 +1,5 @@
 import { constants } from "node:fs"
-import { access, copyFile, mkdir, symlink, unlink } from "node:fs/promises"
+import { access, mkdir, readFile, symlink, unlink, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
@@ -8,8 +8,9 @@ const root = resolve(dirname(fileURLToPath(import.meta.url)), "..")
 const pluginTarget = join(root, "dist", "index.js")
 const configDir = join(homedir(), ".config", "opencode")
 const pluginLink = join(configDir, "plugins", "opencode-resolve.js")
-const resolveConfig = join(configDir, "resolve.json")
+const resolveConfigPath = join(configDir, "resolve.json")
 const exampleConfig = join(root, "opencode-resolve.example.json")
+const opencodeConfigPath = join(configDir, "opencode.json")
 
 await assertFile(pluginTarget)
 await mkdir(dirname(pluginLink), { recursive: true })
@@ -22,12 +23,99 @@ try {
 
 await symlink(pluginTarget, pluginLink)
 
-if (!(await exists(resolveConfig))) {
-  await copyFile(exampleConfig, resolveConfig)
+if (!(await exists(resolveConfigPath))) {
+  await createAdaptiveResolveConfig()
 }
 
 console.log(`Linked plugin: ${pluginLink} -> ${pluginTarget}`)
-console.log(`Resolve config: ${resolveConfig}`)
+console.log(`Resolve config: ${resolveConfigPath}`)
+
+async function createAdaptiveResolveConfig() {
+  const raw = await readFile(exampleConfig, "utf8")
+  const example = JSON.parse(raw)
+
+  let opencodeConfig = {}
+  try {
+    const configRaw = await readFile(opencodeConfigPath, "utf8")
+    opencodeConfig = JSON.parse(configRaw)
+  } catch {
+    // opencode.json not found or unreadable — use empty config
+  }
+
+  const currentModel = detectOpenCodeModel(opencodeConfig)
+  const preset = buildModelPreset(currentModel)
+
+  const resolveConfig = { ...example }
+  if (preset && Object.keys(preset).length > 0) {
+    resolveConfig.models = preset
+  }
+
+  await mkdir(configDir, { recursive: true })
+  await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
+
+  const label = getPresetLabel(currentModel)
+  console.log(`Created ${resolveConfigPath} (preset: ${label})`)
+}
+
+function detectOpenCodeModel(config) {
+  if (typeof config.model === "string" && config.model.length > 0) {
+    return config.model
+  }
+  if (isObject(config.models)) {
+    for (const value of Object.values(config.models)) {
+      if (typeof value === "string" && value.length > 0) return value
+    }
+  }
+  if (isObject(config.agent)) {
+    for (const agentConfig of Object.values(config.agent)) {
+      if (isObject(agentConfig) && typeof agentConfig.model === "string" && agentConfig.model.length > 0) {
+        return agentConfig.model
+      }
+    }
+  }
+  return null
+}
+
+function buildModelPreset(currentModel) {
+  if (!currentModel) return {}
+  const lower = currentModel.toLowerCase()
+  if (lower.includes("glm") || lower.includes("zai")) {
+    return {
+      glm: "zai-coding-plan/glm-5.1",
+      gpt: "openai/gpt-5.5",
+      fast: "glm",
+      strong: "gpt",
+      coder: "glm",
+      resolver: "gpt",
+      reviewer: "gpt",
+      "deep-reviewer": "gpt",
+      explorer: "fast",
+    }
+  }
+  if (lower.includes("openai/") || lower.includes("gpt")) {
+    return {
+      gpt: currentModel,
+      fast: "gpt",
+      strong: "gpt",
+      mini: "gpt",
+      codex: "gpt",
+      coder: "gpt",
+      resolver: "gpt",
+      explorer: "gpt",
+      reviewer: "gpt",
+      "deep-reviewer": "gpt",
+    }
+  }
+  return {}
+}
+
+function getPresetLabel(currentModel) {
+  if (!currentModel) return "inherited"
+  const lower = currentModel.toLowerCase()
+  if (lower.includes("glm") || lower.includes("zai")) return "glm+gpt"
+  if (lower.includes("openai/") || lower.includes("gpt")) return "gpt-only"
+  return "inherited"
+}
 
 async function assertFile(path) {
   await access(path, constants.R_OK)
@@ -46,3 +134,7 @@ async function exists(path) {
 function isMissingFileError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT"
 }
+
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}