opencode-resolve 0.1.4 → 0.1.6

package/README.ko.md

@@ -222,6 +222,29 @@ opencode plugin opencode-resolve --global --force
 
 > 이미 다른 플러그인이 있다면, 기존 배열에 `"opencode-resolve"`를 **추가**하세요. 기존 설정을 **덮어쓰지 마세요**.
 
+#### 2b. 권장 companion 플러그인 제안 (2개)
+
+모델 선택으로 넘어가기 전에, **독립적인** 두 companion 플러그인을 각각 한 번씩 물어봅니다 — 둘 다 권장 기본값. 별개의 OpenCode 플러그인이라 필수는 아니지만 opencode-resolve와 궁합이 좋습니다.
+
+**Companion 1 — `@tarquinen/opencode-dcp` (Dynamic Context Pruning)**
+
+> _opencode-resolve는 **`@tarquinen/opencode-dcp`** 와 궁합이 좋아요 — obsolete tool output을 가지치기해서 긴 resolver 루프의 토큰 비용을 줄입니다. 설치할까요? (권장)_
+
+**Companion 2 — `@slkiser/opencode-quota` (사용량/quota 추적)**
+
+> _그리고 **`@slkiser/opencode-quota`** — 컨텍스트 윈도우를 오염시키지 않고 실시간 토큰/quota 사용량을 보여줍니다. GLM coding-plan, OpenAI Plus/Pro, Qwen 등 지원. 내 사용량/잔여 quota 확인용으로 유용. 설치할까요? (권장)_
+
+사용자가 **예** (각 질문마다):
+
+1. `opencode plugin <package>@latest --global --force` 실행 (캐시 priming).
+2. `~/.config/opencode/opencode.json`의 `plugin` 배열에 `"<package>@latest"` 추가 — 이미 있으면 스킵.
+
+`<package>`는 `@tarquinen/opencode-dcp` 또는 `@slkiser/opencode-quota`.
+
+각 **아니오**: 그 항목 스킵 — `opencode.json`을 그것 때문에 수정하지 마세요. 어느 쪽이든 3단계로 진행.
+
+> `context7` MCP는 `resolve.json`에서 `context7: true`(기본값)이면 opencode-resolve가 런타임에 자동 등록합니다. 별도 질문 불필요.
+
 ### 3단계 — 모델을 인터랙티브하게 고른 뒤 `~/.config/opencode/resolve.json` 작성
 
 여기서 LLM이 **짧은 Q&A를 주도**합니다. 목표: 사용자가 자신의 설정에서 직접 고른 모델 ID로 `resolve.json`을 마무리하는 것.
@@ -251,12 +274,17 @@ provider가 **하나도 설정되지 않은 경우** 진행을 멈추고, `openc
 
 후보 provider가 정확히 하나면 질문을 건너뛰고 사용합니다.
 
-#### 3c. 사용자에게 질문: 단일 / 분할?
+#### 3c. 사용자에게 질문: 단일 / 2단계 / 3단계?
 
-> _모든 역할에 단일 모델을 쓸까요, 아니면 분할 — `coder`/`explorer`에는 빠른 모델, `resolver`/`reviewer`/`deep-reviewer`에는 더 강력한 모델을 쓸까요?_
+기본 권장은 **C (3단계, 브론즈/실버/골드)**. opencode-resolve는 질적으로 다른 세 가지 작업(read-only 스카웃 → write/patch → reason/judge)을 가지며, 이를 3단계로 매핑하는 게 2단계보다 역할별 비용을 더 정확히 반영합니다. 사용자가 모델 두 개만 있으면 B로 fallback, 하나뿐이면 A.
+
+> _권장: **3단계** — `explorer`에 가벼운 스카웃, `coder`에 중간 구현 모델, `resolver`/`reviewer`/`deep-reviewer`/`planner`에 강한 reasoner. 선택:_
 >
-> A. 모든 역할에 단일 모델 (가장 단순, 단일 provider에 권장)
-> B. 분할 — fast + strong (저렴한 모델 + 강력한 모델 둘 다 가진 경우 권장)
+> **C. 3단계 — 브론즈(스카웃) + 실버(코더) + 골드(추론) — 권장**
+> B. 2단계 — fast + strong (모델 두 개만 있을 때)
+> A. 모든 역할에 단일 모델 (모델 하나뿐이거나 최대한 단순한 게 필요한 경우만)
+
+사용자가 그냥 엔터를 누르거나 "권장"이라고 답하면 C로. 모델 부족 시에만 fallback. **same-provider 분할도 완전 유효** — 예: `openai/gpt-4o-mini` / `openai/gpt-5.3-codex` / `openai/o4-mini`, 또는 `zai/glm-4.7-flash` / `zai-coding-plan/glm-5.1` / `zai/glm-5`.
 
 #### 3d. 사용자에게 질문: 어떤 모델?
 
@@ -273,23 +301,36 @@ provider가 **하나도 설정되지 않은 경우** 진행을 멈추고, `openc
 
 > _`coder`와 `explorer`를 `zai-coding-plan/glm-5.1`로, `resolver`/`reviewer`/`deep-reviewer`를 `openai/gpt-5.5`로 핀닝합니다. 진행할까요?_
 
+#### 3d-bis. 사용자가 명시적으로 hard cap 원할 때만 `maxParallelSubagents` 설정
+
+기본 흐름은 `maxParallelSubagents`를 `resolve.json`에 **쓰지 않습니다**. resolver prompt에 soft 가이드라인이 들어있어요 — 진짜 독립적인 작업이면 coder fan out, rate-limit 에러 보이면 backoff, explorer 무제한, reviewer/deep-reviewer/planner는 본질적으로 singleton. oh-my-openagent (per-model semaphore, 사실상 default 무제한) 와 OpenCode core (built-in concurrency 룰 없음) 의 처리와 동일한 결, rate limit을 이미 인지한 모델을 과제약하지 않음.
+
+`maxParallelSubagents`는 사용자가 hard cap을 명시적으로 원할 때만 물어보세요. 흔한 케이스: GLM coding-plan 사용자가 "burst 절대 안 됨" 보장 원할 때. 권장 멘트:
+
+> _(optional, 관련된 경우만)_ _`coder` 모델이 GLM이네요 — coding-plan은 burst 시 throttle 걸립니다. 안전하게 `maxParallelSubagents: 2`로 핀닝할까요?_
+
+그 외엔 필드 자체를 생략.
+
 #### 3e. `~/.config/opencode/resolve.json` 작성
 
-사용자가 **A (단일)** 를 골랐다면:
+**3단계 (C, 권장)** — `bronze`/`silver`/`gold` alias 사용:
 
 ```json
 {
-  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
+  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner"],
   "preserveNative": true,
   "context7": true,
   "commands": false,
   "models": {
-    "primary":       "<선택한-provider>/<선택한-모델>",
-    "coder":         "primary",
-    "explorer":      "primary",
-    "resolver":      "primary",
-    "reviewer":      "primary",
-    "deep-reviewer": "primary"
+    "bronze":        "<provider>/<스카웃-모델>",
+    "silver":        "<provider>/<코더-모델>",
+    "gold":          "<provider>/<추론-모델>",
+    "explorer":      "bronze",
+    "coder":         "silver",
+    "resolver":      "gold",
+    "reviewer":      "gold",
+    "deep-reviewer": "gold",
+    "planner":       "gold"
   },
   "agents": {
     "coder":         { "enabled": true,  "mode": "all" },
@@ -297,49 +338,48 @@ provider가 **하나도 설정되지 않은 경우** 진행을 멈추고, `openc
     "explorer":      { "enabled": true,  "mode": "subagent" },
     "reviewer":      { "enabled": true,  "mode": "subagent" },
     "deep-reviewer": { "enabled": true,  "mode": "subagent" },
+    "planner":       { "enabled": true,  "mode": "subagent" },
     "architect":     { "enabled": false },
     "gpt-coder":     { "enabled": false },
     "debugger":      { "enabled": false },
     "researcher":    { "enabled": false }
   },
   "autoApprove": true,
-  "maxParallelSubagents": 2
+  "autoUpdate": true
 }
 ```
 
-사용자가 **B (분할)** 를 골랐다면:
+**2단계 (B)** — 모델이 두 개뿐이면 bronze와 silver 통합:
 
 ```json
-{
-  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
-  "preserveNative": true,
-  "context7": true,
-  "commands": false,
-  "models": {
-    "fast":          "<provider>/<fast-모델>",
-    "strong":        "<provider>/<strong-모델>",
-    "coder":         "fast",
-    "explorer":      "fast",
-    "resolver":      "strong",
-    "reviewer":      "strong",
-    "deep-reviewer": "strong"
-  },
-  "agents": {
-    "coder":         { "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 },
-    "gpt-coder":     { "enabled": false },
-    "debugger":      { "enabled": false },
-    "researcher":    { "enabled": false }
-  },
-  "autoApprove": true,
-  "maxParallelSubagents": 2
+"models": {
+  "silver":        "<provider>/<코더-모델>",
+  "gold":          "<provider>/<추론-모델>",
+  "explorer":      "silver",
+  "coder":         "silver",
+  "resolver":      "gold",
+  "reviewer":      "gold",
+  "deep-reviewer": "gold",
+  "planner":       "gold"
 }
 ```
 
+**단일 (A)** — 모든 역할이 단일 모델:
+
+```json
+"models": {
+  "gold":          "<provider>/<단일-모델>",
+  "explorer":      "gold",
+  "coder":         "gold",
+  "resolver":      "gold",
+  "reviewer":      "gold",
+  "deep-reviewer": "gold",
+  "planner":       "gold"
+}
+```
+
+`<provider>/<모델>` 플레이스홀더는 모두 사용자가 고른 **정확한** ID로 교체. **`maxParallelSubagents`는 사용자가 명시적으로 hard cap 요청한 경우에만 추가** (3d-bis 참고).
+
 `<provider>/<모델>` 플레이스홀더는 모두 사용자가 3b/3d에서 고른 **정확한** ID 문자열로 교체 — 임의 생성 금지, 자동완성 금지, 버전 드리프트 금지. 고른 모델을 `provider/model` 문자열로 매핑할 수 없으면 추측하지 말고 사용자에게 다시 물어보세요.
 
 > 활성 에이전트마다 명시적인 `enabled: true`를 두어 파일이 자체 문서화됩니다. `enabled` 배열이 여전히 권위 있으며, 에이전트별 플래그는 사람이 파일을 읽을 때의 모호함만 제거합니다.

package/README.md

@@ -222,6 +222,29 @@ Add the string `"opencode-resolve"` to the `plugin` array. **Do not use the inli
 
 > If the user already has other plugins, append `"opencode-resolve"` to the existing array. **Never overwrite** their existing config.
 
+#### 2b. Offer the recommended companion plugins
+
+Before moving to model selection, ask the user about two **independent** companion plugins — one question each, recommended-by-default. Both are separate OpenCode plugins; opencode-resolve does not require them but pairs well with both.
+
+**Companion 1 — `@tarquinen/opencode-dcp` (Dynamic Context Pruning)**
+
+> _opencode-resolve pairs well with **`@tarquinen/opencode-dcp`** — it prunes obsolete tool outputs so long resolver loops cost fewer tokens. Want to install it? (recommended)_
+
+**Companion 2 — `@slkiser/opencode-quota` (quota & usage tracking)**
+
+> _And **`@slkiser/opencode-quota`** — shows your live token/quota usage without polluting the context window. Supports GLM coding-plan, OpenAI Plus/Pro, Qwen, and more. Useful for keeping an eye on your own usage / remaining quota. Install it? (recommended)_
+
+For each **yes** answer:
+
+1. Run `opencode plugin <package>@latest --global --force` (primes the cache).
+2. Append `"<package>@latest"` to the `plugin` array in `~/.config/opencode/opencode.json`, only if it is not already present.
+
+Where `<package>` is `@tarquinen/opencode-dcp` or `@slkiser/opencode-quota`.
+
+For each **no**, skip — do not modify `opencode.json` for that entry. Proceed to Step 3 either way.
+
+> `context7` MCP is registered automatically by opencode-resolve at runtime when `context7: true` (the default in `resolve.json`). No separate question is needed for that.
+
 ### Step 3 — Pick models interactively, then write `~/.config/opencode/resolve.json`
 
 The LLM **drives a short Q&A** here. Goal: end with `resolve.json` containing model IDs the user explicitly chose from their own configuration.
@@ -251,12 +274,17 @@ Print the candidate list and ask. Example wording the LLM should use:
 
 If exactly one provider candidate exists, skip the question and use it.
 
-#### 3c. Ask the user: single-tier or split?
+#### 3c. Ask the user: single, two-tier, or three-tier split?
 
-> _Do you want a single model for every role, or split — a fast model for `coder`/`explorer` and a stronger model for `resolver`/`reviewer`/`deep-reviewer`?_
+The default recommendation is **C (three-tier bronze/silver/gold)** — opencode-resolve has three qualitatively distinct workloads (read-only scout → write/patch → reason/judge) and three matching tiers cost about the same as two-tier but read role costs more accurately. Fall back to B if the user only has two models, A only when they have one.
+
+> _Recommended: **three-tier** — a cheap scout model for `explorer`, a mid coder for `coder`, and a strong reasoner for `resolver`/`reviewer`/`deep-reviewer`/`planner`. Choose:_
 >
-> A. Single model for all roles (simplest, recommended for one-provider setups)
-> B. Split — fast + strong (recommended when you have both a cheap and a strong model)
+> **C. Three-tier — bronze (scout) + silver (coder) + gold (reasoner) — recommended**
+> B. Two-tier — fast + strong (when you only have two models)
+> A. Single model for all roles (only if you have one model or want maximum simplicity)
+
+Default to C if the user just hits enter or says "recommended". Only fall back if they don't have enough distinct models. Same-provider split is fully valid (e.g. `openai/gpt-4o-mini` / `openai/gpt-5.3-codex` / `openai/o4-mini`, or `zai/glm-4.7-flash` / `zai-coding-plan/glm-5.1` / `zai/glm-5`).
 
 #### 3d. Ask the user: which model(s)?
 
@@ -273,23 +301,36 @@ Confirm each pick back to the user before writing the file. Example:
 
 > _I'll pin `coder` and `explorer` to `zai-coding-plan/glm-5.1`, and `resolver`/`reviewer`/`deep-reviewer` to `openai/gpt-5.5`. Proceed?_
 
+#### 3d-bis. Skip `maxParallelSubagents` unless the user explicitly wants a hard cap
+
+The default flow does **not** write `maxParallelSubagents` to `resolve.json`. The resolver prompt ships with soft fan-out guidance — fan out coders when work is genuinely independent, back off on rate-limit errors, explorer is unrestricted, reviewer/deep-reviewer/planner are singletons by nature. This matches how oh-my-openagent (per-model semaphore, default no real cap) and OpenCode core (no built-in concurrency rule) handle the same concern, and avoids overconstraining a model that's already aware of rate limits.
+
+Only ask about `maxParallelSubagents` if the user explicitly mentions wanting to cap fan-out. Common case: GLM coding-plan users who want to **guarantee** they never burst beyond 1 or 2 coder calls. Suggested wording:
+
+> _(optional, ask only if relevant)_ _Your `coder` model is GLM — the coding-plan throttles under bursts. Pin `maxParallelSubagents: 2` to be safe?_
+
+Otherwise, omit the field entirely.
+
 #### 3e. Write `~/.config/opencode/resolve.json`
 
-If the user picked **A (single-tier)**, write:
+**Three-tier (C, recommended)** — use the `bronze`/`silver`/`gold` aliases:
 
 ```json
 {
-  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
+  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner"],
   "preserveNative": true,
   "context7": true,
   "commands": false,
   "models": {
-    "primary":       "<chosen-provider>/<chosen-model>",
-    "coder":         "primary",
-    "explorer":      "primary",
-    "resolver":      "primary",
-    "reviewer":      "primary",
-    "deep-reviewer": "primary"
+    "bronze":        "<provider>/<scout-model>",
+    "silver":        "<provider>/<coder-model>",
+    "gold":          "<provider>/<reasoner-model>",
+    "explorer":      "bronze",
+    "coder":         "silver",
+    "resolver":      "gold",
+    "reviewer":      "gold",
+    "deep-reviewer": "gold",
+    "planner":       "gold"
   },
   "agents": {
     "coder":         { "enabled": true,  "mode": "all" },
@@ -297,49 +338,48 @@ If the user picked **A (single-tier)**, write:
     "explorer":      { "enabled": true,  "mode": "subagent" },
     "reviewer":      { "enabled": true,  "mode": "subagent" },
     "deep-reviewer": { "enabled": true,  "mode": "subagent" },
+    "planner":       { "enabled": true,  "mode": "subagent" },
     "architect":     { "enabled": false },
     "gpt-coder":     { "enabled": false },
     "debugger":      { "enabled": false },
     "researcher":    { "enabled": false }
   },
   "autoApprove": true,
-  "maxParallelSubagents": 2
+  "autoUpdate": true
 }
 ```
 
-If the user picked **B (split)**, write:
+**Two-tier (B)** — collapse bronze and silver if the user has only two models:
 
 ```json
-{
-  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
-  "preserveNative": true,
-  "context7": true,
-  "commands": false,
-  "models": {
-    "fast":          "<provider>/<fast-model>",
-    "strong":        "<provider>/<strong-model>",
-    "coder":         "fast",
-    "explorer":      "fast",
-    "resolver":      "strong",
-    "reviewer":      "strong",
-    "deep-reviewer": "strong"
-  },
-  "agents": {
-    "coder":         { "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 },
-    "gpt-coder":     { "enabled": false },
-    "debugger":      { "enabled": false },
-    "researcher":    { "enabled": false }
-  },
-  "autoApprove": true,
-  "maxParallelSubagents": 2
+"models": {
+  "silver":        "<provider>/<coder-model>",
+  "gold":          "<provider>/<reasoner-model>",
+  "explorer":      "silver",
+  "coder":         "silver",
+  "resolver":      "gold",
+  "reviewer":      "gold",
+  "deep-reviewer": "gold",
+  "planner":       "gold"
 }
 ```
 
+**Single-tier (A)** — every role on one model:
+
+```json
+"models": {
+  "gold":          "<provider>/<single-model>",
+  "explorer":      "gold",
+  "coder":         "gold",
+  "resolver":      "gold",
+  "reviewer":      "gold",
+  "deep-reviewer": "gold",
+  "planner":       "gold"
+}
+```
+
+Replace every `<provider>/<model>` placeholder with the **exact** ID strings the user picked. **Do not** add `maxParallelSubagents` unless the user explicitly asked for a hard cap (see 3d-bis).
+
 Replace every `<provider>/<model>` placeholder with the **exact** ID strings the user picked in 3b/3d — no inventing, no autocompletion, no version drift. If you cannot map the picked model to a `provider/model` string, ask the user to clarify rather than guessing.
 
 > Each enabled agent carries an explicit `enabled: true` so the file is self-documenting. The `enabled` array remains authoritative; the per-agent flag just removes ambiguity for humans reading the file.

package/dist/index.js

@@ -1,9 +1,13 @@
-import { readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 const PLUGIN_VERSION = readPluginVersion();
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_FILE = join(homedir(), ".cache", "opencode-resolve", "update-check.json");
+const PLUGIN_CACHE_DIR = join(homedir(), ".cache", "opencode", "packages", "opencode-resolve@latest");
 function readPluginVersion() {
     try {
         const pkgRoot = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -16,10 +20,34 @@ function readPluginVersion() {
 }
 console.log(`[opencode-resolve] v${PLUGIN_VERSION} loaded`);
 const DEFAULT_MODELS = {};
-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 DEFAULT_ENABLED = ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner"];
+const VALID_AGENT_NAMES = [
+    "coder",
+    "reviewer",
+    "resolver",
+    "architect",
+    "gpt-coder",
+    "debugger",
+    "researcher",
+    "explorer",
+    "deep-reviewer",
+    "planner",
+];
 const VALID_AGENT_NAME_SET = new Set(VALID_AGENT_NAMES);
-const VALID_MODEL_ALIASES = [...VALID_AGENT_NAMES, "glm", "gpt", "quick", "deep", "fast", "strong", "mini", "codex"];
+const VALID_MODEL_ALIASES = [
+    ...VALID_AGENT_NAMES,
+    "glm",
+    "gpt",
+    "quick",
+    "deep",
+    "fast",
+    "strong",
+    "mini",
+    "codex",
+    "bronze",
+    "silver",
+    "gold",
+];
 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"]);
@@ -32,6 +60,7 @@ const VALID_TOP_LEVEL_KEYS = new Set([
     "commands",
     "autoApprove",
     "maxParallelSubagents",
+    "autoUpdate",
     "config",
 ]);
 const DEFAULT_MAX_PARALLEL_SUBAGENTS = 2;
@@ -47,16 +76,20 @@ const VALID_AGENT_KEYS = new Set([
     "permission",
 ]);
 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. 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.`;
+    const explicitLimit = typeof maxParallelSubagents === "number" && Number.isFinite(maxParallelSubagents)
+        ? Math.max(1, Math.trunc(maxParallelSubagents))
+        : undefined;
+    const parallelRule = explicitLimit === undefined
+        ? "Parallel dispatch policy: fan out coder dispatches when the work is genuinely independent (different files, no shared state). Rate limits are per-model — coder/silver-tier models (e.g. GLM coding-plan) can throttle under heavy burst, so back off if you see rate-limit errors. Explorer runs on a lighter model and fans out freely when scope discovery genuinely needs it. Reviewer, deep-reviewer, and planner are dispatched as singletons by their nature."
+        : explicitLimit === 1
+            ? "CRITICAL: User has pinned the coder concurrency cap to 1. Dispatch at most ONE coder concurrently. Wait for an in-flight coder to finish before dispatching another. Explorer is unrestricted (read-only, light model). Reviewer, deep-reviewer, and planner are singletons by nature."
+            : `CRITICAL: User has pinned the coder concurrency cap to ${explicitLimit}. Dispatch at most ${explicitLimit} coders concurrently. Wait for in-flight coders to finish before dispatching more. Explorer is unrestricted (read-only, light model). Reviewer, deep-reviewer, and planner are singletons by nature.`;
     return [
         "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.",
+        "Internal specialist subagents (explorer, reviewer, deep-reviewer, planner) 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.",
@@ -75,6 +108,7 @@ function buildResolverPrompt(maxParallelSubagents) {
         "- 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.",
+        "- planner: advanced read-only planner. Dispatch ONLY when the user explicitly asks for a plan, decomposition, or implementation strategy. Do NOT call planner for routine sub-task planning you can absorb inline.",
         "",
         "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");
@@ -95,6 +129,8 @@ const DEFAULT_AGENT_CONFIG = {
             "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.",
+            "",
+            "Scope-discovery gate: dispatch the `explorer` subagent ONLY when the scope is genuinely unclear — i.e. you need to locate 3+ unknown files, OR a named pattern's location is genuinely unknown. For known files, single-file uncertainty, or routine doubt, read directly with the local read/grep/glob tools. Never dispatch explorer for casual exploration — token efficiency is the discipline.",
         ].join("\n"),
         permission: {
             edit: "ask",
@@ -127,7 +163,7 @@ const DEFAULT_AGENT_CONFIG = {
         color: "#FF7AC6",
         maxSteps: 30,
         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),
+        prompt: buildResolverPrompt(undefined),
         permission: {
             edit: "ask",
             bash: "ask",
@@ -236,15 +272,107 @@ const DEFAULT_AGENT_CONFIG = {
             webfetch: "ask",
         },
     },
+    planner: {
+        mode: "subagent",
+        color: "#F4A300",
+        maxSteps: 10,
+        description: "Internal advanced planner dispatched by the resolver when the user explicitly asks for a plan, decomposition, or implementation strategy. Read-only. Returns a concrete plan; never edits code.",
+        prompt: [
+            "You are Planner, the advanced planning subagent for OpenCode Resolve.",
+            "You are dispatched by the resolver only when the user explicitly asks for a plan, decomposition, or implementation strategy — not for routine sub-task planning the resolver handles inline.",
+            "You MUST NOT modify the project: no file edits, no writes, no shell commands that change state.",
+            "Inspect the relevant code with read-only tools (read, grep, glob, list) before proposing.",
+            "Return: clear phasing, file-level boundaries per phase, verification checkpoints, risks, and explicit trade-offs. Be concrete — name files, name decisions, name the cost of each option.",
+            "Be token-efficient: produce the smallest plan that fully covers the user's intent. No filler, no boilerplate, no restating the request.",
+        ].join("\n"),
+        permission: {
+            edit: "deny",
+            bash: "deny",
+            webfetch: "ask",
+        },
+    },
 };
 export const OpencodeResolve = async ({ directory }, options) => {
     return {
         config: async (config) => {
             const resolveConfig = await loadResolveConfig(directory, config, options);
             applyResolveConfig(config, resolveConfig);
+            if (resolveConfig.autoUpdate !== false && process.env.OPENCODE_RESOLVE_NO_AUTO_UPDATE !== "1") {
+                maybeAutoUpdate().catch(() => { });
+            }
         },
     };
 };
+async function maybeAutoUpdate() {
+    try {
+        const previous = readUpdateCheckCache();
+        if (previous && Date.now() - previous.checkedAt < UPDATE_CHECK_INTERVAL_MS) {
+            return;
+        }
+    }
+    catch {
+        // ignore corrupt cache and re-check
+    }
+    let latest;
+    try {
+        const response = await fetch("https://registry.npmjs.org/opencode-resolve/latest", {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok)
+            return;
+        const data = (await response.json());
+        if (typeof data?.version !== "string")
+            return;
+        latest = data.version;
+    }
+    catch {
+        return;
+    }
+    try {
+        mkdirSync(dirname(UPDATE_CHECK_FILE), { recursive: true });
+        writeFileSync(UPDATE_CHECK_FILE, JSON.stringify({ checkedAt: Date.now(), latest }));
+    }
+    catch {
+        // best-effort; don't block on cache write failure
+    }
+    if (!isNewerVersion(latest, PLUGIN_VERSION))
+        return;
+    console.log(`[opencode-resolve] new version v${latest} available (current: v${PLUGIN_VERSION}) — refreshing cache in background. Restart OpenCode to activate (current session stays on v${PLUGIN_VERSION}).`);
+    try {
+        spawn("sh", ["-c", `rm -rf "${PLUGIN_CACHE_DIR}" && opencode plugin opencode-resolve --global --force`], { detached: true, stdio: "ignore" }).unref();
+    }
+    catch {
+        // If spawn fails, the user already saw the notice and can run the command manually.
+    }
+}
+function readUpdateCheckCache() {
+    try {
+        const raw = readFileSync(UPDATE_CHECK_FILE, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.checkedAt === "number" &&
+            typeof parsed?.latest === "string") {
+            return { checkedAt: parsed.checkedAt, latest: parsed.latest };
+        }
+    }
+    catch {
+        // file missing or unparseable
+    }
+    return undefined;
+}
+function isNewerVersion(candidate, baseline) {
+    const a = candidate.split(".").map((n) => Number.parseInt(n, 10));
+    const b = baseline.split(".").map((n) => Number.parseInt(n, 10));
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const av = Number.isFinite(a[i]) ? a[i] : 0;
+        const bv = Number.isFinite(b[i]) ? b[i] : 0;
+        if (av > bv)
+            return true;
+        if (av < bv)
+            return false;
+    }
+    return false;
+}
 export default OpencodeResolve;
 async function loadResolveConfig(directory, opencodeConfig, options) {
     const pluginOptions = normalizeResolveConfig(options ?? getPluginOptions(opencodeConfig), "plugin options");
@@ -265,7 +393,7 @@ function applyResolveConfig(config, resolveConfig) {
     const models = { ...DEFAULT_MODELS, ...resolveConfig.models };
     const defaultModel = typeof config.model === "string" ? config.model : undefined;
     const autoApprove = resolveConfig.autoApprove !== false;
-    const maxParallelSubagents = resolveConfig.maxParallelSubagents ?? DEFAULT_MAX_PARALLEL_SUBAGENTS;
+    const maxParallelSubagents = resolveConfig.maxParallelSubagents;
     config.agent ??= {};
     for (const name of Object.keys(DEFAULT_AGENT_CONFIG)) {
         const override = resolveConfig.agents?.[name];
@@ -327,7 +455,7 @@ function defaultResolveConfig() {
         context7: true,
         commands: false,
         autoApprove: true,
-        maxParallelSubagents: DEFAULT_MAX_PARALLEL_SUBAGENTS,
+        autoUpdate: true,
     };
 }
 function mergeResolveConfig(...configs) {
@@ -341,6 +469,7 @@ function mergeResolveConfig(...configs) {
         result.commands = config.commands ?? result.commands;
         result.autoApprove = config.autoApprove ?? result.autoApprove;
         result.maxParallelSubagents = config.maxParallelSubagents ?? result.maxParallelSubagents;
+        result.autoUpdate = config.autoUpdate ?? result.autoUpdate;
         result.models = { ...result.models, ...config.models };
         result.agents = mergeAgents(result.agents, config.agents);
     }
@@ -451,6 +580,8 @@ function normalizeResolveConfig(value, source) {
         result.commands = expectBoolean(config.commands, `${source}.commands`);
     if (config.autoApprove !== undefined)
         result.autoApprove = expectBoolean(config.autoApprove, `${source}.autoApprove`);
+    if (config.autoUpdate !== undefined)
+        result.autoUpdate = expectBoolean(config.autoUpdate, `${source}.autoUpdate`);
     if (config.maxParallelSubagents !== undefined) {
         const limit = expectNumber(config.maxParallelSubagents, `${source}.maxParallelSubagents`);
         if (!Number.isInteger(limit) || limit < 1) {

package/opencode-resolve.example.json

@@ -1,10 +1,10 @@
 {
-  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer"],
+  "enabled": ["coder", "resolver", "explorer", "reviewer", "deep-reviewer", "planner"],
   "preserveNative": true,
   "context7": true,
   "commands": false,
   "autoApprove": true,
-  "maxParallelSubagents": 2,
+  "autoUpdate": true,
   "models": {},
   "agents": {
     "coder": {
@@ -26,6 +26,10 @@
       "enabled": true,
       "mode": "subagent"
     },
+    "planner": {
+      "enabled": true,
+      "mode": "subagent"
+    },
     "architect": {
       "enabled": false
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-resolve",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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/postinstall.mjs

@@ -13,7 +13,6 @@ const exampleConfigPath = join(root, "opencode-resolve.example.json")
 
 const ADDITIVE_DEFAULTS = {
   autoApprove: true,
-  maxParallelSubagents: 2,
 }
 
 if (process.env.OPENCODE_RESOLVE_SKIP_POSTINSTALL === "1") {