@jetrabbits/agentic 0.2.0 → 0.3.0

package/docs/agentic-lifecycle.md

@@ -104,11 +104,11 @@ Every copied or generated file carries an internal marker. Markdown uses YAML fr
 
 ## MemPalace install and validation logs
 
-When MemPalace MCP is enabled during interactive install, `agentic` now reports setup progress in explicit steps so users can see what succeeded or failed:
+When MemPalace MCP is enabled during interactive install, TUI install, or through `AGENTIC_ENABLE_MEMPALACE=y`, `agentic` now reports setup progress in explicit steps so users can see what succeeded or failed:
 
 1. Python availability check
 2. pip availability check
 3. `pip install mempalace`
-4. Project initialization (`mempalace init` and `mempalace mine`)
+4. Explicit skip log for automatic project initialization, plus optional manual `mempalace init`/`mempalace mine` instructions
 
-After setup, install checks that `mempalace-mcp` is present and leaves runtime startup/tool validation to the post-install doctor smoke check. Generated MCP configs invoke `mempalace-mcp` without arguments for all supported agent targets.
+If auto-install or runtime checks fail, `agentic` prints manual setup instructions and continues. After setup, install checks that `mempalace-mcp` is present and leaves runtime startup/tool validation to the post-install doctor smoke check. Generated MCP configs invoke `mempalace-mcp` without arguments for all supported agent targets.

package/docs/agentic-stabilization/README.md

@@ -0,0 +1,33 @@
+# Agentic Stabilization v0.3.0
+
+## User-Facing Behavior
+
+- Post-install doctor checks run independently for `codex`, `opencode`, `claude`, and `gemini`.
+- `AGENTIC_DOCTOR_TIMEOUT_SECONDS` defaults to `10`; a timeout is reported as a doctor failure and install continues.
+- Codex doctor runs non-interactively with `--ephemeral` and `--sandbox workspace-write`.
+- OpenCode uses `agent-model-mapper` instead of the removed `model-checker` artifacts.
+- `agent-model-mapper` writes `.opencode/opencode.json` during interactive install only after confirmation.
+- `agent-model-mapper` uses `fzf` for install-time model dropdowns when available and OpenCode startup skips once all roles are mapped.
+- The runtime OpenCode plugin never opens `fzf`, asks questions, or writes project files.
+- Context7 no longer asks for an API key; it uses `CONTEXT7_API_KEY` when set and otherwise prints config-path guidance for adding one later.
+- OpenCode MemPalace setup writes `mempalace-mcp` config without running `mempalace init` automatically.
+- Telegram notification credentials are read only from `OPENCODE_TELEGRAM_BOT_TOKEN` and `OPENCODE_TELEGRAM_CHAT_ID`.
+- MemPalace-enabled installs create a managed `.mempalaceignore` unless the target project already has one.
+- Real Codex, OpenCode, and Telegram blackbox scenarios are part of `make test`.
+- `make test-coverage` traces `agentic` through e2e runs and fails below 90% line coverage.
+
+## Acceptance Criteria
+
+- Hung agent doctor commands time out and do not stop remaining selected agents from running.
+- Doctor output includes timeout duration, exit status, and per-agent elapsed time.
+- `extensions/opencode/plugins/model-checker.ts` and `model-checker.json` are absent.
+- `extensions/opencode/opencode.json` lists `agent-model-mapper`.
+- Runtime model mapper execution does not prompt or modify project files.
+- Telegram plugin tests prove environment-only credentials and no secret output.
+- Real blackbox tests print created files, instruction evidence, MCP usage prompts, and MemPalace fact prompts without printing Telegram secrets.
+
+## Operational Constraints
+
+- `make test` now requires real `codex` and `opencode` binaries, working model auth, network access, Context7/MemPalace access, and Telegram credentials.
+- Telegram credentials must never be committed or written to Agentic config.
+- Coverage is line-based Bash trace coverage for the `agentic` script, not branch coverage.

package/docs/agentic-token-minimization/README.md

@@ -54,7 +54,7 @@ OPENCODE_TELEGRAM_CHAT_ID
 - `.kilocode/mcp.json` for `kilocode`
 - `~/.gemini/antigravity/mcp_config.json` for `antigravity` (global user config)
 
-Interactive installs ask whether to enable Context7. If enabled, the Context7 API key is optional. Empty keys keep the install usable with default Context7 limits or rule-only fallback behavior. Non-interactive installs enable Context7 only when `CONTEXT7_API_KEY` is already set. Generated guidance requires agents to use Context7 for framework, SDK, library, and API documentation before relying on model memory when the project config is present.
+Interactive installs ask whether to enable Context7. If enabled, Context7 is configured without a key unless `CONTEXT7_API_KEY` is already set; the install output prints the config path(s) and an example key placement. Non-interactive installs enable Context7 when either `AGENTIC_ENABLE_CONTEXT7=y` or `CONTEXT7_API_KEY` is set. Generated guidance requires agents to use Context7 for framework, SDK, library, and API documentation before relying on model memory when the project config is present.
 
 Directory copies are processed in batches so large specialization installs avoid spawning a separate marker/manifest process for every copied file. Manifest protection still applies: existing unmanaged files are skipped on rerun, user-modified managed files are skipped, and new generated files can be added by newer `agentic` versions.
 

package/docs/agentic-usage.md

@@ -104,7 +104,7 @@ The final install line prints the exact path:
 Agentic log file: /tmp/agentic-20260512-114203.ABC123
 ```
 
-`agentic` also runs a final doctor smoke check for selected real agent targets (`codex`, `opencode`, `claude`, `gemini`). The doctor runs `/develop-feature напиши hello world python` in a temporary copy of the project and prints one status row per selected agent. Doctor failures are reported but do not roll back or fail the install. Disable doctor for CI or cheap checks with:
+`agentic` also runs a final doctor smoke check for selected real agent targets (`codex`, `opencode`, `claude`, `gemini`). The doctor runs in a temporary copy of the project and prints one status row per selected agent. OpenCode uses a lightweight pure smoke prompt instead of the full `develop-feature` command, so install-time doctor checks do not start a long SDLC workflow. Each agent has an independent timeout controlled by `AGENTIC_DOCTOR_TIMEOUT_SECONDS` and defaults to `10` seconds. Doctor failures and timeouts are reported but do not roll back or fail the install. Disable doctor for cheap checks with:
 
 ```bash
 AGENTIC_DOCTOR=0 agentic install ...
@@ -163,38 +163,34 @@ scoop install fzf
 
 ## OpenCode optional plugins
 
-When `opencode` is selected, interactive installs ask whether to enable Telegram notifications and the model checker. The answer is stored globally in:
+When `opencode` is selected, interactive installs ask whether to enable Telegram notifications and `agent-model-mapper`. The answer is stored globally in:
 
 ```text
 ~/.config/agentic/opencode-plugins.json
 ```
 
-Non-interactive installs create a disabled config when no config exists. Telegram can also read `OPENCODE_TELEGRAM_BOT_TOKEN` and `OPENCODE_TELEGRAM_CHAT_ID`.
+Non-interactive installs create a disabled config when no config exists. Telegram reads `OPENCODE_TELEGRAM_BOT_TOKEN` and `OPENCODE_TELEGRAM_CHAT_ID` from the environment only; tokens are not written to `~/.config/agentic/opencode-plugins.json`. When enabled, `agent-model-mapper` runs during interactive `agentic install`/`agentic tui`, uses `fzf` as a dropdown picker when available, and writes `.opencode/opencode.json` only after confirmation. OpenCode startup never prompts for model mapping; the runtime plugin only reports whether install-time mapping is already complete.
 
 ## Context7
 
-For `opencode`, `codex`, `claude`, `cursor`, `gemini`, `kilocode`, and `antigravity`, interactive installs ask whether to add Context7 MCP configuration. If enabled, the Context7 API key prompt is optional; leave it empty to configure Context7 without a key. Most targets use project-level files, while `antigravity` is written to the global user path `~/.gemini/antigravity/mcp_config.json`.
+For `opencode`, `codex`, `claude`, `cursor`, `gemini`, `kilocode`, and `antigravity`, interactive installs ask whether to add Context7 MCP configuration. If enabled, Context7 is configured without a key unless `CONTEXT7_API_KEY` is already set in the environment. The install output prints the generated config path(s) and an example showing where to add the key later. Most targets use project-level files, while `antigravity` is written to the global user path `~/.gemini/antigravity/mcp_config.json`.
 
-Non-interactive installs skip Context7 unless `CONTEXT7_API_KEY` is set in the environment. Agents are instructed to use Context7 for framework, library, SDK, API, and setup documentation when the project config is present.
+Non-interactive installs enable Context7 when either `AGENTIC_ENABLE_CONTEXT7=y` or `CONTEXT7_API_KEY` is set. Agents are instructed to use Context7 for framework, library, SDK, API, and setup documentation when the project config is present.
 
 ## MemPalace
 
-For `opencode`, `codex`, `claude`, `cursor`, `gemini`, and `antigravity`, MemPalace MCP is configured as a local Python module instead of a hosted MCP URL. Install it first:
-
-```bash
-pip install mempalace
-```
+For `opencode`, `codex`, `claude`, `cursor`, `gemini`, `kilocode`, and `antigravity`, MemPalace MCP is configured as a local Python module instead of a hosted MCP URL. When MemPalace is enabled, `agentic` attempts to install it automatically with `pip install mempalace`.
 
 Generated configs run `mempalace-mcp` without arguments for all supported agent targets. Runtime startup and MCP tool errors are checked by the post-install doctor stage.
 
-During install, if MemPalace is enabled, `agentic` checks whether `mempalace-mcp` is available. For OpenCode installs, `agentic` creates `<project>` and runs `mempalace init "<project>" --yes --auto-mine`. If checks fail (for example, package not installed yet), install continues and agents fall back to standard context discovery.
+During install, if MemPalace is enabled, `agentic` writes a managed `.mempalaceignore` when the target project does not already have one. OpenCode installs do not run `mempalace init` automatically; project indexing is optional and printed as a manual follow-up. If auto-install or runtime checks fail, install continues, manual setup instructions are printed, and agents fall back to standard context discovery.
 
-## Real agent doctor E2E
+## Real agent blackbox E2E
 
-The deterministic e2e suite uses fake agent binaries and does not call models. Real agent doctor checks are opt-in because they may use network access, credentials, and model credits:
+`make test` includes real Codex, OpenCode, and Telegram blackbox scenarios. The local environment must provide working `codex`, `opencode`, Context7/MemPalace access, network access, valid auth, and Telegram credentials in `OPENCODE_TELEGRAM_BOT_TOKEN` and `OPENCODE_TELEGRAM_CHAT_ID`. Secrets are redacted from test output.
 
 ```bash
-AGENTIC_RUN_REAL_AGENT_E2E=1 make test-real-agent-doctor
+make test-real-blackbox
 ```
 
 ## Deprecated wrapper

package/docs/opencode_setup.md

@@ -33,9 +33,9 @@ When `agentic` installs the OpenCode extension, it configures optional plugins i
 ~/.config/agentic/opencode-plugins.json
 ```
 
-Telegram notifications and model checking are opt-in. If the config is absent or a plugin is disabled, the plugin returns no hooks and OpenCode continues without that behavior.
+Telegram notifications and agent model mapping are opt-in. If the config is absent or a plugin is disabled, the plugin returns no hooks and OpenCode continues without that behavior.
 
-Telegram notifications use either the stored config values or these environment variables:
+Telegram notifications read credentials from environment variables only:
 
 ```text
 OPENCODE_TELEGRAM_BOT_TOKEN
@@ -44,5 +44,7 @@ OPENCODE_TELEGRAM_CHAT_ID
 
 Non-interactive `agentic install` defaults optional plugins to disabled when no config exists.
 
+`agent-model-mapper` reads roles from target `.opencode/agents/*.md` and discovers model names from `~/.config/opencode/opencode.json`, falling back to a built-in list only when that file has no model names. When enabled, interactive `agentic install`/`agentic tui` prompts for a main and fallback model per role, using `fzf` as a dropdown picker when available, and writes `.opencode/opencode.json` only after confirmation. OpenCode startup never opens `fzf` or waits for model input; the runtime plugin only reports whether install-time mapping is complete.
+
 For OpenCode targets, `agentic` writes generated operating guidance to `.opencode/AGENTS.md`. If OpenCode is installed
 alongside another agent target, root `AGENTS.md` is generated as well for the non-OpenCode target.

package/extensions/opencode/opencode.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://opencode.ai/config.json",
   "plugin": [
-    "model-checker",
+    "agent-model-mapper",
     "sound-notification",
     "telegram-notification"
   ],

package/extensions/opencode/plugins/agent-model-mapper.ts

@@ -0,0 +1,106 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { existsSync, readFileSync } from "node:fs"
+import { readdir, readFile } from "node:fs/promises"
+import { basename, join } from "node:path"
+
+type AgenticPluginConfig = {
+  agentModelMapper?: {
+    enabled?: boolean
+  }
+}
+
+type Role = {
+  name: string
+  description: string
+  mode: string
+}
+
+function readAgenticConfig(): AgenticPluginConfig {
+  const configHome = process.env.XDG_CONFIG_HOME || join(process.env.HOME || "", ".config")
+  const configPath = join(configHome, "agentic", "opencode-plugins.json")
+
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8")) as AgenticPluginConfig
+  } catch {
+    return {}
+  }
+}
+
+function parseFrontmatter(text: string): Record<string, string> {
+  if (!text.startsWith("---\n")) return {}
+  const end = text.indexOf("\n---", 4)
+  if (end === -1) return {}
+
+  const result: Record<string, string> = {}
+  for (const line of text.slice(4, end).split("\n")) {
+    const index = line.indexOf(":")
+    if (index === -1) continue
+    result[line.slice(0, index).trim()] = line.slice(index + 1).trim().replace(/^['"]|['"]$/g, "")
+  }
+  return result
+}
+
+async function readRoles(directory: string): Promise<Role[]> {
+  const agentsDir = join(directory, ".opencode", "agents")
+  let entries: string[]
+  try {
+    entries = await readdir(agentsDir)
+  } catch {
+    return []
+  }
+
+  const roles: Role[] = []
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".md")) continue
+    const path = join(agentsDir, entry)
+    const text = await readFile(path, "utf-8")
+    const frontmatter = parseFrontmatter(text)
+    roles.push({
+      name: basename(entry, ".md"),
+      description: frontmatter.description || "OpenCode agent",
+      mode: frontmatter.mode || "subagent",
+    })
+  }
+  return roles
+}
+
+function readJsonIfExists(path: string): unknown {
+  if (!existsSync(path)) return undefined
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"))
+  } catch {
+    return undefined
+  }
+}
+
+function hasCompleteAgentModelMapping(directory: string, roles: Role[]): boolean {
+  const state = readJsonIfExists(join(directory, ".opencode", "agent-model-mapper.state.json")) as Record<string, any> | undefined
+  if (!state?.configured) return false
+
+  const config = readJsonIfExists(join(directory, ".opencode", "opencode.json")) as Record<string, any> | undefined
+  const agents = config?.agent
+  if (!agents || typeof agents !== "object") return false
+  return roles.every((role) => {
+    const agent = agents[role.name]
+    return agent && typeof agent === "object" && typeof agent.model === "string" && agent.model.trim().length > 0
+  })
+}
+
+export const AgentModelMapperPlugin: Plugin = async ({ directory }) => {
+  const config = readAgenticConfig()
+  if (!config.agentModelMapper?.enabled) return {}
+
+  const roles = await readRoles(directory)
+  if (!roles.length) {
+    console.log("agent-model-mapper: skipped because .opencode/agents/*.md was not found")
+    return {}
+  }
+
+  if (hasCompleteAgentModelMapping(directory, roles)) {
+    console.log("agent-model-mapper: skipped because all Agentic roles already have model mappings")
+    return {}
+  }
+
+  console.log("agent-model-mapper: install-time model mapping is required; run agentic install or agentic tui")
+  return {}
+}

package/extensions/opencode/plugins/telegram-notification.ts

@@ -5,11 +5,24 @@ import { join } from "node:path"
 type AgenticPluginConfig = {
   telegram?: {
     enabled?: boolean
-    botToken?: string
-    chatId?: string
   }
 }
 
+function telegramApiBaseUrl(): string {
+  return process.env.OPENCODE_TELEGRAM_API_BASE_URL || "https://api.telegram.org"
+}
+
+function telegramUrl(botToken: string, method: string): string {
+  return `${telegramApiBaseUrl()}/bot${botToken}/${method}`
+}
+
+function redactSecret(value: unknown): string {
+  const text = String(value)
+  const token = process.env.OPENCODE_TELEGRAM_BOT_TOKEN
+  const chatId = process.env.OPENCODE_TELEGRAM_CHAT_ID
+  return [token, chatId].filter(Boolean).reduce((output, secret) => output.split(secret as string).join("[redacted]"), text)
+}
+
 function readAgenticConfig(): AgenticPluginConfig {
   const configHome = process.env.XDG_CONFIG_HOME || join(process.env.HOME || "", ".config")
   const configPath = join(configHome, "agentic", "opencode-plugins.json")
@@ -24,16 +37,13 @@ function readAgenticConfig(): AgenticPluginConfig {
 export const TelegramNotificationPlugin: Plugin = async ({ $, client, directory }) => {
   const config = readAgenticConfig()
   const telegram = config.telegram
-  const botToken = process.env.OPENCODE_TELEGRAM_BOT_TOKEN || telegram?.botToken
-  const chatId = process.env.OPENCODE_TELEGRAM_CHAT_ID || telegram?.chatId
+  const botToken = process.env.OPENCODE_TELEGRAM_BOT_TOKEN
+  const chatId = process.env.OPENCODE_TELEGRAM_CHAT_ID
 
   if (!telegram?.enabled || !botToken || !chatId) {
     return {}
   }
 
-  process.env.OPENCODE_TELEGRAM_BOT_TOKEN = botToken
-  process.env.OPENCODE_TELEGRAM_CHAT_ID = chatId
-
   return {
     event: async ({ event }) => {
       if (event.type === "session.idle") {
@@ -60,7 +70,7 @@ export const TelegramNotificationPlugin: Plugin = async ({ $, client, directory
             }
           }
         } catch (e) {
-          await $`echo "Error: ${e}" >> ${directory}/.opencode/telegram-debug.log`
+          await $`echo "Error: ${redactSecret(e)}" >> ${directory}/.opencode/telegram-debug.log`
         }
 
         try {
@@ -74,13 +84,13 @@ export const TelegramNotificationPlugin: Plugin = async ({ $, client, directory
             )
 
             await fetch(
-              `https://api.telegram.org/bot${botToken}/sendDocument`,
+              telegramUrl(botToken, "sendDocument"),
               { method: "POST", body: formData }
             )
 
             const shortText = fullText.slice(0, 3000)
             await fetch(
-              `https://api.telegram.org/bot${botToken}/sendMessage`,
+              telegramUrl(botToken, "sendMessage"),
               {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -96,7 +106,7 @@ export const TelegramNotificationPlugin: Plugin = async ({ $, client, directory
               : messageText
 
             await fetch(
-              `https://api.telegram.org/bot${botToken}/sendMessage`,
+              telegramUrl(botToken, "sendMessage"),
               {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jetrabbits/agentic",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Agent Intelligence Configuration CLI",
   "bin": {
     "agentic": "bin/agentic.js"
@@ -11,6 +11,7 @@
   },
   "files": [
     "AGENTS.md",
+    "MEMORY.md",
     "CHANGELOG.md",
     "UPGRADE.md",
     "LICENSE",

package/extensions/opencode/plugins/model-checker.json

@@ -1,13 +0,0 @@
-{
-  "models": [
-    "openai/gpt-5.5",
-    "opencode/big-pickle",
-    "opencode/minimax-m2.5-free",
-    "google/antigravity-claude-opus-4-6-thinking",
-    "google/antigravity-claude-sonnet-4-6",
-    "google/antigravity-gemini-3-flash",
-    "google/antigravity-gemini-3.1-pro"
-  ],
-  "timeoutMs": 2000,
-  "concurrency": 10
-}

package/extensions/opencode/plugins/model-checker.ts

@@ -1,302 +0,0 @@
-import type { Plugin } from "@opencode-ai/plugin"
-import { mkdir, readFile, writeFile } from "node:fs/promises"
-import { readFileSync } from "node:fs"
-import { join } from "node:path"
-import { tmpdir } from "node:os"
-import { spawn } from "node:child_process"
-
-interface ModelResult {
-  model: string
-  status: "passed" | "failed"
-  error?: string
-}
-
-interface ModelCheckerConfig {
-  models: string[]
-  timeoutMs: number
-  concurrency: number
-  prompt: string
-  probeDir: string
-}
-
-type CommandResult = {
-  code: number | null
-  output: string
-  timedOut: boolean
-  durationMs: number
-}
-
-type AgenticPluginConfig = {
-  modelChecker?: {
-    enabled?: boolean
-  }
-}
-
-function readAgenticConfig(): AgenticPluginConfig {
-  const configHome = process.env.XDG_CONFIG_HOME || join(process.env.HOME || "", ".config")
-  const configPath = join(configHome, "agentic", "opencode-plugins.json")
-
-  try {
-    return JSON.parse(readFileSync(configPath, "utf-8")) as AgenticPluginConfig
-  } catch {
-    return {}
-  }
-}
-
-async function readModelsJson(projectDir: string): Promise<ModelCheckerConfig> {
-  const defaults: ModelCheckerConfig = {
-    models: [],
-    timeoutMs: 10000,
-    concurrency: 3,
-    prompt: "Reply with exactly: OK",
-    probeDir: tmpdir(),
-  }
-
-  try {
-    const filePath = join(projectDir, ".opencode", "plugins", "model-checker.json")
-    const content = await readFile(filePath, "utf-8")
-    const data = JSON.parse(content)
-    if (!Array.isArray(data.models)) return defaults
-
-    const models = [...new Set(data.models.map(String).filter(Boolean))]
-    const timeoutMs = Number.isFinite(data.timeoutMs)
-      ? Math.min(120000, Math.max(1000, Number(data.timeoutMs)))
-      : defaults.timeoutMs
-    const concurrency = Number.isFinite(data.concurrency)
-      ? Math.min(10, Math.max(1, Number(data.concurrency)))
-      : defaults.concurrency
-    const prompt = typeof data.prompt === "string" && data.prompt.trim() ? data.prompt.trim() : defaults.prompt
-    const probeDir = typeof data.probeDir === "string" && data.probeDir.trim() ? data.probeDir.trim() : defaults.probeDir
-
-    return {
-      models,
-      timeoutMs,
-      concurrency,
-      prompt,
-      probeDir,
-    }
-  } catch {
-    return defaults
-  }
-}
-
-async function runModelProbe(model: string, prompt: string, timeoutMs: number, probeDir: string): Promise<CommandResult> {
-  return await new Promise((resolve) => {
-    const startedAt = Date.now()
-    const child = spawn("opencode", ["run", prompt, "-m", model, "--dir", probeDir, "--log-level", "ERROR"], {
-      cwd: probeDir,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        OPENCODE_MODEL_CHECKER_ACTIVE: "1",
-      },
-    })
-
-    let stdout = ""
-    let stderr = ""
-    let timedOut = false
-
-    const timer = setTimeout(() => {
-      timedOut = true
-      child.kill("SIGKILL")
-    }, timeoutMs)
-
-    child.stdout.on("data", (chunk: Buffer | string) => {
-      stdout += chunk.toString()
-    })
-
-    child.stderr.on("data", (chunk: Buffer | string) => {
-      stderr += chunk.toString()
-    })
-
-    child.on("close", (code) => {
-      clearTimeout(timer)
-      resolve({
-        code,
-        timedOut,
-        output: `${stdout}\n${stderr}`.toLowerCase(),
-        durationMs: Date.now() - startedAt,
-      })
-    })
-
-    child.on("error", (error) => {
-      clearTimeout(timer)
-      resolve({
-        code: 1,
-        timedOut,
-        output: String(error).toLowerCase(),
-        durationMs: Date.now() - startedAt,
-      })
-    })
-  })
-}
-
-async function runModelChecks(
-  models: string[],
-  prompt: string,
-  timeoutMs: number,
-  concurrency: number,
-  probeDir: string,
-): Promise<CommandResult[]> {
-  const workers = Math.min(concurrency, models.length)
-  const results: CommandResult[] = new Array(models.length)
-  let cursor = 0
-
-  await Promise.all(
-    Array.from({ length: workers }, async () => {
-      while (true) {
-        const index = cursor++
-        if (index >= models.length) return
-        results[index] = await runModelProbe(models[index], prompt, timeoutMs, probeDir)
-      }
-    }),
-  )
-
-  return results
-}
-
-function classifyResult(model: string, probe: CommandResult): ModelResult {
-  if (probe.timedOut) return { model, status: "failed", error: "timeout" }
-
-  if (probe.output.includes("quota") || probe.output.includes("insufficient") || probe.output.includes("429")) {
-    return { model, status: "failed", error: "quota" }
-  }
-
-  if (probe.code !== 0) {
-    if (/(\b4\d\d\b|\b5\d\d\b)/.test(probe.output)) {
-      return { model, status: "failed", error: "provider error" }
-    }
-    return { model, status: "failed", error: `exit code ${probe.code ?? "null"}` }
-  }
-
-  if (!probe.output.includes("ok")) {
-    return { model, status: "failed", error: "unexpected response" }
-  }
-
-  return { model, status: "passed" }
-}
-
-function printLists(passed: ModelResult[], failed: ModelResult[]) {
-  console.log("\npassed_models:")
-  for (const model of passed) {
-    console.log(`- ${model.model}`)
-  }
-
-  console.log("\nfailed_models:")
-  for (const model of failed) {
-    console.log(`- ${model.model}${model.error ? ` (${model.error})` : ""}`)
-  }
-}
-
-function formatTelegramMessage(passed: ModelResult[], failed: ModelResult[], selected: string): string {
-  const passedText = passed.length ? passed.map((x) => `• ${x.model}`).join("\n") : "(none)"
-  const failedText = failed.length
-    ? failed.map((x) => `• ${x.model}${x.error ? ` (${x.error})` : ""}`).join("\n")
-    : "(none)"
-
-  return [
-    "<b>LLM availability check</b>",
-    "",
-    `<b>passed_models (${passed.length})</b>`,
-    passedText,
-    "",
-    `<b>failed_models (${failed.length})</b>`,
-    failedText,
-    "",
-    `<b>selected model:</b> ${selected}`,
-  ].join("\n")
-}
-
-async function sendTelegram(message: string) {
-  const token = process.env.OPENCODE_TELEGRAM_BOT_TOKEN
-  const chatID = process.env.OPENCODE_TELEGRAM_CHAT_ID
-  if (!token || !chatID) return
-
-  try {
-    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        chat_id: chatID,
-        text: message,
-        parse_mode: "HTML",
-      }),
-    })
-  } catch {
-    // no-op
-  }
-}
-
-async function regenerateOpencodeJson(projectDir: string, selected: string, passed: string[]) {
-  const filePath = join(projectDir, ".opencode", "opencode.json")
-  try {
-    const content = await readFile(filePath, "utf-8")
-    const config = JSON.parse(content)
-
-    if (!config.agent || typeof config.agent !== "object") return
-
-    for (const [agentName, agentConfig] of Object.entries<any>(config.agent)) {
-      if (!agentConfig || typeof agentConfig !== "object") continue
-      if (agentConfig.mode !== "subagent") continue
-
-      config.agent[agentName].model = selected
-    }
-
-    await writeFile(filePath, `${JSON.stringify(config, null, 2)}\n`, "utf-8")
-  } catch {
-    // no-op
-  }
-}
-
-export const ModelCheckerPlugin: Plugin = async ({ directory }) => {
-  const config = readAgenticConfig()
-  if (!config.modelChecker?.enabled) {
-    return {}
-  }
-
-  if (process.env.OPENCODE_MODEL_CHECKER_ACTIVE === "1") {
-    return {}
-  }
-
-  if (process.argv[2] === "run") {
-    return {}
-  }
-
-  async function runChecks() {
-    const config = await readModelsJson(directory)
-    const { models, prompt, timeoutMs, concurrency, probeDir } = config
-    if (!models.length) return
-
-    await mkdir(probeDir, { recursive: true })
-
-    console.log("\nStarting LLM model availability check...")
-    console.log(`- models: ${models.length}, concurrency: ${Math.min(concurrency, models.length)}, timeout: ${timeoutMs}ms`)
-    const results: ModelResult[] = []
-    const probes = await runModelChecks(models, prompt, timeoutMs, concurrency, probeDir)
-    for (const [index, model] of models.entries()) {
-      const probe = probes[index]
-      const result = classifyResult(model, probe)
-      results.push(result)
-      console.log(
-        `- checking ${model}... ${result.status === "passed" ? "OK" : `FAIL (${result.error})`} (${probe.durationMs}ms)`,
-      )
-    }
-
-    const passedModels = results.filter((x) => x.status === "passed")
-    const failedModels = results.filter((x) => x.status === "failed")
-    const selected = passedModels[0]?.model ?? "none"
-
-    printLists(passedModels, failedModels)
-    console.log(`\nselected_model: ${selected}`)
-
-    if (selected !== "none") {
-      await regenerateOpencodeJson(directory, selected, passedModels.map((x) => x.model))
-    }
-
-    await sendTelegram(formatTelegramMessage(passedModels, failedModels, selected))
-  }
-
-  await runChecks()
-
-  return {}
-}