opencode-resolve 0.1.4 → 0.1.5

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 등 지원. opencode-resolve가 실제로 얼마나 토큰 절약하는지 눈으로 확인하는 데 유용. 설치할까요? (권장)_
+
+사용자가 **예** (각 질문마다):
+
+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단계?
+
+기본 권장은 **C (3단계, 브론즈/실버/골드)**. opencode-resolve는 질적으로 다른 세 가지 작업(read-only 스카웃 → write/patch → reason/judge)을 가지며, 이를 3단계로 매핑하는 게 2단계보다 역할별 비용을 더 정확히 반영합니다. 사용자가 모델 두 개만 있으면 B로 fallback, 하나뿐이면 A.
 
-> _모든 역할에 단일 모델을 쓸까요, 아니면 분할 — `coder`/`explorer`에는 빠른 모델, `resolver`/`reviewer`/`deep-reviewer`에는 더 강력한 모델을 쓸까요?_
+> _권장: **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,39 @@ provider가 **하나도 설정되지 않은 경우** 진행을 멈추고, `openc
 
 > _`coder`와 `explorer`를 `zai-coding-plan/glm-5.1`로, `resolver`/`reviewer`/`deep-reviewer`를 `openai/gpt-5.5`로 핀닝합니다. 진행할까요?_
 
+#### 3d-bis. `coder` 모델 기준 `maxParallelSubagents` 결정
+
+opencode-resolve의 정체성은 **토큰 절약** — resolver는 빠르게 계획하고 유형별로 subagent를 디스패치하며, 병렬 캡은 역할당입니다. 캡은 **coder 모델 하나만 보고** 정합니다 (coder가 fan-out 주체이므로 rate budget이 거기서 결정):
+
+| `coder` 모델 ID에 포함된 | `maxParallelSubagents` |
+|---|---|
+| `glm` (어떤 GLM이든 — 보통 GLM coding-plan) | **2** |
+| 그 외 (GPT, Claude, Gemini, local, …) | **4** |
+
+GLM의 제약은 GLM coding-plan의 계정당 rate limit 때문 — 강력한 GLM이라도 burst 디스패치 시 throttle 걸림. 그 외 family는 4를 잘 받아냄. strong/reasoner 모델은 보지 마세요 — 캡은 doer를 따름.
+
+단일(A) / 2단계(B) 케이스도 결국 coder가 쓰는 모델 하나만 보고 적용.
+
 #### 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 +341,49 @@ 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,
+  "autoUpdate": true,
   "maxParallelSubagents": 2
 }
 ```
 
-사용자가 **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`는 **coder 모델 ID에 `glm` 포함되면 2, 그 외 4**.
+
 `<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 actually seeing the token savings opencode-resolve gives you. 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?
+
+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.
 
-> _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`?_
+> _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,39 @@ 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. Pick `maxParallelSubagents` from the `coder` model
+
+opencode-resolve's identity is **token efficiency** — the resolver plans fast and dispatches subagents by type, and the parallel cap is per-role. The cap is determined by the `coder` model only — coder is the fan-out subject, so its rate budget is what matters:
+
+| `coder` model ID contains | `maxParallelSubagents` |
+|---|---|
+| `glm` (any GLM model — most often the GLM coding-plan) | **2** |
+| anything else (GPT, Claude, Gemini, local, …) | **4** |
+
+The GLM constraint comes from the GLM coding-plan's per-account rate limits — even a powerful GLM gets throttled under burst dispatch. Every other family tested tolerates 4 well and the resolver gets meaningful speedup. Don't look at the strong/reasoner model — the cap follows the doer, not the judge.
+
+For single-tier (A) and two-tier (B), apply the same rule to whichever model the `coder` agent ends up using.
+
 #### 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 +341,49 @@ 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,
+  "autoUpdate": true,
   "maxParallelSubagents": 2
 }
 ```
 
-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. Set `maxParallelSubagents` to **2** if the `coder` model ID contains `glm`, otherwise **4**.
+
 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;
@@ -56,7 +85,7 @@ function buildResolverPrompt(maxParallelSubagents) {
         "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 +104,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 +125,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",
@@ -236,15 +268,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");
@@ -328,6 +452,7 @@ function defaultResolveConfig() {
         commands: false,
         autoApprove: true,
         maxParallelSubagents: DEFAULT_MAX_PARALLEL_SUBAGENTS,
+        autoUpdate: true,
     };
 }
 function mergeResolveConfig(...configs) {
@@ -341,6 +466,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 +577,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,9 +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,
+  "autoUpdate": true,
   "maxParallelSubagents": 2,
   "models": {},
   "agents": {
@@ -26,6 +27,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.5",
   "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",