opencode-resolve 0.1.19 → 0.2.0

package/dist/state.d.ts

@@ -6,6 +6,8 @@ export declare const FAILURE_THRESHOLD = 10;
 export declare const STRATEGY_PIVOT_THRESHOLD = 20;
 export declare const EDIT_HOTSPOT_THRESHOLD = 10;
 export declare const EDIT_HOTSPOT_TTL_MS = 600000;
+export declare const DISPATCH_STOP_THRESHOLD = 3;
+export declare const DISPATCH_PIVOT_THRESHOLD = 6;
 export interface SessionState {
     storedConfig?: ResolveConfig;
     storedProjectContext?: ProjectContext;
@@ -13,6 +15,10 @@ export interface SessionState {
         errors: number;
         warnings: number;
         timestamp: number;
+        errorMessages?: {
+            line: number;
+            message: string;
+        }[];
     }>;
     failurePatterns: Map<string, {
         count: number;
@@ -27,9 +33,16 @@ export interface SessionState {
     }>;
     totalEdits: number;
     totalToolCalls: number;
+    totalOutputBytes: number;
     sessionStartTime: number;
     loopWarnings: string[];
     lastStrategyHint: string;
+    consecutiveDispatchFailures: number;
+    lastDispatchAgent?: string;
+    lastDispatchSucceeded?: boolean;
+    lastDispatchAt?: number;
+    awaitingVerify: boolean;
+    awaitingVerifyFile?: string;
     currentAgent?: string;
     locale: Locale;
 }

package/dist/state.js

@@ -4,6 +4,12 @@ export const FAILURE_THRESHOLD = 10;
 export const STRATEGY_PIVOT_THRESHOLD = 20;
 export const EDIT_HOTSPOT_THRESHOLD = 10;
 export const EDIT_HOTSPOT_TTL_MS = 600_000;
+// Ralph Loop: dispatch lifecycle thresholds. The resolver→coder loop must
+// close: dispatch → verify → (fail: diagnose+redispatch | pass: done).
+// After DISPATCH_STOP_THRESHOLD consecutive failed dispatches, force a STOP &
+// report. After DISPATCH_PIVOT_THRESHOLD, force an architect rethink.
+export const DISPATCH_STOP_THRESHOLD = 3;
+export const DISPATCH_PIVOT_THRESHOLD = 6;
 export function createSessionState() {
     return {
         recentDiagnostics: new Map(),
@@ -13,9 +19,12 @@ export function createSessionState() {
         editHotspots: new Map(),
         totalEdits: 0,
         totalToolCalls: 0,
+        totalOutputBytes: 0,
         sessionStartTime: Date.now(),
         loopWarnings: [],
         lastStrategyHint: "",
+        consecutiveDispatchFailures: 0,
+        awaitingVerify: false,
         locale: "en"
     };
 }

package/dist/tools/index.d.ts

@@ -1,4 +1,5 @@
 import { SessionState } from "../state.js";
+export declare function summarizeTestFailure(stdout: string, stderr: string, runner: string | undefined): string;
 export declare function getTools(sessionState: SessionState): {
     "resolve-verify": {
         description: string;
@@ -13,9 +14,11 @@ export declare function getTools(sessionState: SessionState): {
         description: string;
         args: {
             path: import("zod").ZodOptional<import("zod").ZodString>;
+            context: import("zod").ZodOptional<import("zod").ZodBoolean>;
         };
         execute(args: {
             path?: string | undefined;
+            context?: boolean | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
     };
     "resolve-context": {
@@ -56,11 +59,13 @@ export declare function getTools(sessionState: SessionState): {
             file: import("zod").ZodOptional<import("zod").ZodString>;
             pattern: import("zod").ZodOptional<import("zod").ZodString>;
             runner: import("zod").ZodOptional<import("zod").ZodString>;
+            raw: import("zod").ZodOptional<import("zod").ZodBoolean>;
         };
         execute(args: {
             file?: string | undefined;
             pattern?: string | undefined;
             runner?: string | undefined;
+            raw?: boolean | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
     };
     "resolve-pattern": {
@@ -219,8 +224,12 @@ export declare function getTools(sessionState: SessionState): {
     };
     "resolve-session": {
         description: string;
-        args: {};
-        execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+        args: {
+            full: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        };
+        execute(args: {
+            full?: boolean | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
     };
     "resolve-audit": {
         description: string;

package/dist/tools/index.js

@@ -6,8 +6,8 @@ import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
 import { classifyBashCommand, runCommand, sanitizeShellArg, truncateOutput, PLUGIN_VERSION } 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", "codex", "coder", "glm", "gpt-coder", "debugger"]);
+import { VALID_TIERS, VALID_AGENT_NAME_SET, VALID_AGENT_NAMES } from "../agents.js";
+const WRITE_CAPABLE_AGENTS = new Set(["resolver", "coder", "debugger"]);
 function canWriteFromTool(ctx) {
     return typeof ctx.agent !== "string" || WRITE_CAPABLE_AGENTS.has(ctx.agent);
 }
@@ -23,6 +23,60 @@ function commandExecutionDenied(command) {
     }
     return `Command is not allowlisted for direct tool execution: ${command}. Run it through OpenCode bash so the normal permission flow can decide.`;
 }
+// Phase 1.2: parse Vitest/Jest/Pytest/Go test failures into a compact summary
+// (failing names, expected vs received, 3 stack frames). Always returns output
+// ≤ the previous raw-truncate fallback, so resolve-test is strictly net-positive.
+export function summarizeTestFailure(stdout, stderr, runner) {
+    const raw = stderr || stdout;
+    const cmd = (runner ?? "").toLowerCase();
+    const out = `${stdout}\n${stderr}`;
+    // Pytest: "FAILED file::test_name - msg" + "E   ..." assertion lines
+    if (cmd.includes("pytest") || /FAILED\s+\S+::/.test(raw)) {
+        const failed = [...raw.matchAll(/FAILED\s+(\S+?::\S+)\s+-\s+(.+)/g)].slice(0, 10)
+            .map((m) => `  ✗ ${m[1]}\n    ${m[2].slice(0, 200)}`);
+        const asserts = [...raw.matchAll(/^E\s+(.+)/gm)].slice(0, 5).map((m) => m[1].slice(0, 200));
+        if (failed.length || asserts.length) {
+            const parts = [];
+            if (failed.length)
+                parts.push(`Failed tests:\n${failed.join("\n")}`);
+            if (asserts.length)
+                parts.push(`Assertion errors:\n  ${asserts.join("\n  ")}`);
+            return truncateOutput(parts.join("\n"), 1200);
+        }
+    }
+    // Go test: "--- FAIL: TestName" + "    file.go:NN: msg"
+    if (cmd.includes("go test") || /--- FAIL:/.test(raw)) {
+        const failed = [...raw.matchAll(/--- FAIL:\s+(\S+)/g)].slice(0, 10).map((m) => `  ✗ ${m[1]}`);
+        const errs = [...raw.matchAll(/^\s+(\S+\.go):(\d+):\s+(.+)/gm)].slice(0, 5)
+            .map((m) => `    ${m[1]}:${m[2]}: ${m[3].slice(0, 160)}`);
+        if (failed.length) {
+            return truncateOutput(`Failed tests:\n${failed.join("\n")}\n${errs.join("\n")}`, 1200);
+        }
+    }
+    // Vitest / Jest
+    const failingNames = new Set();
+    for (const m of out.matchAll(/●\s+(.+)/g))
+        failingNames.add(m[1].trim().slice(0, 120)); // Jest suite › test
+    for (const m of out.matchAll(/^\s*×\s+(.+)/gm))
+        failingNames.add(m[1].trim().slice(0, 120)); // Vitest × test
+    const failFiles = [...out.matchAll(/^FAIL\s+(\S+)/gm)].map((m) => m[1]).slice(0, 10);
+    const expected = [...out.matchAll(/Expected[^:\n]*:\s*(.+)/g)].slice(0, 3).map((m) => m[1].slice(0, 150));
+    const received = [...out.matchAll(/Received[^:\n]*:\s*(.+)/g)].slice(0, 3).map((m) => m[1].slice(0, 150));
+    const stack = [...out.matchAll(/^\s+at\s+(.+)/gm)].slice(0, 3).map((m) => m[1].slice(0, 160));
+    const parts = [];
+    if (failFiles.length)
+        parts.push(`Failed files: ${failFiles.join(", ")}`);
+    if (failingNames.size)
+        parts.push(`Failed tests:\n${[...failingNames].slice(0, 10).map((n) => `  ✗ ${n}`).join("\n")}`);
+    if (expected.length || received.length) {
+        parts.push(`Expected: ${expected[0] ?? "-"}\nReceived: ${received[0] ?? "-"}`);
+    }
+    if (stack.length)
+        parts.push(`Stack:\n${stack.map((s) => `  at ${s}`).join("\n")}`);
+    // Parsed something useful → compact summary; otherwise fall back to the
+    // previous raw-truncate behaviour (byte-identical).
+    return parts.length ? truncateOutput(parts.join("\n"), 1200) : truncateOutput(raw, 1500);
+}
 export function getTools(sessionState) {
     return {
         "resolve-verify": tool({
@@ -53,22 +107,53 @@ export function getTools(sessionState) {
             },
         }),
         "resolve-diagnostics": tool({
-            description: "Get current LSP diagnostics snapshot. Returns errors and warnings per file from the language server.",
+            description: "Get current LSP diagnostics snapshot. Returns errors and warnings per file from the language server. When errors are present, includes the message and ±3 lines of source context so the coder can fix without a separate read.",
             args: {
                 path: tool.schema.string().optional().describe("Specific file path to check. If omitted, returns all files with active diagnostics."),
+                context: tool.schema.boolean().optional().describe("Include ±3 lines of source context around each error (default true). Set false for counts only."),
             },
-            async execute(args) {
+            async execute(args, ctx) {
                 if (sessionState.recentDiagnostics.size === 0) {
                     return "No active LSP diagnostics.";
                 }
                 const now = Date.now();
+                const wantContext = args.context !== false;
                 const entries = [];
                 for (const [filePath, diag] of sessionState.recentDiagnostics) {
                     if (now - diag.timestamp > DIAGNOSTICS_TTL_MS)
                         continue;
                     if (args.path && filePath !== args.path)
                         continue;
-                    entries.push(`${filePath}: ${diag.errors} errors, ${diag.warnings} warnings`);
+                    const head = `${filePath}: ${diag.errors} errors, ${diag.warnings} warnings`;
+                    // Net-positive: error-free files and context:false calls are byte-identical to before.
+                    if (!wantContext || diag.errors === 0 || !diag.errorMessages?.length) {
+                        entries.push(head);
+                        continue;
+                    }
+                    // Errors present: show message + ±3 source lines (bounded to 3 errors/file).
+                    const blocks = [head];
+                    let srcLines = null;
+                    for (const e of diag.errorMessages.slice(0, 3)) {
+                        const ln = e.line + 1; // LSP lines are 0-based
+                        if (srcLines === null) {
+                            try {
+                                srcLines = (await readFile(resolve(ctx.directory, filePath), "utf8")).split("\n");
+                            }
+                            catch {
+                                srcLines = []; // unreadable: show message without context
+                            }
+                        }
+                        let snippet = "";
+                        if (srcLines.length > 0) {
+                            const start = Math.max(0, ln - 4);
+                            const end = Math.min(srcLines.length, ln + 3);
+                            snippet = srcLines.slice(start, end)
+                                .map((l, i) => `${start + i + 1}${start + i + 1 === ln ? ">" : ":"} ${l}`)
+                                .join("\n");
+                        }
+                        blocks.push(`  L${ln}: ${e.message}${snippet ? "\n" + snippet : ""}`);
+                    }
+                    entries.push(blocks.join("\n"));
                 }
                 if (entries.length === 0) {
                     return args.path ? `No active diagnostics for ${args.path}.` : "No active LSP diagnostics.";
@@ -177,6 +262,7 @@ export function getTools(sessionState) {
                 file: tool.schema.string().optional().describe("Test file path or glob pattern (e.g. 'test/plugin.test.mjs')."),
                 pattern: tool.schema.string().optional().describe("Test name pattern to filter (e.g. 'GLM profile')."),
                 runner: tool.schema.string().optional().describe("Override test runner command (e.g. 'vitest run', 'jest')."),
+                raw: tool.schema.boolean().optional().describe("Return the raw untruncated log instead of the parsed failure summary."),
             },
             async execute(args, ctx) {
                 const projCtx = sessionState.storedProjectContext;
@@ -215,7 +301,11 @@ export function getTools(sessionState) {
                     if (result.exitCode === 0) {
                         return { output: `✅ Tests passed.\n${truncateOutput(result.stdout, 800)}`, metadata: { exitCode: 0 } };
                     }
-                    return { output: `❌ Tests failed (exit ${result.exitCode}).\n${truncateOutput(result.stderr || result.stdout, 1500)}`, metadata: { exitCode: result.exitCode } };
+                    // Phase 1.2: parse framework output into a compact summary unless raw requested.
+                    const detail = args.raw
+                        ? truncateOutput(result.stderr || result.stdout, 1500)
+                        : summarizeTestFailure(result.stdout, result.stderr, testCmd);
+                    return { output: `❌ Tests failed (exit ${result.exitCode}).\n${detail}`, metadata: { exitCode: result.exitCode } };
                 }
                 catch (err) {
                     return `⚠️ Test runner failed: ${err instanceof Error ? err.message : String(err)}`;
@@ -480,8 +570,6 @@ export function getTools(sessionState) {
                 }
                 // Build resolve.json content
                 const resolveConfig = {};
-                if (sessionState.storedConfig?.profile)
-                    resolveConfig.profile = sessionState.storedConfig.profile;
                 if (sessionState.storedConfig?.tier)
                     resolveConfig.tier = sessionState.storedConfig.tier;
                 if (projCtx?.verifyCommands.length) {
@@ -926,9 +1014,11 @@ export function getTools(sessionState) {
             },
         }),
         "resolve-session": tool({
-            description: "Show current Ralph Loop session state: profile, tier, edit count, tool call count, failure warnings, loop warnings, and elapsed time. Use when you suspect you're going in circles.",
-            args: {},
-            async execute(_args, ctx) {
+            description: "Show current Ralph Loop session state: tier, edit count, tool call count, output bytes, failure warnings, loop warnings, and elapsed time. Use when you suspect you're going in circles.",
+            args: {
+                full: tool.schema.boolean().optional().describe("Include a compact changelog (recent commits + uncommitted count) so you get session + repo state in one call. Default false."),
+            },
+            async execute(args, ctx) {
                 const lines = [];
                 const cfg = sessionState.storedConfig;
                 const projCtx = sessionState.storedProjectContext;
@@ -936,8 +1026,7 @@ export function getTools(sessionState) {
                 lines.push(`Session duration: ${elapsed}s`);
                 lines.push(`Tool calls: ${sessionState.totalToolCalls}`);
                 lines.push(`Edits: ${sessionState.totalEdits}`);
-                if (cfg?.profile)
-                    lines.push(`Profile: ${cfg.profile}`);
+                lines.push(`Output: ${sessionState.totalOutputBytes} bytes (~${Math.round(sessionState.totalOutputBytes / 1024)}KB)`);
                 if (cfg?.tier)
                     lines.push(`Tier: ${cfg.tier}`);
                 if (projCtx?.hasTypeScript)
@@ -970,6 +1059,25 @@ export function getTools(sessionState) {
                         lines.push(`  🔄 ${w}`);
                 }
                 ctx.metadata({ title: `session: ${sessionState.totalEdits} edits, ${sessionState.totalToolCalls} tools, ${elapsed}s` });
+                // Phase 1.6: opt-in `full` mode folds a compact changelog (recent
+                // commits + uncommitted count) into the same response — 3 calls → 1.
+                // Default (full omitted/false) leaves the output exactly as before.
+                if (args.full) {
+                    try {
+                        const log = await runCommand("git log --oneline -5", ctx.directory, 5_000);
+                        const st = await runCommand("git status --porcelain", ctx.directory, 5_000);
+                        lines.push("Recent changes:");
+                        if (log.stdout.trim()) {
+                            lines.push(log.stdout.trim().split("\n").map((l) => `  ${l}`).join("\n"));
+                        }
+                        else {
+                            lines.push("  (no commits yet)");
+                        }
+                        const uncommitted = st.stdout.trim().split("\n").filter(Boolean).length;
+                        lines.push(`Uncommitted files: ${uncommitted}`);
+                    }
+                    catch { /* not a git repo */ }
+                }
                 return lines.join("\n");
             },
         }),
@@ -1053,17 +1161,17 @@ export function getTools(sessionState) {
                 if (!cfg) {
                     return "No resolve config loaded. Plugin may not be initialized.";
                 }
-                // 1. Profile check
-                if (cfg.profile) {
-                    if (VALID_PROFILES.has(cfg.profile)) {
-                        results.push(`✅ Profile: ${cfg.profile}`);
+                // 1. Tier check
+                if (cfg.tier) {
+                    if (VALID_TIERS.has(cfg.tier)) {
+                        results.push(`✅ Tier: ${cfg.tier}`);
                     }
                     else {
-                        results.push(`🔴 Invalid profile: '${cfg.profile}'. Valid: ${[...VALID_PROFILES].join(", ")}`);
+                        results.push(`🔴 Invalid tier: '${cfg.tier}'. Valid: ${[...VALID_TIERS].join(", ")}`);
                     }
                 }
                 else {
-                    results.push("ℹ️ No profile set (using defaults)");
+                    results.push("ℹ️ No tier set (using defaults)");
                 }
                 // 2. Tier check
                 if (cfg.tier) {
@@ -1190,8 +1298,6 @@ export function getTools(sessionState) {
                     failures: sessionState.totalFailures,
                     elapsedSeconds: Math.round((Date.now() - sessionState.sessionStartTime) / 1000),
                 };
-                if (sessionState.storedConfig?.profile)
-                    state.profile = sessionState.storedConfig.profile;
                 if (sessionState.storedConfig?.tier)
                     state.tier = sessionState.storedConfig.tier;
                 if (sessionState.failureWarnings.length > 0)

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export type PermissionValue = "ask" | "allow" | "deny";
-export type ResolveAgentName = "coder" | "reviewer" | "resolver" | "codex" | "gpt" | "glm" | "architect" | "gpt-coder" | "debugger" | "researcher" | "explorer" | "deep-reviewer" | "planner";
-export type ModelAlias = ResolveAgentName | "glm" | "gpt" | "quick" | "deep" | "fast" | "strong" | "mini" | "codex" | "bronze" | "silver" | "gold" | "gpt-bronze" | "gpt-silver" | "gpt-gold" | "glm-bronze" | "glm-silver" | "glm-gold";
+export type ResolveAgentName = "coder" | "reviewer" | "resolver" | "architect" | "debugger" | "researcher" | "explorer" | "deep-reviewer" | "planner";
+export type ModelAlias = ResolveAgentName | "quick" | "deep" | "fast" | "strong" | "mini" | "bronze" | "silver" | "gold";
 export type AgentMode = "subagent" | "primary" | "all";
 export type ResolveAgentConfig = {
     enabled?: boolean;
@@ -19,22 +19,20 @@ export type ResolveAgentConfig = {
         external_directory?: PermissionValue;
     };
 };
-export type ProfileName = "mix" | "glm" | "gpt";
 export type TierName = "bronze" | "silver" | "gold";
 export type LanguageSetting = "auto" | "en" | "ko";
 export type ResolveConfig = {
-    profile?: ProfileName;
     tier?: TierName;
     enabled?: ResolveAgentName[];
     models?: Partial<Record<ModelAlias, string>>;
     agents?: Partial<Record<ResolveAgentName, ResolveAgentConfig>>;
     preserveNative?: boolean;
-    context7?: boolean;
     commands?: boolean;
     autoApprove?: boolean;
     maxParallelSubagents?: number;
     autoUpdate?: boolean;
     language?: LanguageSetting;
+    singleAgentMode?: boolean;
 };
 export type ResolvePluginOptions = ResolveConfig & {
     config?: string;

package/dist/utils.d.ts

@@ -1,8 +1,5 @@
 import { ProjectContext, ResolveConfig } from "./types.js";
 export declare const PLUGIN_VERSION: string;
-export declare const UPDATE_CHECK_INTERVAL_MS: number;
-export declare const UPDATE_CHECK_FILE: string;
-export declare const PLUGIN_CACHE_DIR: string;
 export declare function runCommand(command: string, cwd: string, timeoutMs: number): Promise<{
     stdout: string;
     stderr: string;
@@ -20,12 +17,6 @@ export declare function existsDirectory(path: string): Promise<boolean>;
 export declare function detectProjectContext(directory: string): Promise<ProjectContext>;
 export declare function collectContextFiles(rootDirectory: string, relativeDirectory: string, maxFiles?: number): Promise<string[]>;
 export declare function readPluginVersion(): string;
-export declare function readUpdateCheckCache(): {
-    checkedAt: number;
-    latest: string;
-} | undefined;
-export declare function isNewerVersion(candidate: string, baseline: string): boolean;
-export declare function maybeAutoUpdate(): Promise<void>;
 export declare function readFirstJson(paths: string[]): Promise<ResolveConfig | undefined>;
 export declare const BANNED_COMMANDS: ReadonlyArray<RegExp>;
 export declare const DANGEROUS_BASH_PATTERNS: ReadonlyArray<RegExp>;

package/dist/utils.js

@@ -1,14 +1,10 @@
 import { spawn } from "node:child_process";
 import { stat, readFile, access, readdir } from "node:fs/promises";
 import { join, dirname, extname, relative } from "node:path";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
+import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { normalizeResolveConfig } from "./config.js";
 export const PLUGIN_VERSION = readPluginVersion();
-export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-export const UPDATE_CHECK_FILE = join(homedir(), ".cache", "opencode-resolve", "update-check.json");
-export const PLUGIN_CACHE_DIR = join(homedir(), ".cache", "opencode", "packages", "opencode-resolve@latest");
 export function runCommand(command, cwd, timeoutMs) {
     return new Promise((resolve) => {
         const proc = spawn("sh", ["-c", command], {
@@ -218,92 +214,13 @@ export function readPluginVersion() {
         return "unknown";
     }
 }
-export 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;
-}
-export 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 async function maybeAutoUpdate() {
-    const previous = readUpdateCheckCache();
-    try {
-        if (previous && Date.now() - previous.checkedAt < UPDATE_CHECK_INTERVAL_MS) {
-            if (isNewerVersion(previous.latest, PLUGIN_VERSION)) {
-                refreshPluginCacheInBackground(previous.latest, "cached");
-            }
-            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;
-    refreshPluginCacheInBackground(latest, "registry");
-}
-function refreshPluginCacheInBackground(latest, source) {
-    const sourceLabel = source === "cached" ? "cached latest" : "registry latest";
-    console.log(`[opencode-resolve] new version v${latest} available (${sourceLabel}, current: v${PLUGIN_VERSION}) — refreshing OpenCode plugin cache in background. Restart OpenCode to activate it.`);
-    try {
-        spawn("sh", ["-c", `rm -rf "${PLUGIN_CACHE_DIR}" && opencode plugin opencode-resolve@latest --global --force`], {
-            detached: true,
-            stdio: "ignore",
-            env: {
-                ...process.env,
-                OPENCODE_RESOLVE_REFRESHING_CACHE: "1",
-                OPENCODE_RESOLVE_SKIP_POSTINSTALL: "1",
-                OPENCODE_RESOLVE_SKIP_COMPANIONS: "1",
-            },
-        }).unref();
-    }
-    catch {
-        // If spawn fails, the user already saw the notice and can run the command manually.
-    }
-}
+// Auto-update was removed: it spawned `opencode plugin opencode-resolve@latest
+// --global --force` per `hooks.config()` call, which created hundreds of parallel
+// OpenCode sessions whenever multiple instances loaded the plugin at once (and
+// once flattened the user's server with 177 sessions during a test run).
+// Users update manually: `npm i -g opencode-resolve` or via the install script.
+// The `autoUpdate` config field is still accepted by the schema for backward
+// compatibility, but it is now a no-op.
 export async function readFirstJson(paths) {
     for (const path of paths) {
         try {

package/opencode-resolve.example.json

@@ -1,10 +1,7 @@
 {
-  "profile": "mix",
   "preserveNative": true,
-  "context7": true,
   "commands": false,
   "autoApprove": true,
-  "autoUpdate": true,
   "language": "auto",
   "models": {},
   "agents": {
@@ -15,12 +12,6 @@
     "resolver": {
       "enabled": true
     },
-    "codex": {
-      "enabled": false
-    },
-    "gpt": {
-      "enabled": false
-    },
     "explorer": {
       "enabled": true,
       "mode": "subagent"
@@ -40,17 +31,11 @@
     "architect": {
       "enabled": false
     },
-    "gpt-coder": {
-      "enabled": false
-    },
     "debugger": {
       "enabled": false
     },
     "researcher": {
       "enabled": false
-    },
-    "glm": {
-      "enabled": false
     }
   }
 }