opencode-resolve 0.1.20 → 0.3.0

package/dist/hooks/index.js

@@ -1,7 +1,80 @@
-import { DIAGNOSTICS_TTL_MS, FAILURE_PATTERN_TTL_MS, FAILURE_THRESHOLD, STRATEGY_PIVOT_THRESHOLD, EDIT_HOTSPOT_TTL_MS, EDIT_HOTSPOT_THRESHOLD } from "../state.js";
-import { classifyBashCommand, maybeAutoUpdate, detectProjectContext } from "../utils.js";
+import { DIAGNOSTICS_TTL_MS, FAILURE_PATTERN_TTL_MS, FAILURE_THRESHOLD, STRATEGY_PIVOT_THRESHOLD, EDIT_HOTSPOT_THRESHOLD, DISPATCH_STOP_THRESHOLD, DISPATCH_PIVOT_THRESHOLD } from "../state.js";
+import { classifyBashCommand, detectRollbackCommand, formatError, detectProjectContext } from "../utils.js";
+import { createRollbackCheckpoint, isGitRepository } from "../checkpoint.js";
 import { loadResolveConfig, applyResolveConfig } from "../config.js";
-import { contextMessage, narrate, resolveLocale, t, agentDisplayName, PLUGIN_BRAND } from "../messages.js";
+import { contextMessage, narrate, resolveLocale, t, agentDisplayName, brand, PLUGIN_BRAND } from "../messages.js";
+import { VALID_AGENT_NAMES } from "../agents.js";
+// Agents this plugin registers. Hooks that modify chat/tool behavior gate on
+// isActiveResolve() so native opencode agents (build/plan/default chat) pass
+// through unmodified — the plugin only intervenes when a resolve agent drives
+// the current turn.
+const RESOLVE_AGENTS = new Set(VALID_AGENT_NAMES);
+// Collaborative handoff / question patterns. A turn ending in one of these is a
+// genuine question to the user and must NEVER be rewritten into an autonomous
+// directive — doing so severs the user↔model feedback loop.
+const HANDOFF_PATTERNS = [
+    /\?\s*$/, // ends with a question mark
+    /\blet me know\b/i,
+    /\bwould you like\b/i,
+    /\bshall i\b/i,
+    /\bdo you want\b/i,
+    /\bwhat do you think\b/i,
+    /\bcan i\b/i,
+];
+// Code-file extensions. Only edits to code trigger the verify gate; docs/config
+// (.md/.txt/.json/...) are exempt so trivial doc changes don't force a build.
+const CODE_EXTENSIONS = [
+    "ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts",
+    "py", "go", "rs", "java", "kt", "scala", "rb", "php",
+    "c", "cc", "cpp", "cxx", "h", "hh", "hpp", "hxx",
+    "cs", "swift", "sh", "bash", "zsh", "fish",
+    "vue", "svelte", "astro", "gleam", "ex", "exs", "erl", "lua",
+];
+function isCodeFile(filePath) {
+    if (!filePath)
+        return true; // unknown target — be conservative, require verify
+    const dot = filePath.lastIndexOf(".");
+    if (dot < 0)
+        return true; // no extension — treat as code
+    return CODE_EXTENSIONS.includes(filePath.slice(dot + 1).toLowerCase());
+}
+// Harness boilerplate — not the model's words, so rewriting them wholesale
+// costs nothing and buys a sharper instruction.
+const HARNESS_BOILERPLATE_REWRITES = [
+    ["Summarize the task tool output above and continue with your task.",
+        "Analyze the subtask result above. If it succeeded, continue. If it failed, diagnose and retry. Report completion only when verified."],
+    [/Summarize the .+ output above and continue/i,
+        "Analyze the result above. If it succeeded, continue to the next step. If it failed, diagnose root cause and retry with a fix."],
+    [/continue with your task\.$/i,
+        "continue driving toward verified completion."],
+];
+// Marker on every appended nudge. Also the idempotency key: a part that already
+// carries it is never nudged again.
+const NUDGE_MARKER = `[${PLUGIN_BRAND}] self-check:`;
+// The model's own words — uncertainty, low confidence, retry intent. Overwriting
+// these erases the reasoning trace the model needs to notice it is going in
+// circles, so the original text stays and a nudge is appended after it.
+const SELF_REVIEW_NUDGES = [
+    [/I('ve| have) (completed|finished|done) (the )?.*\.$/i,
+        "Before this counts as complete: did typecheck/lint/test actually run and pass? Verify, then report."],
+    [/I('ll| will) (try again|retry|attempt again|redo)/i,
+        "Name the ROOT CAUSE before retrying — a retry that repeats the same fix fails the same way."],
+    [/I('m| am) (not sure|unsure|uncertain) .*/i,
+        "The uncertainty is worth stating. Now settle it with evidence: read the code, check resolve-diagnostics, or search."],
+    [/this (might|should|could|may) work/i,
+        "CONFIRM it works by running verification before moving on. Do not assume."],
+    [/it (seems|appears|looks) to (be )?(working|fine|correct)/i,
+        "VERIFY with typecheck/lint/test — 'seems to work' is not evidence."],
+];
+// Edit-hotspot feedback. Repeatedly editing one file is often the *correct*
+// path through a hard bug — the failure mode is not the repetition itself but
+// re-applying the same change blind. So the nudge asks the model to inspect its
+// own diff, never to go edit some other file (that spreads the damage).
+function hotspotDiffPrompt(filePath, count) {
+    return `'${filePath}' has been edited ${count} times. Before the next edit, run \`git diff -- ${filePath}\` ` +
+        `and check whether recent edits repeat the same substitution or undo each other. ` +
+        `If the root cause is genuinely in this file, keep working here.`;
+}
 function capTemperature(current, cap) {
     return typeof current === "number" && Number.isFinite(current)
         ? Math.min(current, cap)
@@ -16,10 +89,6 @@ const DISPATCH_KEYS = {
     architect: "dispatch.architect",
     researcher: "dispatch.researcher",
     debugger: "dispatch.debugger",
-    codex: "dispatch.codex",
-    glm: "dispatch.glm",
-    gpt: "dispatch.gpt",
-    "gpt-coder": "dispatch.gptCoder",
 };
 function extractSubagentType(args) {
     if (!args || typeof args !== "object")
@@ -36,6 +105,26 @@ function extractDispatchGoal(args) {
     const trimmed = candidate.trim().split("\n")[0] ?? "";
     return trimmed.length > 80 ? trimmed.slice(0, 77) + "…" : trimmed;
 }
+// Ralph Loop: does a bash command run one of the project's verify commands
+// (typecheck / lint / test)? Used to clear the awaitingVerify flag so the
+// loop can tell the resolver the edit was actually checked.
+function isVerifyCommand(cmd, verifyCommands) {
+    if (typeof cmd !== "string" || cmd.length === 0)
+        return false;
+    if (!Array.isArray(verifyCommands) || verifyCommands.length === 0)
+        return false;
+    const normalized = cmd.trim();
+    return verifyCommands.some((vc) => typeof vc === "string" && vc.length > 0 && normalized.includes(vc));
+}
+// Ralph Loop: classify a task (subagent dispatch) result as success/failure.
+// A dispatch is failed if the tool errored or carried an error in metadata.
+function dispatchFailed(output) {
+    if (Boolean(output?.error))
+        return true;
+    if (typeof output?.metadata === "object" && output.metadata?.error)
+        return true;
+    return false;
+}
 export function getHooks(directory, options, sessionState) {
     const narrateToolStart = (input, output) => {
         const tool = input.tool;
@@ -77,6 +166,9 @@ export function getHooks(directory, options, sessionState) {
             (typeof output?.metadata === "object" && output.metadata?.error);
         narrate(sessionState, errorPresent ? "dispatch.failed" : "dispatch.completed", { to });
     };
+    // Is the current turn driven by an agent this plugin registered? Native
+    // opencode agents (build/plan/default chat) return false → hooks no-op.
+    const isActiveResolve = () => RESOLVE_AGENTS.has(sessionState.currentAgent ?? "");
     return {
         event: async (input) => {
             const evt = input.event;
@@ -90,8 +182,17 @@ export function getHooks(directory, options, sessionState) {
                             : [];
                     const errors = diagnostics.filter((d) => d.severity === 1 || d.severity === "error").length;
                     const warnings = diagnostics.filter((d) => d.severity === 2 || d.severity === "warning").length;
+                    // Phase 1.1: capture error messages + line numbers so resolve-diagnostics
+                    // can show ±3 lines of context, saving the coder a separate read call.
+                    const errorMessages = diagnostics
+                        .filter((d) => d.severity === 1 || d.severity === "error")
+                        .slice(0, 20)
+                        .map((d) => ({
+                        line: d.range?.start?.line ?? d.line ?? 0,
+                        message: String(d.message ?? "").slice(0, 200),
+                    }));
                     if (errors > 0 || warnings > 0) {
-                        sessionState.recentDiagnostics.set(props.path, { errors, warnings, timestamp: Date.now() });
+                        sessionState.recentDiagnostics.set(props.path, { errors, warnings, timestamp: Date.now(), errorMessages });
                     }
                     else {
                         sessionState.recentDiagnostics.delete(props.path);
@@ -131,9 +232,9 @@ export function getHooks(directory, options, sessionState) {
                         // Generate warnings for recurring failures
                         sessionState.totalFailures++;
                         sessionState.failureWarnings = [];
-                        for (const [, v] of sessionState.failurePatterns) {
+                        for (const [k, v] of sessionState.failurePatterns) {
                             if (v.count >= FAILURE_THRESHOLD) {
-                                sessionState.failureWarnings.push(`Tool '${toolName}' failed ${v.count} times. Last: ${v.lastMessage}`);
+                                sessionState.failureWarnings.push(`Tool '${k}' failed ${v.count} times. Last: ${v.lastMessage}`);
                             }
                         }
                     }
@@ -162,42 +263,6 @@ export function getHooks(directory, options, sessionState) {
                     }
                 }
             }
-            // ── Ralph Loop: track edit tool calls for hotspot detection ────────
-            if (evt.type === "message.part.updated") {
-                const props = evt.properties;
-                const part = props.part;
-                if (part?.type === "tool-invocation" || part?.type === "tool-use") {
-                    sessionState.totalToolCalls++;
-                    const toolName = part.tool ?? part.toolName ?? "";
-                    if (toolName === "edit" || toolName === "write") {
-                        sessionState.totalEdits++;
-                        const filePath = part.args?.filePath ?? part.args?.path ?? "";
-                        if (filePath) {
-                            const existing = sessionState.editHotspots.get(filePath);
-                            if (existing) {
-                                existing.count++;
-                                existing.lastEditTime = Date.now();
-                            }
-                            else {
-                                sessionState.editHotspots.set(filePath, { count: 1, lastEditTime: Date.now() });
-                            }
-                            // Prune stale entries
-                            const now = Date.now();
-                            for (const [k, v] of sessionState.editHotspots) {
-                                if (now - v.lastEditTime > EDIT_HOTSPOT_TTL_MS)
-                                    sessionState.editHotspots.delete(k);
-                            }
-                            // Generate loop warnings
-                            sessionState.loopWarnings = [];
-                            for (const [file, data] of sessionState.editHotspots) {
-                                if (data.count >= EDIT_HOTSPOT_THRESHOLD) {
-                                    sessionState.loopWarnings.push(`File '${file}' edited ${data.count} times — consider a different approach. Keep iterating.`);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
         },
         config: async (config) => {
             const resolveConfig = await loadResolveConfig(directory, config, options);
@@ -206,14 +271,15 @@ export function getHooks(directory, options, sessionState) {
             sessionState.storedProjectContext = projectContext;
             sessionState.locale = resolveLocale(resolveConfig.language, process.env.LANG);
             applyResolveConfig(config, resolveConfig, projectContext);
-            if (resolveConfig.autoUpdate !== false && process.env.OPENCODE_RESOLVE_NO_AUTO_UPDATE !== "1") {
-                maybeAutoUpdate().catch(() => { });
-            }
+            // Auto-update removed — see src/utils.ts header. Users update manually.
         },
         "shell.env": async (_input, output) => {
             output.env = {
                 ...output.env,
-                CI: "true",
+                // CI=true is intentionally NOT forced — it strips color output from
+                // test/lint runners (jest/vitest/eslint go --no-colors under CI) and
+                // pollutes native usage. Only non-interactive guard vars are set, to
+                // prevent prompts (npm/git/pip/debconf) from hanging the agent.
                 DEBIAN_FRONTEND: "noninteractive",
                 GIT_TERMINAL_PROMPT: "0",
                 GIT_EDITOR: "true",
@@ -234,44 +300,48 @@ export function getHooks(directory, options, sessionState) {
                     : Array.isArray(input.pattern)
                         ? input.pattern.join(" ")
                         : "";
-                const action = classifyBashCommand(cmd);
-                if (action !== "ask")
-                    output.status = action;
+                // `permissions.allowGitReset` / `allowGitClean` only relax the policy for
+                // resolve agents — they are the ones `tool.execute.before` checkpoints.
+                // Native agents keep the universal deny.
+                const permissions = isActiveResolve() ? sessionState.storedConfig?.permissions : undefined;
+                const action = classifyBashCommand(cmd, permissions);
+                // Banned/dangerous commands are denied universally (protect everyone).
+                if (action === "deny") {
+                    output.status = "deny";
+                }
+                else if (action === "allow" && isActiveResolve()) {
+                    // Auto-approve safe commands only when a resolve agent drives the turn;
+                    // native agents keep opencode's own permission flow.
+                    output.status = "allow";
+                }
             }
         },
         "chat.params": async (input, output) => {
             if (typeof input.agent === "string" && input.agent.length > 0) {
                 sessionState.currentAgent = input.agent;
             }
-            const profile = sessionState.storedConfig?.profile;
-            if (profile === "glm") {
-                output.temperature = capTemperature(output.temperature, 0.4);
-                if (output.maxOutputTokens === undefined || output.maxOutputTokens > 16384) {
-                    output.maxOutputTokens = 16384;
-                }
-                // GLM: tighter topP for deterministic output
-                if (output.topP === undefined || output.topP > 0.9) {
-                    output.topP = 0.85;
-                }
+            // Only shape params for resolve agents — native opencode agents (build/plan)
+            // pass through so the plugin never alters their model behavior.
+            if (!isActiveResolve())
+                return;
+            // Deterministic params keep the resolve loop on-rails (coding benefits from low temperature).
+            output.temperature = capTemperature(output.temperature, 0.4);
+            if (output.maxOutputTokens === undefined || output.maxOutputTokens > 16384) {
+                output.maxOutputTokens = 16384;
             }
-            else if (profile === "gpt") {
-                output.temperature = capTemperature(output.temperature, 0.7);
-                if (output.maxOutputTokens === undefined) {
-                    output.maxOutputTokens = 32768;
-                }
+            if (output.topP === undefined || output.topP > 0.9) {
+                output.topP = 0.85;
             }
             // Read-only agents: lower temperature always
             const readOnlyAgents = new Set(["reviewer", "deep-reviewer", "explorer", "planner", "researcher", "architect"]);
             if (readOnlyAgents.has(input.agent)) {
                 output.temperature = capTemperature(output.temperature, 0.3);
             }
-            // Write agents: slightly higher temperature for creative problem-solving
-            const writeAgents = new Set(["coder", "resolver", "codex", "glm", "gpt-coder"]);
-            if (writeAgents.has(input.agent) && output.temperature === undefined) {
-                output.temperature = 0.5;
-            }
         },
         "tool.definition": async (input, output) => {
+            // Don't pollute tool descriptions for native agents — resolve agents only.
+            if (!isActiveResolve())
+                return;
             const prefix = `[${PLUGIN_BRAND}]`;
             const hintKeys = {
                 edit: "tool.edit",
@@ -292,6 +362,9 @@ export function getHooks(directory, options, sessionState) {
             }
         },
         "command.execute.before": async (_input, output) => {
+            // Only prepend the discipline reminder when a resolve agent drives the turn.
+            if (!isActiveResolve())
+                return;
             // Prepend a discipline reminder to all command executions.
             // The parts array is typed as Part[] — TextPart requires id/sessionID/messageID.
             // We provide placeholder values; OpenCode replaces them if needed.
@@ -300,16 +373,43 @@ export function getHooks(directory, options, sessionState) {
                 sessionID: "",
                 messageID: "",
                 type: "text",
-                text: contextMessage(sessionState.currentAgent, "system.driveResolution"),
+                text: `[${PLUGIN_BRAND}] ${t("system.driveResolution", "en")}`,
             });
         },
         "tool.execute.before": async (input, output) => {
+            // Native agents get unmodified tool execution — resolve agents only.
+            if (!isActiveResolve())
+                return;
             // For bash: inject hints for common mistakes
             if (input.tool === "bash" && output.args && typeof output.args === "object") {
                 const cmd = output.args.command ?? output.args.cmd;
                 if (typeof cmd === "string" && cmd.includes("git commit") && !cmd.includes("-m")) {
                     output.args = { ...output.args, _resolve_hint: "Use 'git commit -m \"message\"' — interactive commit is blocked." };
                 }
+                // Rollback safety net: snapshot the worktree before `git reset --hard` /
+                // `git clean -f` destroys uncommitted work. Runs whenever the command is
+                // about to execute — whether it was un-gated by `permissions.allow*` or
+                // approved by the user at the prompt. If the snapshot cannot be written
+                // in a git repo, abort rather than run the command unprotected.
+                if (typeof cmd === "string") {
+                    const rollback = detectRollbackCommand(cmd);
+                    if (rollback && await isGitRepository(directory)) {
+                        let checkpoint;
+                        try {
+                            checkpoint = await createRollbackCheckpoint(directory, rollback);
+                        }
+                        catch (error) {
+                            throw new Error(`[${PLUGIN_BRAND}] refused to run '${cmd}': could not create a rollback checkpoint (${formatError(error)}). ` +
+                                `Commit or stash your work first.`);
+                        }
+                        narrate(sessionState, "narration.checkpoint");
+                        output.args = {
+                            ...output.args,
+                            _resolve_checkpoint_ref: checkpoint.ref,
+                            _resolve_checkpoint_restore: checkpoint.restoreCommand,
+                        };
+                    }
+                }
             }
             // For write: warn about overwriting existing files
             if (input.tool === "write" && output.args && typeof output.args === "object") {
@@ -331,7 +431,21 @@ export function getHooks(directory, options, sessionState) {
             }
         },
         "tool.execute.after": async (input, output) => {
+            // Only track/count/instrument tool calls driven by resolve agents.
+            if (!isActiveResolve())
+                return;
+            // Count every completed tool call from the reliable tool.execute.after
+            // hook (the message-stream event hook was unreliable + double-counted).
+            sessionState.totalToolCalls++;
+            // Phase 1.0: measure cumulative tool output bytes for token-budget
+            // visibility. Only counts text the resolver actually consumes.
+            const _outText = typeof output?.output === "string" ? output.output
+                : typeof output?.output?.output === "string" ? output.output.output
+                    : typeof output === "string" ? output : "";
+            if (_outText)
+                sessionState.totalOutputBytes += Buffer.byteLength(_outText, "utf8");
             if (input.tool === "edit" || input.tool === "write") {
+                sessionState.totalEdits++;
                 const verifyCommands = sessionState.storedProjectContext?.verifyCommands;
                 const meta = { ...(output.metadata ?? {}) };
                 if (verifyCommands && verifyCommands.length > 0) {
@@ -358,22 +472,69 @@ export function getHooks(directory, options, sessionState) {
                     // Ralph Loop: inject loop warning into metadata
                     const hotspot = sessionState.editHotspots.get(editedPath);
                     if (hotspot && hotspot.count >= EDIT_HOTSPOT_THRESHOLD) {
-                        meta._resolve_loop_warning = `This file has been edited ${hotspot.count} times. Consider a different approach.`;
+                        meta._resolve_loop_warning = hotspotDiffPrompt(editedPath, hotspot.count);
                     }
                 }
                 output.metadata = meta;
+                // Ralph Loop: an edit just happened — mark that verification is now
+                // required before the resolver may report completion. Cleared when a
+                // verify command (typecheck/lint/test) runs via bash. Adaptive: skip
+                // the gate for non-code files (.md/.txt/.json/...) so trivial doc
+                // changes don't force a build/test round-trip.
+                if (isCodeFile(editedPath)) {
+                    sessionState.awaitingVerify = true;
+                    sessionState.awaitingVerifyFile = editedPath;
+                }
                 // Ralph Loop: update sessionState.loopWarnings after every edit/write
                 sessionState.loopWarnings = [];
                 for (const [file, data] of sessionState.editHotspots) {
                     if (data.count >= EDIT_HOTSPOT_THRESHOLD) {
-                        sessionState.loopWarnings.push(`File '${file}' edited ${data.count} times — consider a different approach for this file. Keep iterating.`);
+                        sessionState.loopWarnings.push(hotspotDiffPrompt(file, data.count));
                     }
                 }
             }
             // Role-play narration → terminal only. Does NOT enter LLM context.
             narrateToolEnd(input, output);
+            // Ralph Loop: dispatch lifecycle — track resolver→coder results so the
+            // loop closes. A failed dispatch must trigger diagnosis before retry;
+            // repeated failures escalate (diagnose → STOP → architect pivot).
+            if (input.tool === "task") {
+                const sub = extractSubagentType(input?.args);
+                const failed = dispatchFailed(output);
+                sessionState.lastDispatchAgent = sub;
+                sessionState.lastDispatchSucceeded = !failed;
+                sessionState.lastDispatchAt = Date.now();
+                if (failed) {
+                    sessionState.consecutiveDispatchFailures++;
+                }
+                else {
+                    sessionState.consecutiveDispatchFailures = 0;
+                }
+                // Attach a directive the resolver sees in tool metadata.
+                const dmeta = { ...(output.metadata ?? {}) };
+                const c = sessionState.consecutiveDispatchFailures;
+                if (failed) {
+                    if (c >= DISPATCH_PIVOT_THRESHOLD) {
+                        dmeta._resolve_loop_directive = `Ralph Loop: ${c} consecutive dispatch failures. Dispatch ARCHITECT to rethink the approach.`;
+                    }
+                    else if (c >= DISPATCH_STOP_THRESHOLD) {
+                        dmeta._resolve_loop_directive = `Ralph Loop: ${c} consecutive dispatch failures. STOP — revert the last change and report to the user exactly what is blocked.`;
+                    }
+                    else {
+                        dmeta._resolve_loop_directive = `Ralph Loop: ${sub ?? "subagent"} dispatch failed (${c}x). Diagnose the ROOT CAUSE before re-dispatching. Do NOT retry the same way.`;
+                    }
+                }
+                output.metadata = dmeta;
+            }
             // For bash: extract key error lines from failing commands
             if (input.tool === "bash") {
+                // Ralph Loop: running a verify command clears the awaitingVerify flag —
+                // the resolver has now checked the edit it made.
+                const cmd = input.args?.command ?? input.args?.cmd;
+                if (isVerifyCommand(cmd, sessionState.storedProjectContext?.verifyCommands)) {
+                    sessionState.awaitingVerify = false;
+                    sessionState.awaitingVerifyFile = undefined;
+                }
                 const outputText = typeof output.output === "string" ? output.output
                     : output.output?.output ?? "";
                 const exitCode = output.metadata?.exitCode ?? output.output?.metadata?.exitCode;
@@ -390,15 +551,16 @@ export function getHooks(directory, options, sessionState) {
             }
         },
         "experimental.session.compacting": async (_input, output) => {
+            // Only preserve resolve-loop context; native compaction is untouched.
+            if (!isActiveResolve())
+                return;
             narrate(sessionState, "narration.compacting");
             const ctx = sessionState.storedProjectContext;
             const cfg = sessionState.storedConfig;
             if (!ctx && !cfg)
                 return;
             const contextLines = [];
-            // Profile and tier info
-            if (cfg?.profile)
-                contextLines.push(`Profile: ${cfg.profile}.`);
+            // Tier info
             if (cfg?.tier)
                 contextLines.push(`Tier: ${cfg.tier}.`);
             // Project context
@@ -434,60 +596,50 @@ export function getHooks(directory, options, sessionState) {
             }
         },
         "experimental.chat.messages.transform": async (_input, output) => {
-            const replacements = [
-                // Exact: default OpenCode "continue" prompt
-                ["Summarize the task tool output above and continue with your task.",
-                    "Analyze the subtask result above. If it succeeded, continue. If it failed, diagnose and retry. Report completion only when verified."],
-                // Regex: any "Summarize ... and continue" variant
-                [/Summarize the .+ output above and continue/i,
-                    "Analyze the result above. If it succeeded, continue to the next step. If it failed, diagnose root cause and retry with a fix."],
-                // Regex: generic "continue with your task" ending
-                [/continue with your task\.$/i,
-                    "continue driving toward verified completion."],
-                // Regex: "I've completed..." without verification
-                [/I('ve| have) (completed|finished|done) (the )?.*\.$/i,
-                    "Verify your changes pass typecheck/lint/test before reporting completion."],
-                // Regex: passive "Let me know if..."
-                [/let me know if (you|you'd like) .*/i,
-                    "Proceed with the next step. If blocked, diagnose and report specifically what failed."],
-                // Regex: "Would you like me to..."
-                [/would you like me to .*/i,
-                    "Proceed with the most effective next step autonomously."],
-                // Ralph Loop: detect "I'll try again" — encourage different approach, don't stop
-                [/I('ll| will) (try again|retry|attempt again|redo)/i,
-                    "Diagnose the ROOT CAUSE of the failure, then apply a DIFFERENT fix. The Ralph Loop keeps going."],
-                // Regex: "I'm not sure" — uncertainty without action
-                [/I('m| am) (not sure|unsure|uncertain) .*/i,
-                    "Resolve uncertainty by reading the code, checking diagnostics, or using resolve-search. Keep driving."],
-                // Regex: "This might work" — low confidence
-                [/this (might|should|could|may) work/i,
-                    "CONFIRM it works by running verification. Do not assume."],
-                // Regex: "It seems to be working" — unverified claim
-                [/it (seems|appears|looks) to (be )?(working|fine|correct)/i,
-                    "VERIFY with typecheck/lint/test. 'Seems to work' is not evidence."],
-            ];
+            // Rewrite passive language only within resolve turns — native chat is verbatim.
+            if (!isActiveResolve())
+                return;
             for (const msg of output.messages) {
                 for (const part of msg.parts) {
                     if (part.type !== "text")
                         continue;
-                    for (const [pattern, replacement] of replacements) {
-                        if (typeof pattern === "string" ? part.text === pattern : pattern.test(part.text)) {
-                            part.text = replacement;
-                            break; // first match wins
-                        }
+                    // Preserve collaborative handoffs/questions — never touch a turn that
+                    // asks the user something.
+                    if (HANDOFF_PATTERNS.some((p) => p.test(part.text.trim())))
+                        continue;
+                    const boilerplate = HARNESS_BOILERPLATE_REWRITES.find(([pattern]) => typeof pattern === "string" ? part.text === pattern : pattern.test(part.text));
+                    if (boilerplate) {
+                        part.text = boilerplate[1];
+                        continue;
                     }
+                    // transform() sees the whole message list every turn, so an appended
+                    // nudge would compound. One nudge per part, ever.
+                    if (part.text.includes(NUDGE_MARKER))
+                        continue;
+                    const nudge = SELF_REVIEW_NUDGES.find(([pattern]) => pattern.test(part.text));
+                    if (nudge)
+                        part.text = `${part.text}\n\n${NUDGE_MARKER} ${nudge[1]}`;
                 }
             }
         },
         "experimental.compaction.autocontinue": async (_input, output) => {
+            // Only force auto-continue for resolve agents — native agents keep their own cadence.
+            if (!isActiveResolve())
+                return;
             // Always enable auto-continue — the resolver should keep driving
             output.enabled = true;
         },
         "experimental.chat.system.transform": async (_input, output) => {
+            // Inject system context/warnings only into resolve-agent turns — native
+            // agents (build/plan/default chat) get their own system prompt untouched.
+            if (!isActiveResolve())
+                return;
             const ctx = sessionState.storedProjectContext;
             const hasFailures = sessionState.failureWarnings.length > 0;
             const hasLoops = sessionState.loopWarnings.length > 0;
-            if (!ctx && !hasFailures && !hasLoops)
+            const hasDispatchFailures = sessionState.consecutiveDispatchFailures > 0;
+            const needsVerify = sessionState.awaitingVerify;
+            if (!ctx && !hasFailures && !hasLoops && !hasDispatchFailures && !needsVerify)
                 return;
             const lines = [];
             const agent = sessionState.currentAgent;
@@ -524,7 +676,10 @@ export function getHooks(directory, options, sessionState) {
                 for (const w of sessionState.loopWarnings.slice(0, 3)) {
                     lines.push(`  - ${w}`);
                 }
+                // Self-observation first — reading your own diff is the cheapest way out
+                // of a hotspot, and the only one that cannot pollute an unrelated file.
                 const strategyKeys = [
+                    "strategy.reviewDiff",
                     "strategy.rereadFile",
                     "strategy.tryDifferent",
                     "strategy.useDiagnostics",
@@ -552,11 +707,37 @@ export function getHooks(directory, options, sessionState) {
                 }));
                 lines.push(t("system.iterationWarning", "en"));
             }
+            // Ralph Loop: enforced loop closure — dispatch lifecycle escalation.
+            // 1-2 failures: diagnose + retry. 3: STOP. 6+: architect pivot.
+            const dc = sessionState.consecutiveDispatchFailures;
+            if (dc > 0) {
+                if (dc >= DISPATCH_PIVOT_THRESHOLD) {
+                    lines.push(contextMessage(agent, "system.dispatchPivot"));
+                }
+                else if (dc >= DISPATCH_STOP_THRESHOLD) {
+                    lines.push(contextMessage(agent, "system.dispatchStop", { count: dc }));
+                }
+                else {
+                    lines.push(contextMessage(agent, "system.dispatchEscalate", {
+                        count: dc,
+                        agent: sessionState.lastDispatchAgent ?? "subagent",
+                    }));
+                }
+            }
+            // Ralph Loop: a pending edit MUST be verified before reporting done.
+            if (sessionState.awaitingVerify) {
+                lines.push(contextMessage(agent, "system.awaitingVerify", {
+                    file: sessionState.awaitingVerifyFile ?? "",
+                }));
+            }
             if (lines.length > 0) {
-                output.system.push(lines.join("\n"));
+                output.system.push(`${brand(undefined)}\n${lines.join("\n")}`);
             }
         },
         "experimental.text.complete": async (_input, output) => {
+            // Append verify reminders only to resolve-agent completions — native output is verbatim.
+            if (!isActiveResolve())
+                return;
             const text = output.text ?? "";
             if (!text)
                 return;

package/dist/index.d.ts

@@ -5,4 +5,8 @@ export * from "./config.js";
 export * from "./state.js";
 import type { Plugin } from "@opencode-ai/plugin";
 export declare const OpencodeResolve: Plugin;
-export default OpencodeResolve;
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/index.js

@@ -24,4 +24,7 @@ export const OpencodeResolve = async ({ directory }, options) => {
         tool: getTools(sessionState)
     };
 };
-export default OpencodeResolve;
+// V1 plugin format — avoids opencode's legacy getLegacyPlugins fallback path,
+// which iterates Object.values(mod) and throws on non-function exports
+// (DEFAULT_MODELS, VALID_MODES, PLUGIN_VERSION, etc. from the re-exports above).
+export default { id: "opencode-resolve", server: OpencodeResolve };

package/dist/messages.d.ts

@@ -6,7 +6,7 @@ export declare function resolveLocale(configured: string | undefined, envLang: s
 export declare function brand(agent: string | undefined): string;
 /** Friendly display name per agent (used in role-play narration). */
 export declare function agentDisplayName(agent: string | undefined, locale: Locale): string;
-export type MessageKey = "reminder.verify" | "reminder.ralphLoopText" | "system.driveResolution" | "system.projectKnowledge" | "system.contextDocs" | "system.verifyCommands" | "system.typescriptMandatory" | "system.failuresHeader" | "system.failuresFooter" | "system.strategyPivotHeader" | "system.strategyPivotBody" | "system.strategyPivotTail" | "system.ralphHeader" | "system.ralphKeepGoing" | "system.sessionStats" | "system.iterationWarning" | "compaction.contextHeader" | "tool.edit" | "tool.write" | "tool.bash" | "tool.task" | "tool.glob" | "tool.grep" | "tool.read" | "tool.webfetch" | "tool.todowrite" | "dispatch.toSubagent" | "dispatch.fromResolver" | "dispatch.coder" | "dispatch.reviewer" | "dispatch.deepReviewer" | "dispatch.explorer" | "dispatch.planner" | "dispatch.architect" | "dispatch.researcher" | "dispatch.debugger" | "dispatch.codex" | "dispatch.glm" | "dispatch.gpt" | "dispatch.gptCoder" | "dispatch.completed" | "dispatch.failed" | "narration.editing" | "narration.searching" | "narration.reading" | "narration.thinking" | "narration.bashing" | "narration.compacting" | "narration.writing" | "narration.testing" | "narration.typechecking" | "narration.linting" | "narration.git" | "narration.fetch" | "narration.todo" | "narration.diagnostics" | "narration.context" | "narration.verifyPass" | "narration.verifyFail" | "narration.idle" | "strategy.smallerPieces" | "strategy.differentFile" | "strategy.readTest" | "strategy.checkImports" | "strategy.searchSimilar" | "strategy.rereadFile" | "strategy.tryDifferent" | "strategy.useDiagnostics" | "strategy.suggestionLabel";
+export type MessageKey = "reminder.verify" | "reminder.ralphLoopText" | "system.driveResolution" | "system.projectKnowledge" | "system.contextDocs" | "system.verifyCommands" | "system.typescriptMandatory" | "system.failuresHeader" | "system.failuresFooter" | "system.strategyPivotHeader" | "system.strategyPivotBody" | "system.strategyPivotTail" | "system.ralphHeader" | "system.ralphKeepGoing" | "system.sessionStats" | "system.iterationWarning" | "system.dispatchEscalate" | "system.dispatchStop" | "system.dispatchPivot" | "system.awaitingVerify" | "compaction.contextHeader" | "tool.edit" | "tool.write" | "tool.bash" | "tool.task" | "tool.glob" | "tool.grep" | "tool.read" | "tool.webfetch" | "tool.todowrite" | "dispatch.toSubagent" | "dispatch.fromResolver" | "dispatch.coder" | "dispatch.reviewer" | "dispatch.deepReviewer" | "dispatch.explorer" | "dispatch.planner" | "dispatch.architect" | "dispatch.researcher" | "dispatch.debugger" | "dispatch.completed" | "dispatch.failed" | "narration.editing" | "narration.searching" | "narration.reading" | "narration.thinking" | "narration.bashing" | "narration.compacting" | "narration.writing" | "narration.testing" | "narration.typechecking" | "narration.linting" | "narration.git" | "narration.checkpoint" | "narration.fetch" | "narration.todo" | "narration.diagnostics" | "narration.context" | "narration.verifyPass" | "narration.verifyFail" | "narration.idle" | "strategy.smallerPieces" | "strategy.differentFile" | "strategy.readTest" | "strategy.checkImports" | "strategy.searchSimilar" | "strategy.rereadFile" | "strategy.tryDifferent" | "strategy.useDiagnostics" | "strategy.reviewDiff" | "strategy.suggestionLabel";
 type Params = Record<string, string | number>;
 /** Render a message in the requested locale. Picks a random variant if multiple are defined. */
 export declare function t(key: MessageKey, locale: Locale, params?: Params): string;