opencode-resolve 0.1.10 → 0.1.12

package/README.ko.md

@@ -156,8 +156,8 @@ npm install -g opencode-resolve
 
 1. `opencode-resolve`를 `~/.config/opencode/opencode.json`의 `plugin` 배열에 추가 (이미 없는 경우).
 2. 파일이 존재하지 않는 경우, 현재 모델 프로바이더에 맞게 적응된 `~/.config/opencode/resolve.json`을 생성:
-   - **인터랙티브 터미널** → 항상 `mix` / `gpt` / `glm`을 묻고, `bronze` / `silver` / `gold` 3티어 모델을 고르게 합니다. `mix`에서는 전용 `codex`, `glm` primary 에이전트를 켤지도 묻습니다.
-   - **비대화형 설치** → 모델 pinning을 추측하지 않습니다. `profile: "mix"`, `models: {}`를 쓰고 세 primary 경로(`resolver`, `codex`, `glm`)를 활성화하므로 이후 명시적으로 모델을 고르면 됩니다.
+   - **인터랙티브 터미널** → 항상 `mix` / `gpt` / `glm`을 묻고, `bronze` / `silver` / `gold` 3티어 모델을 고르게 합니다. `mix`에서는 전용 `gpt`, `glm` primary 에이전트를 켤지도 묻습니다.
+   - **비대화형 설치** → opencode.json에서 프로바이더를 자동 감지하여 모델 적응 프리셋을 작성합니다. `resolver`, `gpt`, `glm` primary 경로를 활성화합니다.
    - **GLM/ZAI 모델 감지** → 비밀값 없는 로컬 ZAI MCP 부트스트랩은 계속 추가합니다.
 
    기존 `resolve.json` 파일은 **동의 없이 덮어쓰지 않습니다**. 재설치 시 인터랙티브 환경이면 기존 파일을 업데이트할지, 백업 후 fresh setup을 다시 돌릴지 묻습니다. 비대화형 자동화에서는 `OPENCODE_RESOLVE_REINSTALL=fresh` 또는 `OPENCODE_RESOLVE_REINSTALL=update`를 설정하세요.
@@ -176,6 +176,30 @@ OPENCODE_RESOLVE_SKIP_POSTINSTALL=1 npm install -g opencode-resolve
 opencode plugin opencode-resolve --global --force
 ```
 
+그래도 OpenCode가 계속 예전 패키지를 로드하면, OpenCode 플러그인 캐시 항목만 지우고 다시 설치하세요. 이 절차는 `~/.config/opencode/resolve.json`을 삭제하지 않습니다.
+
+Linux/macOS:
+
+```sh
+export OPENCODE_CACHE_ROOT="${XDG_CACHE_HOME:-$HOME/.cache}/opencode"
+rm -rf "$OPENCODE_CACHE_ROOT/packages/opencode-resolve@latest"
+opencode plugin opencode-resolve@latest --global --force
+node -e "console.log(require(process.env.OPENCODE_CACHE_ROOT + '/packages/opencode-resolve@latest/node_modules/opencode-resolve/package.json').version)"
+```
+
+Windows PowerShell:
+
+```powershell
+$OpenCodeCacheRoot = if ($env:XDG_CACHE_HOME) { Join-Path $env:XDG_CACHE_HOME "opencode" } else { Join-Path $env:LOCALAPPDATA "opencode" }
+$PluginCache = Join-Path $OpenCodeCacheRoot "packages\opencode-resolve@latest"
+Remove-Item -Recurse -Force $PluginCache -ErrorAction SilentlyContinue
+opencode plugin opencode-resolve@latest --global --force
+$Pkg = Join-Path $PluginCache "node_modules\opencode-resolve\package.json"
+node -e "console.log(require(process.argv[1]).version)" $Pkg
+```
+
+캐시 새로고침 후 OpenCode를 재시작하세요.
+
 ### 수동 대안
 
 `postinstall`이 플러그인을 등록하지 않았다면, `~/.config/opencode/opencode.json`에 직접 추가:
@@ -655,8 +679,8 @@ opencode-resolve는 전체 저장소를 프롬프트에 밀어 넣지 않고도
 
 | 감지된 프로바이더 | 프리셋 |
 |---|---|
-| 인터랙티브 터미널 | 항상 `mix` / `gpt` / `glm`을 묻고 3티어 모델을 고르게 하며, `mix`에서는 `codex`와 `glm` primary 에이전트 활성화도 묻습니다 |
-| 비대화형 설치 | 모델 pinning을 추측하지 않음; `profile: "mix"`, `models: {}`를 쓰고 `resolver`, `codex`, `glm` primary 경로를 활성화 |
+| 인터랙티브 터미널 | 항상 `mix` / `gpt` / `glm`을 묻고 3티어 모델을 고르게 하며, `mix`에서는 `gpt`와 `glm` primary 에이전트 활성화도 묻습니다 |
+| 비대화형 설치 | opencode.json에서 프로바이더를 자동 감지하여 모델 적응 프리셋 작성. `resolver`, `gpt`, `glm` primary 경로 활성화 |
 | 레거시 opt-in | `OPENCODE_RESOLVE_AUTO_PRESET=1`을 설정하면 비대화형 provider-adapted 프리셋 허용 |
 | GLM/ZAI 감지 | API 키를 복사하지 않고 ZAI MCP 부트스트랩 추가 |
 
@@ -748,7 +772,7 @@ OPENCODE_RESOLVE_SKIP_POSTINSTALL=1 npm install -g opencode-resolve
 | `fast` | 빠른/저렴한 모델의 프로바이더 중립적 별칭 |
 | `strong` | 강력한/비싼 모델의 프로바이더 중립적 별칭 |
 | `mini` | 미니/효율적 모델의 프로바이더 중립적 별칭 |
-| `codex` | 코덱스 스타일 코딩 모델의 프로바이더 중립적 별칭 |
+| `codex` | 코덱스 스타일 코딩 모델의 프로바이더 중립적 별칭 (레거시) |
 | `bronze` / `silver` / `gold` | scout / coder / reasoner 3티어 별칭 |
 | `gpt-bronze` / `gpt-silver` / `gpt-gold` | mixed 설정의 GPT/Codex 전용 3티어 별칭 |
 | `glm-bronze` / `glm-silver` / `glm-gold` | mixed 설정의 GLM 전용 3티어 별칭 |
@@ -766,7 +790,8 @@ OPENCODE_RESOLVE_SKIP_POSTINSTALL=1 npm install -g opencode-resolve
 | 에이전트 | 기본 | 모드 | Edit | Bash | WebFetch | 용도 |
 |---|:---:|---|---|---|---|---|
 | `resolver` | 예 (핵심) | `all` | allow | ask (분류기 라우팅) | allow | 컨텍스트 효율적 오케스트레이터. 작업을 검증된 체크포인트로 분해, coder 디스패치, 각각 검증, 반복 회복 실패 시 차단 사항 보고. |
-| `codex` | 아니오 | `all` | allow | ask (분류기 라우팅) | allow | `resolver`와 같은 검증 resolve-loop 스타일의 Codex 최적화 primary. 최초 설치 GPT/mix 프리셋 또는 명시 설정으로 활성화. |
+| `codex` | 아니오 | `all` | allow | ask (분류기 라우팅) | allow | `resolver`와 같은 검증 resolve-loop 스타일의 Codex 최적화 primary. 레거시 — 새 GPT 설정에서는 `gpt` 권장. |
+| `gpt` | 아니오 | `all` | allow | ask (분류기 라우팅) | allow | `resolver`와 같은 검증 resolve-loop 스타일의 GPT 최적화 primary. 최초 설치 GPT/mix 프리셋 또는 명시 설정으로 활성화. |
 | `glm` | 아니오 | `all` | allow | ask (분류기 라우팅) | allow | `resolver`와 같은 검증 resolve-loop 스타일의 GLM 최적화 primary. 최초 설치 GLM/mix 프리셋 또는 명시 설정으로 활성화. |
 | `coder` | 예 (핵심) | `subagent` | allow | ask (분류기 라우팅) | allow | 집중된 구현자. 가장 작은 올바른 패치. 필요한 파일만 읽음. |
 | `explorer` | 예 (서브에이전트) | `subagent` | **deny** | **deny** | allow | 내부 빠른 코드베이스 스카우트. Resolver가 범위가 불명확할 때만 디스패치; 좁은 범위는 로컬 read/grep/glob 선호. |
@@ -864,6 +889,28 @@ opencode plugin opencode-resolve --global --force
 # OpenCode 재시작
 ```
 
+그래도 버전이 바뀌지 않으면 OpenCode가 패키지 캐시를 재사용하는 상태입니다. 해당 플러그인 캐시 항목만 hard refresh 하세요:
+
+Linux/macOS:
+
+```sh
+export OPENCODE_CACHE_ROOT="${XDG_CACHE_HOME:-$HOME/.cache}/opencode"
+rm -rf "$OPENCODE_CACHE_ROOT/packages/opencode-resolve@latest"
+opencode plugin opencode-resolve@latest --global --force
+node -e "console.log(require(process.env.OPENCODE_CACHE_ROOT + '/packages/opencode-resolve@latest/node_modules/opencode-resolve/package.json').version)"
+```
+
+Windows PowerShell:
+
+```powershell
+$OpenCodeCacheRoot = if ($env:XDG_CACHE_HOME) { Join-Path $env:XDG_CACHE_HOME "opencode" } else { Join-Path $env:LOCALAPPDATA "opencode" }
+$PluginCache = Join-Path $OpenCodeCacheRoot "packages\opencode-resolve@latest"
+Remove-Item -Recurse -Force $PluginCache -ErrorAction SilentlyContinue
+opencode plugin opencode-resolve@latest --global --force
+$Pkg = Join-Path $PluginCache "node_modules\opencode-resolve\package.json"
+node -e "console.log(require(process.argv[1]).version)" $Pkg
+```
+
 업그레이드 후 `postinstall`이 `resolve.json`에 추가적 마이그레이션을 실행합니다 — 새 키가 추가되고, 기존 키는 절대 수정되지 않습니다.
 
 ### 특정 버전 고정

package/README.md

@@ -156,8 +156,8 @@ The `postinstall` script automatically:
 
 1. Adds `opencode-resolve` to `~/.config/opencode/opencode.json` `plugin` array (if not already present).
 2. Creates `~/.config/opencode/resolve.json` adapted to your current model provider when the file does not exist:
-   - **Interactive terminal** → always asks for `mix` / `gpt` / `glm`, then lets you pick three-tier `bronze` / `silver` / `gold` models. In `mix`, it also asks whether to enable dedicated `codex` and `glm` primary agents.
-   - **Non-interactive install** → does not guess model pinning. It writes `profile: "mix"`, leaves `models: {}`, and enables the three primary routes (`resolver`, `codex`, `glm`) so you can pin models explicitly afterward.
+   - **Interactive terminal** → always asks for `mix` / `gpt` / `glm`, then lets you pick three-tier `bronze` / `silver` / `gold` models. In `mix`, it also asks whether to enable dedicated `gpt` and `glm` primary agents.
+   - **Non-interactive install** → auto-detects providers from opencode.json and writes a model-adapted preset. Enables `resolver`, `gpt`, and `glm` as primary routes.
    - **GLM/ZAI model detected** → still adds the non-secret local ZAI MCP bootstrap.
 
    Existing `resolve.json` files are **never overwritten without consent**. On reinstall, interactive setup asks whether to update the existing file or back it up and run fresh setup. For non-interactive automation, set `OPENCODE_RESOLVE_REINSTALL=fresh` or `OPENCODE_RESOLVE_REINSTALL=update`.
@@ -176,6 +176,30 @@ OPENCODE_RESOLVE_SKIP_POSTINSTALL=1 npm install -g opencode-resolve
 opencode plugin opencode-resolve --global --force
 ```
 
+If OpenCode keeps loading the old package anyway, clear only the OpenCode plugin cache entry and install again. This does **not** delete `~/.config/opencode/resolve.json`.
+
+Linux/macOS:
+
+```sh
+export OPENCODE_CACHE_ROOT="${XDG_CACHE_HOME:-$HOME/.cache}/opencode"
+rm -rf "$OPENCODE_CACHE_ROOT/packages/opencode-resolve@latest"
+opencode plugin opencode-resolve@latest --global --force
+node -e "console.log(require(process.env.OPENCODE_CACHE_ROOT + '/packages/opencode-resolve@latest/node_modules/opencode-resolve/package.json').version)"
+```
+
+Windows PowerShell:
+
+```powershell
+$OpenCodeCacheRoot = if ($env:XDG_CACHE_HOME) { Join-Path $env:XDG_CACHE_HOME "opencode" } else { Join-Path $env:LOCALAPPDATA "opencode" }
+$PluginCache = Join-Path $OpenCodeCacheRoot "packages\opencode-resolve@latest"
+Remove-Item -Recurse -Force $PluginCache -ErrorAction SilentlyContinue
+opencode plugin opencode-resolve@latest --global --force
+$Pkg = Join-Path $PluginCache "node_modules\opencode-resolve\package.json"
+node -e "console.log(require(process.argv[1]).version)" $Pkg
+```
+
+Restart OpenCode after the cache refresh.
+
 ### Manual fallback
 
 If `postinstall` didn't register the plugin, add it to `~/.config/opencode/opencode.json` yourself:
@@ -655,8 +679,8 @@ When `resolve.json` does **not** exist, postinstall inspects your OpenCode model
 
 | Detected provider | Preset |
 |---|---|
-| Interactive terminal | Always prompts for `mix` / `gpt` / `glm`, asks for three-tier model picks, and in `mix` asks whether to enable `codex` and `glm` primary agents |
-| Non-interactive install | Does not guess model pinning; writes `profile: "mix"`, `models: {}`, and enables `resolver`, `codex`, and `glm` as primary routes |
+| Interactive terminal | Always prompts for `mix` / `gpt` / `glm`, asks for three-tier model picks, and in `mix` asks whether to enable `gpt` and `glm` primary agents |
+| Non-interactive install | Auto-detects providers from opencode.json and writes a model-adapted preset with `resolver`, `gpt`, and `glm` enabled |
 | Legacy opt-in | Set `OPENCODE_RESOLVE_AUTO_PRESET=1` to allow non-interactive provider-adapted presets |
 | GLM/ZAI detected | Adds the ZAI MCP bootstrap without copying API keys |
 
@@ -748,9 +772,9 @@ In this setup, `plan` uses `openai/gpt-5.3-codex`; native `build`, resolve `code
 | `fast` | Provider-neutral alias for a fast/cheap model |
 | `strong` | Provider-neutral alias for a strong/expensive model |
 | `mini` | Provider-neutral alias for a mini/efficient model |
-| `codex` | Provider-neutral alias for a codex-style coding model |
+| `codex` | Provider-neutral alias for a codex-style coding model (legacy) |
 | `bronze` / `silver` / `gold` | Three-tier scout / coder / reasoner aliases |
-| `gpt-bronze` / `gpt-silver` / `gpt-gold` | GPT/Codex-specific three-tier aliases for mixed setups |
+| `gpt-bronze` / `gpt-silver` / `gpt-gold` | GPT-specific three-tier aliases for mixed setups |
 | `glm-bronze` / `glm-silver` / `glm-gold` | GLM-specific three-tier aliases for mixed setups |
 | `quick` | Legacy alias (equivalent to `fast`) |
 | `deep` | Legacy alias (equivalent to `strong`) |
@@ -766,7 +790,8 @@ Aliases only resolve when defined in `models`. Agent names (`coder`, `resolver`,
 | Agent | Default | Mode | Edit | Bash | WebFetch | Purpose |
 |---|:---:|---|---|---|---|---|
 | `resolver` | Yes (core) | `all` | allow | ask (classifier-routed) | allow | Context-efficient orchestrator. Decomposes work into verified checkpoints, dispatches coder, verifies each, and reports blockers when repeated recovery fails. |
-| `codex` | No | `all` | allow | ask (classifier-routed) | allow | Codex-optimized primary resolver with the same verified resolve-loop style as `resolver`. Enabled by first-install GPT/mix presets or explicitly. |
+| `codex` | No | `all` | allow | ask (classifier-routed) | allow | Codex-optimized primary resolver. Legacy — prefer `gpt` for new GPT setups. |
+| `gpt` | No | `all` | allow | ask (classifier-routed) | allow | GPT-optimized primary resolver with the same verified resolve-loop style as `resolver`. Enabled by first-install GPT/mix presets or explicitly. |
 | `glm` | No | `all` | allow | ask (classifier-routed) | allow | GLM-optimized primary resolver with the same verified resolve-loop style as `resolver`. Enabled by first-install GLM/mix presets or explicitly. |
 | `coder` | Yes (core) | `subagent` | allow | ask (classifier-routed) | allow | Focused implementer. Smallest correct patch. Reads only needed files. |
 | `explorer` | Yes (subagent) | `subagent` | **deny** | **deny** | allow | Internal fast codebase scout. Resolver dispatches when scope is genuinely unknown; prefers local read/grep/glob for narrow scope. |
@@ -864,6 +889,28 @@ opencode plugin opencode-resolve --global --force
 # Restart OpenCode
 ```
 
+If the version still does not change, OpenCode is reusing its package cache. Hard-refresh that one plugin entry:
+
+Linux/macOS:
+
+```sh
+export OPENCODE_CACHE_ROOT="${XDG_CACHE_HOME:-$HOME/.cache}/opencode"
+rm -rf "$OPENCODE_CACHE_ROOT/packages/opencode-resolve@latest"
+opencode plugin opencode-resolve@latest --global --force
+node -e "console.log(require(process.env.OPENCODE_CACHE_ROOT + '/packages/opencode-resolve@latest/node_modules/opencode-resolve/package.json').version)"
+```
+
+Windows PowerShell:
+
+```powershell
+$OpenCodeCacheRoot = if ($env:XDG_CACHE_HOME) { Join-Path $env:XDG_CACHE_HOME "opencode" } else { Join-Path $env:LOCALAPPDATA "opencode" }
+$PluginCache = Join-Path $OpenCodeCacheRoot "packages\opencode-resolve@latest"
+Remove-Item -Recurse -Force $PluginCache -ErrorAction SilentlyContinue
+opencode plugin opencode-resolve@latest --global --force
+$Pkg = Join-Path $PluginCache "node_modules\opencode-resolve\package.json"
+node -e "console.log(require(process.argv[1]).version)" $Pkg
+```
+
 After upgrading, `postinstall` runs additive migration on your `resolve.json` — new keys are added, existing keys are never modified.
 
 ### Pinning a specific version

package/dist/agents.d.ts

@@ -1,7 +1,7 @@
 import { ResolveAgentName, ResolveAgentConfig, ModelAlias, TierName } from "./types.js";
 export declare const DEFAULT_MODELS: Partial<Record<ModelAlias, string>>;
 export declare const DEFAULT_ENABLED: ResolveAgentName[];
-export declare const VALID_AGENT_NAMES: readonly ["coder", "reviewer", "resolver", "codex", "glm", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer", "planner"];
+export declare const VALID_AGENT_NAMES: readonly ["coder", "reviewer", "resolver", "codex", "gpt", "glm", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer", "planner"];
 export declare const VALID_AGENT_NAME_SET: Set<string>;
 export declare const DEFAULT_AGENT_CONFIG: Record<ResolveAgentName, Required<Pick<ResolveAgentConfig, "mode" | "description" | "prompt" | "color">> & ResolveAgentConfig>;
 export declare const GLM_CODER_PROMPT: string;
@@ -10,7 +10,7 @@ export declare function buildGLMResolverPrompt(maxParallelSubagents: number | un
 export declare function buildGPTResolverPrompt(): string;
 export declare function buildCodexResolverPrompt(): string;
 export declare function buildResolverPrompt(maxParallelSubagents: number | undefined): string;
-export declare const VALID_MODEL_ALIASES: readonly ["coder", "reviewer", "resolver", "codex", "glm", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer", "planner", "glm", "gpt", "quick", "deep", "fast", "strong", "mini", "codex", "bronze", "silver", "gold", "gpt-bronze", "gpt-silver", "gpt-gold", "glm-bronze", "glm-silver", "glm-gold"];
+export declare const VALID_MODEL_ALIASES: readonly ["coder", "reviewer", "resolver", "codex", "gpt", "glm", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer", "planner", "glm", "gpt", "quick", "deep", "fast", "strong", "mini", "codex", "bronze", "silver", "gold", "gpt-bronze", "gpt-silver", "gpt-gold", "glm-bronze", "glm-silver", "glm-gold"];
 export declare const VALID_MODEL_ALIAS_SET: Set<string>;
 export declare const VALID_PROFILES: Set<string>;
 export declare const VALID_TIERS: Set<string>;

package/dist/agents.js

@@ -5,6 +5,7 @@ export const VALID_AGENT_NAMES = [
     "reviewer",
     "resolver",
     "codex",
+    "gpt",
     "glm",
     "architect",
     "gpt-coder",
@@ -85,6 +86,18 @@ export const DEFAULT_AGENT_CONFIG = {
             webfetch: "allow",
         },
     },
+    gpt: {
+        mode: "all",
+        color: "#FFB347",
+        maxSteps: 35,
+        description: "GPT-optimized primary resolver for agentic coding work. Use when a GPT/OpenAI coding model is pinned and you want a dedicated user-facing route separate from the neutral resolver.",
+        prompt: buildGPTResolverPrompt(),
+        permission: {
+            edit: "allow",
+            bash: "ask",
+            webfetch: "allow",
+        },
+    },
     architect: {
         mode: "subagent",
         color: "#00BFFF",
@@ -368,11 +381,11 @@ export const VALID_MODEL_ALIAS_SET = new Set(VALID_MODEL_ALIASES);
 export const VALID_PROFILES = new Set(["mix", "glm", "gpt"]);
 export const VALID_TIERS = new Set(["bronze", "silver", "gold"]);
 export const GLM_ENABLED = ["coder", "resolver", "glm", "explorer", "reviewer", "planner"];
-export const GPT_ENABLED = ["coder", "resolver", "codex", "explorer", "reviewer", "deep-reviewer", "planner"];
+export const GPT_ENABLED = ["coder", "resolver", "gpt", "explorer", "reviewer", "deep-reviewer", "planner"];
 export const TIER_ENABLED = {
     bronze: ["coder", "resolver"],
     silver: ["coder", "resolver", "explorer", "reviewer", "planner"],
-    gold: ["coder", "resolver", "codex", "glm", "explorer", "reviewer", "deep-reviewer", "planner", "debugger", "researcher"],
+    gold: ["coder", "resolver", "codex", "gpt", "glm", "explorer", "reviewer", "deep-reviewer", "planner", "debugger", "researcher"],
 };
 export const GLM_AGENT_OVERRIDES = {
     coder: { maxSteps: 15 },
@@ -384,7 +397,7 @@ export const GLM_AGENT_OVERRIDES = {
 export const GPT_AGENT_OVERRIDES = {
     coder: { maxSteps: 25 },
     resolver: { maxSteps: 40 },
-    codex: { maxSteps: 40 },
+    gpt: { maxSteps: 40 },
     explorer: { maxSteps: 8 },
     reviewer: { maxSteps: 10 },
     "deep-reviewer": { maxSteps: 15 },

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 export type PermissionValue = "ask" | "allow" | "deny";
-export type ResolveAgentName = "coder" | "reviewer" | "resolver" | "codex" | "glm" | "architect" | "gpt-coder" | "debugger" | "researcher" | "explorer" | "deep-reviewer" | "planner";
+export type ResolveAgentName = "coder" | "reviewer" | "resolver" | "codex" | "gpt" | "glm" | "architect" | "gpt-coder" | "debugger" | "researcher" | "explorer" | "deep-reviewer" | "planner";
 export type ModelAlias = ResolveAgentName | "glm" | "gpt" | "quick" | "deep" | "fast" | "strong" | "mini" | "codex" | "bronze" | "silver" | "gold" | "gpt-bronze" | "gpt-silver" | "gpt-gold" | "glm-bronze" | "glm-silver" | "glm-gold";
 export type AgentMode = "subagent" | "primary" | "all";
 export type ResolveAgentConfig = {

package/opencode-resolve.example.json

@@ -17,6 +17,9 @@
     "codex": {
       "enabled": false
     },
+    "gpt": {
+      "enabled": false
+    },
     "explorer": {
       "enabled": true,
       "mode": "subagent"

package/opencode-resolve.reference.jsonc

@@ -118,9 +118,9 @@
 
   // -----------------------------------------------------------------------
   // models (object)
-  // Alias map. Keys are either an agent name (coder, reviewer, resolver,
-  // codex, glm, architect, gpt-coder, debugger, researcher, explorer,
-  // deep-reviewer, planner)
+// Alias map. Keys are either an agent name (coder, reviewer, resolver,
+// codex, gpt, glm, architect, gpt-coder, debugger, researcher, explorer,
+// deep-reviewer, planner)
   // OR one of the well-known aliases (`glm`, `gpt`, `quick`, `deep`,
   // `fast`, `strong`, `mini`, `codex`, `bronze`, `silver`, `gold`,
   // `gpt-bronze`, `gpt-silver`, `gpt-gold`, `glm-bronze`, `glm-silver`,
@@ -168,12 +168,12 @@
   //   third-party providers never blocks agent execution.
   //   "models": {
   //     "glm": "zai-coding-plan/glm-5.1",
-  //     "bronze": "zai-coding-plan/glm-5.1",
-  //     "silver": "zai-coding-plan/glm-5.1",
+  //     "bronze": "zai-coding-plan/glm-4.7-flash",
+  //     "silver": "zai-coding-plan/glm-5",
   //     "gold": "zai-coding-plan/glm-5.1",
   //     "fast": "bronze",
   //     "strong": "gold",
-  //     "coder": "silver",
+  //     "coder": "gold",
   //     "resolver": "gold",
   //     "reviewer": "gold",
   //     "deep-reviewer": "gold",
@@ -223,13 +223,26 @@
 
     // codex — Codex-optimized primary resolver (selectable in agent picker)
     // Same verified resolve-loop style as resolver, with a Codex-specific
-    // system prompt. Enabled by GPT/mix first-install presets when selected.
+    // system prompt. Legacy — kept for backward compatibility. New GPT
+    // installs should prefer the "gpt" agent instead.
     "codex": {
       "enabled": false,
       "mode": "all",
       "maxSteps": 35
     },
 
+    // -----------------------------------------------------------------
+    // gpt — GPT-optimized primary resolver (selectable in agent picker)
+    // GPT-specific verified resolve-loop with parallel coder dispatch,
+    // full agent roster, and higher maxSteps. Enabled automatically when
+    // GPT profile is selected during install. Uses buildGPTResolverPrompt().
+    // -----------------------------------------------------------------
+    "gpt": {
+      "enabled": false,
+      "mode": "all",
+      "maxSteps": 35
+    },
+
     // Internal specialist subagents — enabled by default as subagents only.
     // Core path is resolver→coder. These are dispatched only when justified.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-resolve",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "OpenCode plugin that adds a lightweight resolver/coder harness for continuous agentic coding.",
   "type": "module",
   "homepage": "https://github.com/jshsakura/opencode-resolve#readme",

package/scripts/install-local.mjs

@@ -100,7 +100,7 @@ async function createAdaptiveResolveConfig() {
     resolveConfig.models = {}
     resolveConfig.agents = {
       ...resolveConfig.agents,
-      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+      gpt: { ...(resolveConfig.agents?.gpt ?? {}), enabled: true },
       glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
     }
   }

package/scripts/postinstall.mjs

@@ -53,9 +53,13 @@ const OPENAI_MODEL_HINTS = [
 
 const GLM_MODEL_HINTS = [
   "zai-coding-plan/glm-5.1",
+  "zai-coding-plan/glm-5",
+  "zai-coding-plan/glm-4.7-flash",
+  "zai-coding-plan/glm-4.5-flash",
   "zai/glm-5.1",
   "zai/glm-5",
   "zai/glm-4.7-flash",
+  "zai/glm-4.7",
   "zai/glm-4.5-flash",
   "zai/glm-4.5",
   "zai/glm-4.5-air",
@@ -91,30 +95,55 @@ async function registerPlugin() {
   await mkdir(configDir, { recursive: true })
   const scriptedAnswers = await readScriptedAnswersIfNeeded()
 
-  const config = await readOpenCodeConfig()
-  let configChanged = addPlugin(config)
-
-  // Inject ZAI MCP servers when GLM is detected
-  const allModels = detectAllModels(config)
+  const probe = await readOpenCodeConfig()
+  const allModels = detectAllModels(probe)
   const hasGLM = allModels.some((m) => isGLMModel(m))
-  if (hasGLM) {
-    const mcpChanged = await injectZAIMCPs(config)
-    configChanged = configChanged || mcpChanged
-  }
+  const pluginNeeded = !isPluginRegisteredIn(probe)
+  const missingMCPNames = hasGLM
+    ? Object.keys(ZAI_MCP_SERVERS).filter((name) => probe.mcp?.[name] === undefined)
+    : []
 
-  if (configChanged) {
-    await writeFile(opencodeConfigPath, `${JSON.stringify(config, null, 2)}\n`)
+  if (pluginNeeded || missingMCPNames.length > 0) {
+    const fresh = await readOpenCodeConfig()
+    if (pluginNeeded) applyPluginPatch(fresh)
+    if (missingMCPNames.length > 0) applyMCPPatches(fresh, missingMCPNames)
+    await writeFile(opencodeConfigPath, `${JSON.stringify(fresh, null, 2)}\n`)
     console.log(`[${packageName}] updated ${opencodeConfigPath}`)
   } else {
     console.log(`[${packageName}] already registered in ${opencodeConfigPath}`)
   }
 
   if (!(await exists(resolveConfigPath))) {
-    await createAdaptiveResolveConfig(config, scriptedAnswers)
+    await createAdaptiveResolveConfig(probe, scriptedAnswers)
     return
   }
 
-  await handleExistingResolveConfig(config, scriptedAnswers)
+  await handleExistingResolveConfig(probe, scriptedAnswers)
+}
+
+function isPluginRegisteredIn(config) {
+  return Array.isArray(config.plugin) && config.plugin.some(isRegisteredPluginEntry)
+}
+
+function applyPluginPatch(config) {
+  config.plugin ??= []
+  if (!Array.isArray(config.plugin)) {
+    throw new Error(`${opencodeConfigPath}.plugin must be an array`)
+  }
+  if (!config.plugin.some(isRegisteredPluginEntry)) {
+    config.plugin.push(packageName)
+  }
+}
+
+function applyMCPPatches(config, names) {
+  config.mcp ??= {}
+  for (const name of names) {
+    if (config.mcp[name] === undefined) {
+      config.mcp[name] = ZAI_MCP_SERVERS[name]
+    }
+  }
+  console.log(`[${packageName}] injected ZAI MCP server config: ${names.join(", ")}`)
+  console.log(`[${packageName}] note: API keys are not copied into opencode.json; export Z_AI_API_KEY if the MCP server requires it.`)
 }
 
 async function handleExistingResolveConfig(opencodeConfig, scriptedAnswers) {
@@ -196,29 +225,11 @@ async function createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers) {
     return
   }
 
-  if (process.env.OPENCODE_RESOLVE_AUTO_PRESET !== "1") {
-    resolveConfig.profile = "mix"
-    delete resolveConfig.tier
-    resolveConfig.models = {}
-    resolveConfig.agents = {
-      ...resolveConfig.agents,
-      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
-      glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
-    }
-    await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
-    console.log(`[${packageName}] created ${resolveConfigPath} (preset: prompt-required)`)
-    console.log(`[${packageName}] model pinning was not guessed because no interactive prompt was available.`)
-    console.log(`[${packageName}] rerun setup in a TTY or edit ${resolveConfigPath} to choose GPT/GLM three-tier models.`)
-    return
-  }
-
-  // Profile selection based on detected providers
   const hasGLM = allModels.some((m) => isGLMModel(m))
   const hasGPT = allModels.some((m) => isGPTModel(m))
   const preset = buildModelPreset(currentModel, allModels)
 
   if (hasGLM && !hasGPT) {
-    // GLM only → GLM profile, silver tier (token-efficient, no deep-reviewer)
     resolveConfig.profile = "glm"
     resolveConfig.tier = "silver"
     resolveConfig.agents = {
@@ -226,20 +237,18 @@ async function createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers) {
       glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
     }
   } else if (hasGPT && !hasGLM) {
-    // GPT only → GPT profile, gold tier (full power)
     resolveConfig.profile = "gpt"
     resolveConfig.tier = "gold"
     resolveConfig.agents = {
       ...resolveConfig.agents,
-      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+      gpt: { ...(resolveConfig.agents?.gpt ?? {}), enabled: true },
     }
   } else {
-    // Mixed or unknown provider → explicit mix profile. No tier: use DEFAULT_ENABLED.
     resolveConfig.profile = "mix"
     if (hasGLM && hasGPT) {
       resolveConfig.agents = {
         ...resolveConfig.agents,
-        codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+        gpt: { ...(resolveConfig.agents?.gpt ?? {}), enabled: true },
         glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
       }
     }
@@ -247,6 +256,9 @@ async function createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers) {
 
   if (preset && Object.keys(preset).length > 0) {
     resolveConfig.models = preset
+  } else {
+    console.log(`[${packageName}] no GPT/GLM models detected in opencode.json — agents inherit the top-level model`)
+    console.log(`[${packageName}] to configure model pinning, rerun setup in a TTY or edit ${resolveConfigPath}`)
   }
 
   await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
@@ -327,7 +339,11 @@ function buildModelPreset(currentModel, allModels = []) {
 
   // GLM / ZAI — GLM-only preset (no GPT dependency, avoids token-exhaustion errors)
   if (lower.includes("glm") || lower.includes("zai")) {
-    return buildGLMOnlyPreset(currentModel)
+    return buildGLMOnlyPreset(currentModel, glmModels)
+  }
+
+  if (lower.includes("openai/") || lower.includes("gpt")) {
+    return buildGPTOnlyPreset(currentModel, gptModels)
   }
 
   // OpenAI / GPT single-provider preset
@@ -339,8 +355,9 @@ function buildModelPreset(currentModel, allModels = []) {
   return {}
 }
 
-function buildGLMOnlyPreset(model) {
-  const tiers = chooseThreeTier(collectModelChoices([model], isGLMModel, GLM_MODEL_HINTS, false), "glm", false)
+function buildGLMOnlyPreset(model, glmModels) {
+  const models = glmModels && glmModels.length > 0 ? glmModels : [model]
+  const tiers = chooseThreeTier(models, "glm", false)
   return {
     glm: tiers.gold,
     bronze: tiers.bronze,
@@ -349,7 +366,7 @@ function buildGLMOnlyPreset(model) {
     fast: "bronze",
     strong: "gold",
     mini: "bronze",
-    coder: "silver",
+    coder: "gold",
     resolver: "gold",
     reviewer: "gold",
     "deep-reviewer": "gold",
@@ -358,8 +375,9 @@ function buildGLMOnlyPreset(model) {
   }
 }
 
-function buildGPTOnlyPreset(model) {
-  const tiers = chooseThreeTier(collectModelChoices([model], isGPTModel, OPENAI_MODEL_HINTS, false), "gpt", false)
+function buildGPTOnlyPreset(model, gptModels) {
+  const models = gptModels && gptModels.length > 0 ? gptModels : [model]
+  const tiers = chooseThreeTier(models, "gpt", false)
   return {
     gpt: tiers.gold,
     bronze: tiers.bronze,
@@ -404,12 +422,17 @@ async function buildInteractivePreset(currentModel, allModels, scriptedAnswers)
         profile: "gpt",
         tier: "gold",
         models: buildGPTThreeTierModels(tiers),
-        agents: { codex: { enabled: true } },
+        agents: { gpt: { enabled: true } },
       }
     }
 
     if (profile === "glm") {
-      const tiers = await askThreeTier(rl, "GLM", choices.glm)
+      const useCodingPlan = await askYesNo(rl, "Use coding-plan (zai-coding-plan) instead of standard (zai)? [y/N]: ", false)
+      const glmChoices = useCodingPlan
+        ? choices.glm.map((m) => m.replace(/^zai\//, "zai-coding-plan/"))
+        : choices.glm.map((m) => m.replace(/^zai-coding-plan\//, "zai/"))
+      const deduped = unique([...glmChoices.filter((m) => isGLMModel(m)), ...GLM_MODEL_HINTS])
+      const tiers = await askThreeTier(rl, "GLM", deduped)
       return {
         label: "glm-three-tier",
         profile: "glm",
@@ -419,16 +442,16 @@ async function buildInteractivePreset(currentModel, allModels, scriptedAnswers)
       }
     }
 
-    const useCodex = await askYesNo(rl, "Enable dedicated Codex primary agent too? [Y/n]: ", true)
+    const useGPT = await askYesNo(rl, "Enable dedicated GPT primary agent too? [Y/n]: ", true)
     const useGLM = await askYesNo(rl, "Enable dedicated GLM primary agent too? [Y/n]: ", true)
-    const gptTiers = await askThreeTier(rl, "Codex/GPT", choices.gpt)
+    const gptTiers = await askThreeTier(rl, "GPT", choices.gpt)
     const glmTiers = await askThreeTier(rl, "GLM", choices.glm)
     return {
       label: "mix-three-tier",
       profile: "mix",
       models: buildMixedThreeTierModels(gptTiers, glmTiers),
       agents: {
-        codex: { enabled: useCodex },
+        gpt: { enabled: useGPT },
         glm: { enabled: useGLM },
       },
     }
@@ -539,7 +562,7 @@ function buildGLMThreeTierModels(tiers) {
     strong: "gold",
     mini: "bronze",
     explorer: "bronze",
-    coder: "silver",
+    coder: "gold",
     resolver: "gold",
     reviewer: "gold",
     "deep-reviewer": "gold",
@@ -561,7 +584,7 @@ function chooseThreeTier(models, family, includeFallbackHints = true) {
   const choices = unique(includeFallbackHints ? [...models, ...fallback] : models)
   return {
     bronze: preferModel(choices, family === "glm" ? ["flash", "air", "mini"] : ["spark", "mini", "4o-mini"], choices[0]),
-    silver: preferModel(choices, family === "glm" ? ["5.1", "4.5"] : ["codex", "5.3", "5.2"], choices[1] ?? choices[0]),
+    silver: preferModel(choices, family === "glm" ? ["4.7", "4.5", "5"] : ["codex", "5.3", "5.2"], choices[1] ?? choices[0]),
     gold: preferModel(choices, family === "glm" ? ["5.1", "5", "4.5"] : ["5.5", "5.4", "gpt-5.3-codex"], choices[2] ?? choices[1] ?? choices[0]),
   }
 }
@@ -724,38 +747,7 @@ async function readOpenCodeConfig() {
   return parsed
 }
 
-function addPlugin(config) {
-  config.plugin ??= []
-  if (!Array.isArray(config.plugin)) {
-    throw new Error(`${opencodeConfigPath}.plugin must be an array`)
-  }
-
-  if (config.plugin.some(isRegisteredPluginEntry)) return false
-  config.plugin.push(packageName)
-  return true
-}
-
-async function injectZAIMCPs(config) {
-  config.mcp ??= {}
-  if (!isObject(config.mcp)) return false
-
-  const added = []
-  for (const [name, mcpConfig] of Object.entries(ZAI_MCP_SERVERS)) {
-    if (config.mcp[name] === undefined) {
-      config.mcp[name] = mcpConfig
-      added.push(name)
-    }
-  }
-
-  if (added.length > 0) {
-    console.log(`[${packageName}] injected ZAI MCP server config: ${added.join(", ")}`)
-    console.log(`[${packageName}] note: API keys are not copied into opencode.json; export Z_AI_API_KEY if the MCP server requires it.`)
-    return true
-  }
 
-  console.log(`[${packageName}] ZAI MCP server already present — skipping`)
-  return false
-}
 
 function isRegisteredPluginEntry(entry) {
   if (typeof entry === "string") return isResolvePluginName(entry)
@@ -879,13 +871,25 @@ async function installCompanion(pkg) {
 }
 
 async function addCompanionToOpenCodeConfig(pluginEntry) {
-  const config = await readOpenCodeConfig()
-  config.plugin ??= []
-  if (!Array.isArray(config.plugin)) {
-    throw new Error(`${opencodeConfigPath}.plugin must be an array`)
-  }
   const baseName = stripVersionSuffix(pluginEntry)
-  const alreadyPresent = config.plugin.some((entry) => {
+  const probe = await readOpenCodeConfig()
+  const alreadyPresent = isCompanionPresent(probe, baseName)
+  if (alreadyPresent) return
+
+  const fresh = await readOpenCodeConfig()
+  if (!isCompanionPresent(fresh, baseName)) {
+    fresh.plugin ??= []
+    if (!Array.isArray(fresh.plugin)) {
+      throw new Error(`${opencodeConfigPath}.plugin must be an array`)
+    }
+    fresh.plugin.push(pluginEntry)
+    await writeFile(opencodeConfigPath, `${JSON.stringify(fresh, null, 2)}\n`)
+  }
+}
+
+function isCompanionPresent(config, baseName) {
+  if (!Array.isArray(config.plugin)) return false
+  return config.plugin.some((entry) => {
     const raw = typeof entry === "string"
       ? entry
       : Array.isArray(entry) && typeof entry[0] === "string"
@@ -893,7 +897,4 @@ async function addCompanionToOpenCodeConfig(pluginEntry) {
         : null
     return raw !== null && stripVersionSuffix(raw) === baseName
   })
-  if (alreadyPresent) return
-  config.plugin.push(pluginEntry)
-  await writeFile(opencodeConfigPath, `${JSON.stringify(config, null, 2)}\n`)
 }