opencode-resolve 0.1.8 → 0.1.10

package/README.ko.md

@@ -156,11 +156,11 @@ npm install -g opencode-resolve
 
 1. `opencode-resolve`를 `~/.config/opencode/opencode.json`의 `plugin` 배열에 추가 (이미 없는 경우).
 2. 파일이 존재하지 않는 경우, 현재 모델 프로바이더에 맞게 적응된 `~/.config/opencode/resolve.json`을 생성:
-   - **GLM/ZAI 모델 감지** → GLM-only 별칭 프리셋(GPT 의존 없음) 및 비밀값 없는 로컬 ZAI MCP 부트스트랩.
-   - **OpenAI/GPT 모델 감지** → 모든 역할에 현재 모델을 사용하는 단일 프로바이더 GPT 프리셋.
-   - **다른 프로바이더 또는 모델 없음** → 모델 중립적 `models: {}` (모든 역할이 OpenCode 기본 모델 상속).
+   - **인터랙티브 터미널** → 항상 `mix` / `gpt` / `glm`을 묻고, `bronze` / `silver` / `gold` 3티어 모델을 고르게 합니다. `mix`에서는 전용 `codex`, `glm` primary 에이전트를 켤지도 묻습니다.
+   - **비대화형 설치** → 모델 pinning을 추측하지 않습니다. `profile: "mix"`, `models: {}`를 쓰고 세 primary 경로(`resolver`, `codex`, `glm`)를 활성화하므로 이후 명시적으로 모델을 고르면 됩니다.
+   - **GLM/ZAI 모델 감지** → 비밀값 없는 로컬 ZAI MCP 부트스트랩은 계속 추가합니다.
 
-   기존 `resolve.json` 파일은 **절대 덮어쓰지 않습니다** — 적응형 프리셋은 최초 생성 시에만 적용됩니다. 다시 생성하려면 `resolve.json`을 삭제하고 재설치하세요.
+   기존 `resolve.json` 파일은 **동의 없이 덮어쓰지 않습니다**. 재설치 시 인터랙티브 환경이면 기존 파일을 업데이트할지, 백업 후 fresh setup을 다시 돌릴지 묻습니다. 비대화형 자동화에서는 `OPENCODE_RESOLVE_REINSTALL=fresh` 또는 `OPENCODE_RESOLVE_REINSTALL=update`를 설정하세요.
 
 자동 등록을 건너뛰려면:
 
@@ -552,7 +552,7 @@ opencode-resolve는 전체 저장소를 프롬프트에 밀어 넣지 않고도
 | `autoApprove` | `boolean` | `true` | 하위 호환/가독성 플래그. 현재 동작은 내장 기본 권한과 `permission.ask` bash 분류기가 제어하며, 이 플래그가 권한을 재작성하지 않음. |
 | `autoUpdate` | `boolean` | `true` | npm 버전 확인과 OpenCode 플러그인 캐시 갱신 알림을 best-effort로 수행. 비활성화하려면 false. |
 | `maxParallelSubagents` | `positive integer` | _미설정_ | 동시 coder 수에 대한 선택적 프롬프트 수준 상한. 미설정 시 resolver는 soft fan-out 가이드를 사용하고 rate-limit 에러에 backoff. GLM profile도 사용자가 설정하지 않는 한 hard cap을 걸지 않음. |
-| `models` | `object` | `{}` | 별칭 맵. 키는 에이전트 이름 또는 `fast`/`strong`/`mini`/`codex`/`quick`/`deep`/`glm`/`gpt`. 값은 모델 id 또는 다른 별칭. 기본적으로 비어있음 — 모든 역할이 OpenCode 기본 모델을 상속. |
+| `models` | `object` | `{}` | 별칭 맵. 키는 에이전트 이름 또는 `bronze`/`silver`/`gold`, `gpt-*`, `glm-*`, `fast`, `strong`, `mini`, `codex`, `quick`, `deep`, `glm`, `gpt` 같은 별칭. 값은 모델 id 또는 다른 별칭. |
 | `agents` | `object` | `{}` | 에이전트별 재정의 (아래 참조). |
 | `config` | `string` | _없음_ | 설정 파일의 사용자 정의 경로 (프로젝트 상대경로 또는 절대경로). |
 
@@ -647,6 +647,7 @@ opencode-resolve는 전체 저장소를 프롬프트에 밀어 넣지 않고도
 - 이미 설정한 키는 **절대** 수정하지 않음.
 - `enabled` 목록, `models` 맵, 또는 `agents` 재정의를 **절대** 다시 쓰지 않음.
 - `enabled`가 설정되어 있고 `"resolver"`를 포함하지 않으면, 추가를 제안하는 한 줄 팁을 출력. 파일은 그대로 유지.
+- 인터랙티브 재설치에서는 기존 파일을 업데이트할지, 백업 후 fresh setup을 다시 돌릴지 물음. 비대화형 자동화에서는 fresh 재설치에 `OPENCODE_RESOLVE_REINSTALL=fresh`, 보존 마이그레이션에 `OPENCODE_RESOLVE_REINSTALL=update` 사용.
 
 ### 적응형 최초 설치 프리셋
 
@@ -654,12 +655,12 @@ opencode-resolve는 전체 저장소를 프롬프트에 밀어 넣지 않고도
 
 | 감지된 프로바이더 | 프리셋 |
 |---|---|
-| GLM/ZAI + OpenAI/GPT | Mixed: `profile: "mix"`, scout/coder 별칭은 GLM, resolver/reviewer/planner 별칭은 GPT |
-| GLM / ZAI | GLM-only: 모든 resolve 에이전트가 GLM 별칭 사용, GPT 의존 없음 |
-| OpenAI / GPT | 단일 프로바이더: 모든 역할이 현재 OpenAI 모델 사용 |
-| 다른 프로바이더 또는 없음 | `profile: "mix"`와 모델 중립적 `models: {}` (모든 역할이 OpenCode 기본 모델 상속) |
+| 인터랙티브 터미널 | 항상 `mix` / `gpt` / `glm`을 묻고 3티어 모델을 고르게 하며, `mix`에서는 `codex`와 `glm` primary 에이전트 활성화도 묻습니다 |
+| 비대화형 설치 | 모델 pinning을 추측하지 않음; `profile: "mix"`, `models: {}`를 쓰고 `resolver`, `codex`, `glm` primary 경로를 활성화 |
+| 레거시 opt-in | `OPENCODE_RESOLVE_AUTO_PRESET=1`을 설정하면 비대화형 provider-adapted 프리셋 허용 |
+| GLM/ZAI 감지 | API 키를 복사하지 않고 ZAI MCP 부트스트랩 추가 |
 
-언제든지 프리셋을 변경하려면 `resolve.json`의 `models`를 직접 편집하거나, 파일을 삭제하고 재설치하세요.
+언제든지 프리셋을 변경하려면 `resolve.json`의 `models`를 직접 편집하거나, `OPENCODE_RESOLVE_REINSTALL=fresh`로 재설치하세요.
 
 마이그레이션을 완전히 건너뛰려면:
 
@@ -748,6 +749,9 @@ OPENCODE_RESOLVE_SKIP_POSTINSTALL=1 npm install -g opencode-resolve
 | `strong` | 강력한/비싼 모델의 프로바이더 중립적 별칭 |
 | `mini` | 미니/효율적 모델의 프로바이더 중립적 별칭 |
 | `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티어 별칭 |
 | `quick` | 레거시 별칭 (`fast`와 동등) |
 | `deep` | 레거시 별칭 (`strong`과 동등) |
 | `glm` | 레거시 별칭 (하위 호환성) |
@@ -762,6 +766,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 프리셋 또는 명시 설정으로 활성화. |
+| `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 선호. |
 | `reviewer` | 예 (서브에이전트) | `subagent` | **deny** | **deny** | allow | 내부 검증 갭 감사자. 비사소한 변경에 검증 갭이 있을 때 디스패치. |
@@ -784,7 +790,7 @@ OPENCODE_RESOLVE_SKIP_POSTINSTALL=1 npm install -g opencode-resolve
 
 지원되는 권한 값: `ask`, `allow`, `deny`.
 
-지원되는 모델 별칭 키: `fast`, `strong`, `mini`, `codex`, `quick`, `deep`, `glm`, `gpt`, 그리고 지원되는 모든 에이전트 이름. 별칭은 `models`에 정의된 경우에만 해석됩니다.
+지원되는 모델 별칭 키: `fast`, `strong`, `mini`, `codex`, `quick`, `deep`, `glm`, `gpt`, `bronze`, `silver`, `gold`, `gpt-bronze`, `gpt-silver`, `gpt-gold`, `glm-bronze`, `glm-silver`, `glm-gold`, 그리고 지원되는 모든 에이전트 이름. 별칭은 `models`에 정의된 경우에만 해석됩니다.
 
 `preserveNative`은 가독성을 위해 허용되지만, 네이티브 `plan`과 `build`는 항상 보존됩니다. 플러그인은 빌트인 OpenCode 에이전트를 절대 다시 쓰지 않습니다.
 
@@ -875,12 +881,20 @@ opencode plugin opencode-resolve --global --force
 
 ```sh
 npm install
+npm run hooks:install
 npm test
 npm run install:local
 ```
 
 `install:local`은 플러그인을 빌드하고, OpenCode 전역 플러그인 디렉토리에 링크하며, `~/.config/opencode/resolve.json`이 없으면 생성합니다.
 
+`hooks:install`은 이 checkout의 `core.hooksPath`를 `.githooks`로 설정합니다. 추적되는 훅은 의도적으로 빡세게 동작합니다:
+
+| 훅 | 게이트 |
+|---|---|
+| `pre-commit` | `npm run typecheck`, `npm test`, `npm run coverage` |
+| `pre-push` | 전체 `pre-commit` 게이트와 `npm pack --dry-run`을 통과해야 원격에 반영 |
+
 수동 로컬 설치:
 
 ```sh
@@ -900,6 +914,7 @@ ln -sf "$PWD/dist/index.js" ~/.config/opencode/plugins/opencode-resolve.js
 ```sh
 npm run typecheck
 npm test
+npm run coverage
 npm run build
 ```
 
@@ -910,6 +925,7 @@ npm run build
 ```sh
 npm run typecheck
 npm test
+npm run coverage
 npm audit --audit-level=moderate
 npm publish --dry-run
 ```

package/README.md

@@ -156,11 +156,11 @@ 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:
-   - **GLM/ZAI model detected** → GLM-only alias preset (no GPT dependency) and a non-secret local ZAI MCP bootstrap.
-   - **OpenAI/GPT model detected** → single-provider GPT preset using your current model for all roles.
-   - **Other or no model** → model-neutral `models: {}` (all roles inherit OpenCode default).
+   - **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.
+   - **GLM/ZAI model detected** → still adds the non-secret local ZAI MCP bootstrap.
 
-   Existing `resolve.json` files are **never overwritten** — the adaptive preset only applies to first-time creation. To regenerate, delete `resolve.json` and reinstall.
+   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`.
 
 To skip automatic registration:
 
@@ -552,7 +552,7 @@ Every accepted top-level option:
 | `autoApprove` | `boolean` | `true` | Compatibility/readability flag. Current behavior is controlled by built-in base permissions and the `permission.ask` bash classifier; the flag does not rewrite permissions. |
 | `autoUpdate` | `boolean` | `true` | Best-effort npm version check and OpenCode plugin cache refresh notice. Set false to disable. |
 | `maxParallelSubagents` | `positive integer` | _unset_ | Optional prompt-level cap on simultaneous coders. When unset, the resolver uses soft fan-out guidance and backs off on rate-limit errors. GLM profile does not impose a hard cap unless you set one. |
-| `models` | `object` | `{}` | Alias map. Keys are agent names or `fast`/`strong`/`mini`/`codex`/`quick`/`deep`/`glm`/`gpt`. Values are model ids or other aliases. Empty by default — all roles inherit the OpenCode default model. |
+| `models` | `object` | `{}` | Alias map. Keys are agent names or provider-neutral aliases including `bronze`/`silver`/`gold`, `gpt-*`, `glm-*`, `fast`, `strong`, `mini`, `codex`, `quick`, `deep`, `glm`, `gpt`. Values are model ids or other aliases. |
 | `agents` | `object` | `{}` | Per-agent overrides (see below). |
 | `config` | `string` | _none_ | Custom path to a config file (relative to the project or absolute). |
 
@@ -647,6 +647,7 @@ When you upgrade to a newer version of `opencode-resolve`, the `postinstall` scr
 - **Never** modifies keys you have already set.
 - **Never** rewrites your `enabled` list, `models` map, or `agents` overrides.
 - If `enabled` is set and does not include `"resolver"`, prints a one-line tip suggesting you add it. Your file is left untouched.
+- In an interactive reinstall, asks whether to update the existing file or back it up and run fresh setup. In non-interactive automation, use `OPENCODE_RESOLVE_REINSTALL=fresh` for a fresh reinstall or `OPENCODE_RESOLVE_REINSTALL=update` to preserve and migrate.
 
 ### Adaptive first-install preset
 
@@ -654,12 +655,12 @@ When `resolve.json` does **not** exist, postinstall inspects your OpenCode model
 
 | Detected provider | Preset |
 |---|---|
-| GLM/ZAI + OpenAI/GPT | Mixed: `profile: "mix"`, GLM for scout/coder aliases, GPT for resolver/reviewer/planner aliases |
-| GLM / ZAI | GLM-only: all resolve agents use GLM aliases, avoiding GPT dependency |
-| OpenAI / GPT | Single-provider: all roles use your current OpenAI model |
-| Other or none | `profile: "mix"` with model-neutral `models: {}` (all roles inherit OpenCode default) |
+| 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 |
+| 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 |
 
-To change presets at any time, edit `models` in `resolve.json` directly or delete the file and reinstall.
+To change presets at any time, edit `models` in `resolve.json` directly or run reinstall with `OPENCODE_RESOLVE_REINSTALL=fresh`.
 
 Skip the migration entirely with:
 
@@ -748,6 +749,9 @@ In this setup, `plan` uses `openai/gpt-5.3-codex`; native `build`, resolve `code
 | `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 |
+| `bronze` / `silver` / `gold` | Three-tier scout / coder / reasoner aliases |
+| `gpt-bronze` / `gpt-silver` / `gpt-gold` | GPT/Codex-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`) |
 | `glm` | Legacy alias (backward compatibility) |
@@ -762,6 +766,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. |
+| `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. |
 | `reviewer` | Yes (subagent) | `subagent` | **deny** | **deny** | allow | Internal verification-gap auditor. Resolver dispatches for post-change verification gaps on non-trivial changes. |
@@ -784,7 +790,7 @@ Supported modes:
 
 Supported permission values: `ask`, `allow`, `deny`.
 
-Supported model alias keys: `fast`, `strong`, `mini`, `codex`, `quick`, `deep`, `glm`, `gpt`, and every supported agent name. Aliases only resolve when defined in `models`.
+Supported model alias keys: `fast`, `strong`, `mini`, `codex`, `quick`, `deep`, `glm`, `gpt`, `bronze`, `silver`, `gold`, `gpt-bronze`, `gpt-silver`, `gpt-gold`, `glm-bronze`, `glm-silver`, `glm-gold`, and every supported agent name. Aliases only resolve when defined in `models`.
 
 `preserveNative` is accepted for readability, but native `plan` and `build` are always preserved. The plugin never rewrites built-in OpenCode agents.
 
@@ -875,12 +881,20 @@ From this repository:
 
 ```sh
 npm install
+npm run hooks:install
 npm test
 npm run install:local
 ```
 
 `install:local` builds the plugin, links it into the OpenCode global plugin directory, and creates `~/.config/opencode/resolve.json` if it does not exist.
 
+`hooks:install` sets this checkout's `core.hooksPath` to `.githooks`. The tracked hooks are intentionally strict:
+
+| Hook | Gate |
+|---|---|
+| `pre-commit` | `npm run typecheck`, `npm test`, `npm run coverage` |
+| `pre-push` | full `pre-commit` gate plus `npm pack --dry-run` before anything reaches the remote |
+
 Manual local install:
 
 ```sh
@@ -900,6 +914,7 @@ Run the normal checks:
 ```sh
 npm run typecheck
 npm test
+npm run coverage
 npm run build
 ```
 
@@ -910,6 +925,7 @@ Before publishing:
 ```sh
 npm run typecheck
 npm test
+npm run coverage
 npm audit --audit-level=moderate
 npm publish --dry-run
 ```

package/dist/agents.d.ts

@@ -1,15 +1,16 @@
 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", "glm", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer", "planner"];
+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_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;
 export declare const GPT_CODER_PROMPT: string;
 export declare function buildGLMResolverPrompt(maxParallelSubagents: number | undefined): string;
 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", "glm", "architect", "gpt-coder", "debugger", "researcher", "explorer", "deep-reviewer", "planner", "glm", "gpt", "quick", "deep", "fast", "strong", "mini", "codex", "bronze", "silver", "gold"];
+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_ALIAS_SET: Set<string>;
 export declare const VALID_PROFILES: Set<string>;
 export declare const VALID_TIERS: Set<string>;

package/dist/agents.js

@@ -4,6 +4,7 @@ export const VALID_AGENT_NAMES = [
     "coder",
     "reviewer",
     "resolver",
+    "codex",
     "glm",
     "architect",
     "gpt-coder",
@@ -72,6 +73,18 @@ export const DEFAULT_AGENT_CONFIG = {
             webfetch: "allow",
         },
     },
+    codex: {
+        mode: "all",
+        color: "#FFB347",
+        maxSteps: 35,
+        description: "Codex-optimized primary resolver for agentic coding work. Use when a Codex-style OpenAI coding model is pinned and you want a dedicated user-facing route separate from the neutral resolver.",
+        prompt: buildCodexResolverPrompt(),
+        permission: {
+            edit: "allow",
+            bash: "ask",
+            webfetch: "allow",
+        },
+    },
     architect: {
         mode: "subagent",
         color: "#00BFFF",
@@ -282,6 +295,23 @@ export function buildGPTResolverPrompt() {
         "Specialists: explorer (scope unknown), reviewer (verification gap), deep-reviewer (risky/security/architectural), debugger (verify failure diagnosis), planner (user asks for plan).",
     ].join("\n");
 }
+export function buildCodexResolverPrompt() {
+    return [
+        "You are Codex Resolver, the OpenAI Codex-optimized primary agent for OpenCode Resolve.",
+        "Use Codex-style software engineering judgment: inspect narrowly, patch directly when trivial, dispatch focused coders when parallel work is useful, and verify before reporting.",
+        "",
+        "Prefer coder for implementation slices, explorer for quick scope discovery, reviewer for verification gaps, deep-reviewer for risky/security/architecture changes, debugger for verify failure diagnosis, planner only when the user asks for a plan.",
+        "Dispatch coder with: TASK (atomic goal), OUTCOME (success criteria), MUST DO, MUST NOT DO, CONTEXT (files/patterns).",
+        "After EVERY coder return: verify it works + follows codebase patterns. If not → re-dispatch with precise fix.",
+        "INTELLIGENT RECOVERY: On verify failure, dispatch debugger FIRST to diagnose root cause, THEN re-dispatch coder with precise fix. Do NOT blindly retry.",
+        "Trivial fixes → apply yourself. No subagent needed.",
+        "3 consecutive failures → STOP, REVERT, REPORT, ASK user.",
+        "",
+        "Verify: type check or lint MUST pass on changed files. Check LSP diagnostics when available. NO EVIDENCE = NOT COMPLETE.",
+        "",
+        "NEVER: as any / @ts-ignore / leave code broken / delete failing tests / commit without request.",
+    ].join("\n");
+}
 export function buildResolverPrompt(maxParallelSubagents) {
     const explicitLimit = typeof maxParallelSubagents === "number" && Number.isFinite(maxParallelSubagents)
         ? Math.max(1, Math.trunc(maxParallelSubagents))
@@ -327,16 +357,22 @@ export const VALID_MODEL_ALIASES = [
     "bronze",
     "silver",
     "gold",
+    "gpt-bronze",
+    "gpt-silver",
+    "gpt-gold",
+    "glm-bronze",
+    "glm-silver",
+    "glm-gold",
 ];
 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", "explorer", "reviewer", "planner"];
-export const GPT_ENABLED = ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner"];
+export const GLM_ENABLED = ["coder", "resolver", "glm", "explorer", "reviewer", "planner"];
+export const GPT_ENABLED = ["coder", "resolver", "codex", "explorer", "reviewer", "deep-reviewer", "planner"];
 export const TIER_ENABLED = {
     bronze: ["coder", "resolver"],
     silver: ["coder", "resolver", "explorer", "reviewer", "planner"],
-    gold: ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner", "debugger", "researcher"],
+    gold: ["coder", "resolver", "codex", "glm", "explorer", "reviewer", "deep-reviewer", "planner", "debugger", "researcher"],
 };
 export const GLM_AGENT_OVERRIDES = {
     coder: { maxSteps: 15 },
@@ -348,6 +384,7 @@ export const GLM_AGENT_OVERRIDES = {
 export const GPT_AGENT_OVERRIDES = {
     coder: { maxSteps: 25 },
     resolver: { maxSteps: 40 },
+    codex: { maxSteps: 40 },
     explorer: { maxSteps: 8 },
     reviewer: { maxSteps: 10 },
     "deep-reviewer": { maxSteps: 15 },

package/dist/config.js

@@ -47,7 +47,7 @@ export function applyResolveConfig(config, resolveConfig, projectContext) {
                     agentConfig.prompt = buildResolverPrompt(maxParallelSubagents);
             }
             // Inject project context into all resolver-type agents
-            if ((name === "resolver" || name === "glm") && contextInjection) {
+            if ((name === "resolver" || name === "codex" || name === "glm") && contextInjection) {
                 agentConfig.prompt = agentConfig.prompt + "\n\n" + contextInjection;
             }
             // Inject verify commands into coder prompts
@@ -153,7 +153,13 @@ export function mergeAgents(left, right) {
 export function resolveModel(model, models) {
     if (!model)
         return undefined;
-    return models[model] ?? model;
+    let current = model;
+    const seen = new Set();
+    while (models[current] !== undefined && !seen.has(current)) {
+        seen.add(current);
+        current = models[current] ?? current;
+    }
+    return current;
 }
 export function buildPermission(basePermission, userPermission) {
     const merged = {

package/dist/hooks/index.js

@@ -192,7 +192,7 @@ export function getHooks(directory, options, sessionState) {
                 output.temperature = capTemperature(output.temperature, 0.3);
             }
             // Write agents: slightly higher temperature for creative problem-solving
-            const writeAgents = new Set(["coder", "resolver", "glm", "gpt-coder"]);
+            const writeAgents = new Set(["coder", "resolver", "codex", "glm", "gpt-coder"]);
             if (writeAgents.has(input.agent) && output.temperature === undefined) {
                 output.temperature = 0.5;
             }

package/dist/tools/index.js

@@ -5,7 +5,7 @@ import { writeFileSync, mkdirSync } from "node:fs";
 import { classifyBashCommand, runCommand, sanitizeShellArg, truncateOutput } from "../utils.js";
 import { DIAGNOSTICS_TTL_MS } from "../state.js";
 import { VALID_PROFILES, VALID_TIERS, VALID_AGENT_NAME_SET, VALID_AGENT_NAMES } from "../agents.js";
-const WRITE_CAPABLE_AGENTS = new Set(["resolver", "coder", "glm", "gpt-coder", "debugger"]);
+const WRITE_CAPABLE_AGENTS = new Set(["resolver", "codex", "coder", "glm", "gpt-coder", "debugger"]);
 function canWriteFromTool(ctx) {
     return typeof ctx.agent !== "string" || WRITE_CAPABLE_AGENTS.has(ctx.agent);
 }

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export type PermissionValue = "ask" | "allow" | "deny";
-export type ResolveAgentName = "coder" | "reviewer" | "resolver" | "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";
+export type ResolveAgentName = "coder" | "reviewer" | "resolver" | "codex" | "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 = {
     enabled?: boolean;

package/opencode-resolve.example.json

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

package/opencode-resolve.reference.jsonc

@@ -119,9 +119,12 @@
   // -----------------------------------------------------------------------
   // models (object)
   // Alias map. Keys are either an agent name (coder, reviewer, resolver,
-  // architect, gpt-coder, debugger, researcher, explorer, deep-reviewer)
+  // codex, 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`).
+  // `fast`, `strong`, `mini`, `codex`, `bronze`, `silver`, `gold`,
+  // `gpt-bronze`, `gpt-silver`, `gpt-gold`, `glm-bronze`, `glm-silver`,
+  // `glm-gold`).
   // Values are model identifiers OR another alias.
   //
   // Resolution order for a given agent:
@@ -137,11 +140,17 @@
   // 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 → GLM-only aliases (no GPT dependency)
-  //   - 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.
+  //   - interactive terminal → always prompts for mix/gpt/glm, three-tier models,
+  //     and optional dedicated codex/glm primary agents
+  //   - non-interactive install → no guessed model pinning; profile mix,
+  //     models {}, and resolver/codex/glm primary routes enabled
+  //   - OPENCODE_RESOLVE_AUTO_PRESET=1 → legacy non-interactive
+  //     provider-adapted presets
+  // Existing resolve.json files are never overwritten without consent.
+  // Interactive reinstall asks whether to update or back up and run fresh
+  // setup. Non-interactive automation can set:
+  //   OPENCODE_RESOLVE_REINSTALL=fresh
+  //   OPENCODE_RESOLVE_REINSTALL=update
   //
   // Example — one efficient model for everything (recommended default):
   //   "models": {}
@@ -154,19 +163,22 @@
   //     "resolver": "strong"
   //   }
   //
-  // Example — GLM-only preset (auto-generated for GLM/ZAI users):
-  //   All agents use GLM — no GPT dependency, so token exhaustion on
+  // Example — GLM-only three-tier preset (auto-generated for GLM/ZAI users):
+  //   GLM fills all tiers — no GPT dependency, so token exhaustion on
   //   third-party providers never blocks agent execution.
   //   "models": {
   //     "glm": "zai-coding-plan/glm-5.1",
-  //     "fast": "glm",
-  //     "strong": "glm",
-  //     "coder": "glm",
-  //     "resolver": "glm",
-  //     "reviewer": "glm",
-  //     "deep-reviewer": "glm",
-  //     "explorer": "fast",
-  //     "planner": "glm"
+  //     "bronze": "zai-coding-plan/glm-5.1",
+  //     "silver": "zai-coding-plan/glm-5.1",
+  //     "gold": "zai-coding-plan/glm-5.1",
+  //     "fast": "bronze",
+  //     "strong": "gold",
+  //     "coder": "silver",
+  //     "resolver": "gold",
+  //     "reviewer": "gold",
+  //     "deep-reviewer": "gold",
+  //     "explorer": "bronze",
+  //     "planner": "gold"
   //   }
   //
   // Legacy aliases (glm, gpt, quick, deep) remain supported for backward
@@ -209,6 +221,15 @@
       }
     },
 
+    // 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.
+    "codex": {
+      "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.8",
+  "version": "0.1.10",
   "description": "OpenCode plugin that adds a lightweight resolver/coder harness for continuous agentic coding.",
   "type": "module",
   "homepage": "https://github.com/jshsakura/opencode-resolve#readme",
@@ -30,9 +30,13 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "coverage": "npm run build && node --experimental-test-coverage --test-coverage-lines=79 --test-coverage-branches=69 --test-coverage-functions=85 --test test/*.mjs",
+    "hooks:install": "node scripts/install-git-hooks.mjs",
     "install:local": "npm run build && node scripts/install-local.mjs",
     "postinstall": "node scripts/postinstall.mjs",
     "prepack": "npm test",
+    "precommit": "npm run typecheck && npm test && npm run coverage",
+    "prepush": "npm run precommit && npm pack --dry-run",
     "test": "npm run build && node --test test/*.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },

package/scripts/install-git-hooks.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process"
+import { chmodSync, existsSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)))
+const hooksDir = join(root, ".githooks")
+
+if (!existsSync(join(root, ".git"))) {
+  console.error("[opencode-resolve] not a git checkout; cannot install hooks")
+  process.exit(1)
+}
+
+for (const hook of ["pre-commit", "pre-push"]) {
+  chmodSync(join(hooksDir, hook), 0o755)
+}
+
+const result = spawnSync("git", ["config", "core.hooksPath", ".githooks"], {
+  cwd: root,
+  stdio: "inherit",
+})
+
+if (result.status !== 0) {
+  process.exit(result.status ?? 1)
+}
+
+console.log("[opencode-resolve] git hooks installed: core.hooksPath=.githooks")

package/scripts/install-local.mjs

@@ -2,6 +2,7 @@ import { constants } from "node:fs"
 import { access, mkdir, readFile, symlink, unlink, writeFile } from "node:fs/promises"
 import { homedir } from "node:os"
 import { dirname, join, resolve } from "node:path"
+import { createInterface } from "node:readline/promises"
 import { fileURLToPath } from "node:url"
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..")
@@ -25,11 +26,58 @@ await symlink(pluginTarget, pluginLink)
 
 if (!(await exists(resolveConfigPath))) {
   await createAdaptiveResolveConfig()
+} else {
+  await handleExistingResolveConfig()
 }
 
 console.log(`Linked plugin: ${pluginLink} -> ${pluginTarget}`)
 console.log(`Resolve config: ${resolveConfigPath}`)
 
+async function handleExistingResolveConfig() {
+  const action = await chooseExistingResolveConfigAction()
+  if (action !== "fresh") {
+    console.log(`Existing resolve config preserved: ${resolveConfigPath}`)
+    return
+  }
+
+  await backupResolveConfig()
+  await createAdaptiveResolveConfig()
+}
+
+async function chooseExistingResolveConfigAction() {
+  const requested = (process.env.OPENCODE_RESOLVE_REINSTALL ?? "").trim().toLowerCase()
+  if (["fresh", "reset", "recreate", "new"].includes(requested)) return "fresh"
+  if (["update", "keep", "migrate", "preserve"].includes(requested)) return "update"
+  if (requested) {
+    console.warn(`Ignoring unknown OPENCODE_RESOLVE_REINSTALL=${JSON.stringify(requested)}; use "fresh" or "update".`)
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.log(`Existing resolve config found; preserving it. Set OPENCODE_RESOLVE_REINSTALL=fresh for a fresh reinstall.`)
+    return "update"
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    console.log("")
+    console.log(`Existing resolve config found: ${resolveConfigPath}`)
+    console.log("  1. update existing config — preserve your settings")
+    console.log("  2. fresh reinstall — back up resolve.json and create a new config")
+    const raw = await rl.question("Existing config [1=update, 2=fresh reinstall, default 1]: ")
+    return raw.trim() === "2" ? "fresh" : "update"
+  } finally {
+    rl.close()
+  }
+}
+
+async function backupResolveConfig() {
+  const raw = await readFile(resolveConfigPath, "utf8")
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const backupPath = `${resolveConfigPath}.bak.${stamp}`
+  await writeFile(backupPath, raw)
+  console.log(`Backed up existing resolve config to ${backupPath}`)
+}
+
 async function createAdaptiveResolveConfig() {
   const raw = await readFile(exampleConfig, "utf8")
   const example = JSON.parse(raw)
@@ -42,10 +90,20 @@ async function createAdaptiveResolveConfig() {
     // opencode.json not found or unreadable — use empty config
   }
 
-  const currentModel = detectOpenCodeModel(opencodeConfig)
-  const preset = buildModelPreset(currentModel)
-
   const resolveConfig = { ...example }
+  let preset = {}
+  if (process.env.OPENCODE_RESOLVE_AUTO_PRESET === "1") {
+    const currentModel = detectOpenCodeModel(opencodeConfig)
+    preset = buildModelPreset(currentModel)
+  } else {
+    resolveConfig.profile = "mix"
+    resolveConfig.models = {}
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+      glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
+    }
+  }
   if (preset && Object.keys(preset).length > 0) {
     resolveConfig.models = preset
   }
@@ -53,7 +111,9 @@ async function createAdaptiveResolveConfig() {
   await mkdir(configDir, { recursive: true })
   await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
 
-  const label = getPresetLabel(currentModel)
+  const label = process.env.OPENCODE_RESOLVE_AUTO_PRESET === "1"
+    ? getPresetLabel(detectOpenCodeModel(opencodeConfig))
+    : "prompt-required"
   console.log(`Created ${resolveConfigPath} (preset: ${label})`)
 }
 

package/scripts/postinstall.mjs

@@ -41,6 +41,26 @@ const COMPANION_PLUGINS = [
   },
 ]
 
+const OPENAI_MODEL_HINTS = [
+  "openai/gpt-5.5",
+  "openai/gpt-5.4",
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.3-codex-spark",
+  "openai/gpt-5.2",
+  "openai/gpt-5-mini",
+  "openai/gpt-4o-mini",
+]
+
+const GLM_MODEL_HINTS = [
+  "zai-coding-plan/glm-5.1",
+  "zai/glm-5.1",
+  "zai/glm-5",
+  "zai/glm-4.7-flash",
+  "zai/glm-4.5-flash",
+  "zai/glm-4.5",
+  "zai/glm-4.5-air",
+]
+
 if (process.env.OPENCODE_RESOLVE_SKIP_POSTINSTALL === "1") {
   process.exit(0)
 }
@@ -69,6 +89,7 @@ async function readOwnVersion() {
 
 async function registerPlugin() {
   await mkdir(configDir, { recursive: true })
+  const scriptedAnswers = await readScriptedAnswersIfNeeded()
 
   const config = await readOpenCodeConfig()
   let configChanged = addPlugin(config)
@@ -89,14 +110,62 @@ async function registerPlugin() {
   }
 
   if (!(await exists(resolveConfigPath))) {
-    await createAdaptiveResolveConfig(config)
+    await createAdaptiveResolveConfig(config, scriptedAnswers)
+    return
+  }
+
+  await handleExistingResolveConfig(config, scriptedAnswers)
+}
+
+async function handleExistingResolveConfig(opencodeConfig, scriptedAnswers) {
+  const action = await chooseExistingResolveConfigAction(scriptedAnswers)
+  if (action === "fresh") {
+    await backupResolveConfig()
+    await createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers)
     return
   }
 
   await migrateResolveConfig()
 }
 
-async function createAdaptiveResolveConfig(opencodeConfig) {
+async function chooseExistingResolveConfigAction(scriptedAnswers) {
+  const requested = (process.env.OPENCODE_RESOLVE_REINSTALL ?? "").trim().toLowerCase()
+  if (["fresh", "reset", "recreate", "new"].includes(requested)) return "fresh"
+  if (["update", "keep", "migrate", "preserve"].includes(requested)) return "update"
+  if (requested) {
+    console.warn(`[${packageName}] ignoring unknown OPENCODE_RESOLVE_REINSTALL=${JSON.stringify(requested)}; use "fresh" or "update".`)
+  }
+
+  const forcePrompt = process.env.OPENCODE_RESOLVE_FORCE_PROMPT === "1"
+  const canPrompt = Boolean((process.stdin.isTTY && process.stdout.isTTY) || forcePrompt)
+  if (!canPrompt) {
+    console.log(`[${packageName}] existing ${resolveConfigPath} found; preserving it and applying additive updates.`)
+    console.log(`[${packageName}] for a fresh reinstall, rerun in a TTY or set OPENCODE_RESOLVE_REINSTALL=fresh.`)
+    return "update"
+  }
+
+  const rl = createPromptInterface(scriptedAnswers)
+  try {
+    console.log("")
+    console.log(`[${packageName}] Existing resolve config found: ${resolveConfigPath}`)
+    console.log("  1. update existing config — preserve your settings and add missing defaults")
+    console.log("  2. fresh reinstall — back up resolve.json and run setup again")
+    const answer = await askChoice(rl, "Existing config [1=update, 2=fresh reinstall, default 1]: ", ["1", "2"], "1")
+    return answer === "2" ? "fresh" : "update"
+  } finally {
+    rl.close()
+  }
+}
+
+async function backupResolveConfig() {
+  const raw = await readFile(resolveConfigPath, "utf8")
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const backupPath = `${resolveConfigPath}.bak.${stamp}`
+  await writeFile(backupPath, raw)
+  console.log(`[${packageName}] backed up existing resolve config to ${backupPath}`)
+}
+
+async function createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers) {
   await assertReadable(exampleConfigPath)
   const raw = await readFile(exampleConfigPath, "utf8")
   const example = JSON.parse(raw)
@@ -104,6 +173,44 @@ async function createAdaptiveResolveConfig(opencodeConfig) {
   const currentModel = detectOpenCodeModel(opencodeConfig)
   const allModels = detectAllModels(opencodeConfig)
   const resolveConfig = { ...example }
+  const forcePrompt = process.env.OPENCODE_RESOLVE_FORCE_PROMPT === "1"
+  const canPrompt = Boolean(
+    (process.stdin.isTTY && process.stdout.isTTY) || forcePrompt,
+  )
+  const interactivePreset = canPrompt
+    ? await buildInteractivePreset(currentModel, allModels, scriptedAnswers)
+    : undefined
+
+  if (interactivePreset) {
+    resolveConfig.profile = interactivePreset.profile
+    if (interactivePreset.tier) resolveConfig.tier = interactivePreset.tier
+    else delete resolveConfig.tier
+    if (interactivePreset.enabled) resolveConfig.enabled = interactivePreset.enabled
+    resolveConfig.models = interactivePreset.models
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      ...(interactivePreset.agents ?? {}),
+    }
+    await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
+    console.log(`[${packageName}] created ${resolveConfigPath} (preset: ${interactivePreset.label})`)
+    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))
@@ -114,13 +221,28 @@ async function createAdaptiveResolveConfig(opencodeConfig) {
     // GLM only → GLM profile, silver tier (token-efficient, no deep-reviewer)
     resolveConfig.profile = "glm"
     resolveConfig.tier = "silver"
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      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 },
+    }
   } 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 },
+        glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
+      }
+    }
   }
 
   if (preset && Object.keys(preset).length > 0) {
@@ -161,21 +283,33 @@ function detectOpenCodeModel(config) {
 }
 
 function buildModelPreset(currentModel, allModels = []) {
-  const glmModel = allModels.find((m) => isGLMModel(m))
-  const gptModel = allModels.find((m) => isGPTModel(m))
+  const detectedGLMModels = allModels.filter(isGLMModel)
+  const detectedGPTModels = allModels.filter(isGPTModel)
+  const glmModels = detectedGLMModels.length > 0 ? collectModelChoices(detectedGLMModels, isGLMModel, GLM_MODEL_HINTS, false) : []
+  const gptModels = detectedGPTModels.length > 0 ? collectModelChoices(detectedGPTModels, isGPTModel, OPENAI_MODEL_HINTS, false) : []
+  const glmModel = glmModels[0]
+  const gptModel = gptModels[0]
 
   if (glmModel && gptModel) {
+    const glmTiers = chooseThreeTier(glmModels, "glm", false)
+    const gptTiers = chooseThreeTier(gptModels, "gpt", false)
     return {
       mix: "gpt",
-      glm: glmModel,
-      gpt: gptModel,
-      bronze: "glm",
-      silver: "glm",
-      gold: "gpt",
-      fast: "glm",
-      strong: "gpt",
-      mini: "glm",
-      codex: "gpt",
+      gpt: gptTiers.gold,
+      bronze: glmTiers.bronze,
+      silver: glmTiers.silver,
+      gold: gptTiers.gold,
+      "glm-bronze": glmTiers.bronze,
+      "glm-silver": glmTiers.silver,
+      "glm-gold": glmTiers.gold,
+      "gpt-bronze": gptTiers.bronze,
+      "gpt-silver": gptTiers.silver,
+      "gpt-gold": gptTiers.gold,
+      fast: "bronze",
+      strong: "gold",
+      mini: "bronze",
+      codex: "gpt-gold",
+      glm: glmTiers.gold,
       explorer: "bronze",
       coder: "silver",
       resolver: "gold",
@@ -186,8 +320,6 @@ function buildModelPreset(currentModel, allModels = []) {
   }
 
   if (!currentModel) {
-    if (glmModel) return buildGLMOnlyPreset(glmModel)
-    if (gptModel) return buildGPTOnlyPreset(gptModel)
     return {}
   }
 
@@ -208,32 +340,256 @@ function buildModelPreset(currentModel, allModels = []) {
 }
 
 function buildGLMOnlyPreset(model) {
+  const tiers = chooseThreeTier(collectModelChoices([model], isGLMModel, GLM_MODEL_HINTS, false), "glm", false)
   return {
-    glm: model,
-    fast: "glm",
-    strong: "glm",
-    coder: "glm",
-    resolver: "glm",
-    reviewer: "glm",
-    "deep-reviewer": "glm",
-    explorer: "fast",
-    planner: "glm",
+    glm: tiers.gold,
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    explorer: "bronze",
+    planner: "gold",
   }
 }
 
 function buildGPTOnlyPreset(model) {
+  const tiers = chooseThreeTier(collectModelChoices([model], isGPTModel, OPENAI_MODEL_HINTS, false), "gpt", false)
+  return {
+    gpt: tiers.gold,
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    codex: "gold",
+    coder: "silver",
+    resolver: "gold",
+    explorer: "bronze",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+  }
+}
+
+async function buildInteractivePreset(currentModel, allModels, scriptedAnswers) {
+  const choices = {
+    gpt: collectModelChoices(allModels, isGPTModel, OPENAI_MODEL_HINTS),
+    glm: collectModelChoices(allModels, isGLMModel, GLM_MODEL_HINTS),
+  }
+  if (currentModel) {
+    if (isGPTModel(currentModel)) choices.gpt = unique([currentModel, ...choices.gpt])
+    if (isGLMModel(currentModel)) choices.glm = unique([currentModel, ...choices.glm])
+  }
+
+  const rl = createPromptInterface(scriptedAnswers)
+  try {
+    console.log("")
+    console.log(`[${packageName}] Choose resolve profile:`)
+    console.log("  1. mix — neutral resolver plus optional Codex and GLM primary agents")
+    console.log("  2. gpt — GPT/Codex-only, three-tier")
+    console.log("  3. glm — GLM-only, three-tier")
+    const profileAnswer = await askChoice(rl, "Profile [1=mix, 2=gpt, 3=glm, default 1]: ", ["1", "2", "3"], "1")
+    const profile = profileAnswer === "2" ? "gpt" : profileAnswer === "3" ? "glm" : "mix"
+
+    if (profile === "gpt") {
+      const tiers = await askThreeTier(rl, "GPT/Codex", choices.gpt)
+      return {
+        label: "gpt-three-tier",
+        profile: "gpt",
+        tier: "gold",
+        models: buildGPTThreeTierModels(tiers),
+        agents: { codex: { enabled: true } },
+      }
+    }
+
+    if (profile === "glm") {
+      const tiers = await askThreeTier(rl, "GLM", choices.glm)
+      return {
+        label: "glm-three-tier",
+        profile: "glm",
+        tier: "gold",
+        models: buildGLMThreeTierModels(tiers),
+        agents: { glm: { enabled: true } },
+      }
+    }
+
+    const useCodex = await askYesNo(rl, "Enable dedicated Codex 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 glmTiers = await askThreeTier(rl, "GLM", choices.glm)
+    return {
+      label: "mix-three-tier",
+      profile: "mix",
+      models: buildMixedThreeTierModels(gptTiers, glmTiers),
+      agents: {
+        codex: { enabled: useCodex },
+        glm: { enabled: useGLM },
+      },
+    }
+  } finally {
+    rl.close()
+  }
+}
+
+function createPromptInterface(scriptedAnswers) {
+  return scriptedAnswers
+    ? {
+        async question(prompt) {
+          const answer = scriptedAnswers.length > 0 ? scriptedAnswers.shift() ?? "" : ""
+          process.stdout.write(prompt)
+          process.stdout.write(`${answer}\n`)
+          return answer
+        },
+        close() {},
+      }
+    : createInterface({ input: process.stdin, output: process.stdout })
+}
+
+async function askThreeTier(rl, label, models) {
+  const choices = models.length > 0 ? models : (label.toLowerCase().includes("glm") ? GLM_MODEL_HINTS : OPENAI_MODEL_HINTS)
+  console.log("")
+  console.log(`[${packageName}] ${label} model choices:`)
+  choices.forEach((model, index) => console.log(`  ${index + 1}. ${model}`))
+  const defaults = chooseThreeTier(choices, label.toLowerCase().includes("glm") ? "glm" : "gpt")
+  const bronze = await askModel(rl, choices, `Pick ${label} bronze/scout [default ${defaults.bronze}]: `, defaults.bronze)
+  const silver = await askModel(rl, choices, `Pick ${label} silver/coder [default ${defaults.silver}]: `, defaults.silver)
+  const gold = await askModel(rl, choices, `Pick ${label} gold/reasoner [default ${defaults.gold}]: `, defaults.gold)
+  return { bronze, silver, gold }
+}
+
+async function askModel(rl, choices, question, defaultValue) {
+  const answer = (await rl.question(question)).trim()
+  if (!answer) return defaultValue
+  const index = Number.parseInt(answer, 10)
+  if (Number.isInteger(index) && index >= 1 && index <= choices.length) return choices[index - 1]
+  return answer
+}
+
+async function askChoice(rl, question, valid, defaultValue) {
+  const answer = (await rl.question(question)).trim().toLowerCase()
+  if (!answer) return defaultValue
+  return valid.includes(answer) ? answer : defaultValue
+}
+
+async function askYesNo(rl, question, defaultValue) {
+  const answer = (await rl.question(question)).trim().toLowerCase()
+  if (!answer) return defaultValue
+  return answer === "y" || answer === "yes"
+}
+
+function buildMixedThreeTierModels(gptTiers, glmTiers) {
+  return {
+    mix: "gpt-gold",
+    gpt: "gpt-gold",
+    glm: "glm-gold",
+    bronze: "glm-bronze",
+    silver: "glm-silver",
+    gold: "gpt-gold",
+    "gpt-bronze": gptTiers.bronze,
+    "gpt-silver": gptTiers.silver,
+    "gpt-gold": gptTiers.gold,
+    "glm-bronze": glmTiers.bronze,
+    "glm-silver": glmTiers.silver,
+    "glm-gold": glmTiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    codex: "gpt-gold",
+    explorer: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    planner: "gold",
+  }
+}
+
+function buildGPTThreeTierModels(tiers) {
+  return {
+    gpt: "gold",
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    codex: "gold",
+    explorer: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    planner: "gold",
+  }
+}
+
+function buildGLMThreeTierModels(tiers) {
   return {
-    gpt: model,
-    fast: "gpt",
-    strong: "gpt",
-    mini: "gpt",
-    codex: "gpt",
-    coder: "gpt",
-    resolver: "gpt",
-    explorer: "gpt",
-    reviewer: "gpt",
-    "deep-reviewer": "gpt",
+    glm: "gold",
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    explorer: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    planner: "gold",
+  }
+}
+
+function collectModelChoices(allModels, predicate, hints, includeFallbackHints = true) {
+  const detected = allModels.filter(predicate)
+  const providerIds = new Set(detected.map((model) => model.split("/")[0]).filter(Boolean))
+  const matchingHints = includeFallbackHints
+    ? hints.filter((model) => providerIds.size === 0 || providerIds.has(model.split("/")[0]) || detected.length < 3)
+    : []
+  return unique([...detected, ...matchingHints])
+}
+
+function chooseThreeTier(models, family, includeFallbackHints = true) {
+  const fallback = family === "glm" ? GLM_MODEL_HINTS : OPENAI_MODEL_HINTS
+  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]),
+    gold: preferModel(choices, family === "glm" ? ["5.1", "5", "4.5"] : ["5.5", "5.4", "gpt-5.3-codex"], choices[2] ?? choices[1] ?? choices[0]),
+  }
+}
+
+function preferModel(models, needles, fallback) {
+  return models.find((model) => {
+    const lower = model.toLowerCase()
+    return needles.some((needle) => lower.includes(needle))
+  }) ?? fallback
+}
+
+function unique(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))]
+}
+
+async function readAllStdin() {
+  let raw = ""
+  for await (const chunk of process.stdin) {
+    raw += chunk
+  }
+  return raw
+}
+
+async function readScriptedAnswersIfNeeded() {
+  if (process.env.OPENCODE_RESOLVE_FORCE_PROMPT === "1" && !process.stdin.isTTY) {
+    return (await readAllStdin()).split(/\r?\n/)
   }
+  return undefined
 }
 
 function getPresetLabel(currentModel) {