opencode-resolve 0.1.20 → 0.2.0

package/dist/hooks/index.js

@@ -1,7 +1,42 @@
-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, detectProjectContext } from "../utils.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());
+}
 function capTemperature(current, cap) {
     return typeof current === "number" && Number.isFinite(current)
         ? Math.min(current, cap)
@@ -16,10 +51,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 +67,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 +128,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 +144,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 +194,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 +225,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 +233,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",
@@ -235,43 +263,43 @@ export function getHooks(directory, options, sessionState) {
                         ? input.pattern.join(" ")
                         : "";
                 const action = classifyBashCommand(cmd);
-                if (action !== "ask")
-                    output.status = action;
+                // 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 +320,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,10 +331,13 @@ 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;
@@ -331,7 +365,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) {
@@ -362,6 +410,15 @@ export function getHooks(directory, options, sessionState) {
                     }
                 }
                 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) {
@@ -372,8 +429,46 @@ export function getHooks(directory, options, sessionState) {
             }
             // 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 +485,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,6 +530,9 @@ export function getHooks(directory, options, sessionState) {
             }
         },
         "experimental.chat.messages.transform": async (_input, output) => {
+            // Rewrite passive language only within resolve turns — native chat is verbatim.
+            if (!isActiveResolve())
+                return;
             const replacements = [
                 // Exact: default OpenCode "continue" prompt
                 ["Summarize the task tool output above and continue with your task.",
@@ -447,12 +546,6 @@ export function getHooks(directory, options, sessionState) {
                 // 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."],
@@ -470,6 +563,11 @@ export function getHooks(directory, options, sessionState) {
                 for (const part of msg.parts) {
                     if (part.type !== "text")
                         continue;
+                    // Preserve collaborative handoffs/questions — never rewrite a turn
+                    // that asks the user something. Only rewrite passive/stalled claims
+                    // ("this might work", "seems fine", unverified "completed", ...).
+                    if (HANDOFF_PATTERNS.some((p) => p.test(part.text.trim())))
+                        continue;
                     for (const [pattern, replacement] of replacements) {
                         if (typeof pattern === "string" ? part.text === pattern : pattern.test(part.text)) {
                             part.text = replacement;
@@ -480,14 +578,23 @@ export function getHooks(directory, options, sessionState) {
             }
         },
         "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;
@@ -552,11 +659,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.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";
 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;

package/dist/messages.js

@@ -39,10 +39,6 @@ const AGENT_DISPLAY = {
         architect: "architect",
         researcher: "researcher",
         debugger: "debugger",
-        codex: "codex",
-        glm: "glm",
-        gpt: "gpt",
-        "gpt-coder": "gpt-coder",
     },
     ko: {
         resolver: "리졸버",
@@ -54,10 +50,6 @@ const AGENT_DISPLAY = {
         architect: "아키텍트",
         researcher: "리서처",
         debugger: "디버거",
-        codex: "코덱스",
-        glm: "GLM",
-        gpt: "GPT",
-        "gpt-coder": "GPT 코더",
     },
 };
 let variantCounter = 0;
@@ -83,6 +75,10 @@ const MESSAGES = {
         "system.ralphKeepGoing": "Keep driving — the Ralph Loop should keep iterating until verified resolution.",
         "system.sessionStats": ({ edits, calls, elapsed }) => `📊 Session stats: ${edits} edits, ${calls} tool calls, ${elapsed}s elapsed.`,
         "system.iterationWarning": "Significant iteration with failures. Consider a fundamentally different approach — but keep going.",
+        "system.dispatchEscalate": ({ count, agent }) => `🔄 Ralph Loop: ${agent ?? "subagent"} dispatch failed ${count} time(s) in a row. Do NOT retry the same way. Diagnose the ROOT CAUSE first (read the error, use resolve-diagnostics), then re-dispatch with a precise fix.`,
+        "system.dispatchStop": ({ count }) => `🛑 Ralph Loop: ${count} consecutive dispatch failures. STOP now — revert your last change or restore a safe state, then report to the user EXACTLY what is blocked. Do not keep retrying.`,
+        "system.dispatchPivot": "🔀 STRATEGY PIVOT: repeated dispatch failure on the same task. Dispatch ARCHITECT to design a fundamentally different approach before continuing.",
+        "system.awaitingVerify": ({ file }) => `⏳ Awaiting verification: ${file ?? "the file you just edited"} has NOT been verified yet. Run typecheck/lint/test before reporting completion. NO EVIDENCE = NOT COMPLETE.`,
         "compaction.contextHeader": ({ body }) => `Project context (preserve): ${body}`,
         "tool.edit": "Read the file first. Make the smallest correct change. Verify after editing.",
         "tool.write": "Only write new files when explicitly needed. Prefer editing existing files.",
@@ -178,26 +174,6 @@ const MESSAGES = {
             ({ goal }) => goal ? `🪤 debugger setting a trap for "${goal}"` : "🪤 debugger setting a trap",
             ({ goal }) => goal ? `🧪 debugger isolating ${goal} in a minimal repro` : "🧪 debugger isolating the failure",
         ],
-        "dispatch.codex": [
-            ({ goal }) => goal ? `🧠 codex tackles ${goal}` : "🧠 codex tackles a hard reasoning task",
-            ({ goal }) => goal ? `🧠 codex chewing on "${goal}"` : "🧠 codex chewing on a thorny piece",
-            ({ goal }) => goal ? `📚 codex consults its tomes for ${goal}` : "📚 codex consults its tomes",
-        ],
-        "dispatch.glm": [
-            ({ goal }) => goal ? `⚡ glm handles ${goal}` : "⚡ glm handles the next slice",
-            ({ goal }) => goal ? `⚡ glm sprinting through "${goal}"` : "⚡ glm sprinting through the next slice",
-            ({ goal }) => goal ? `🐎 glm fast lane on ${goal}` : "🐎 glm fast lane",
-        ],
-        "dispatch.gpt": [
-            ({ goal }) => goal ? `🚀 gpt drives ${goal}` : "🚀 gpt drives the next slice",
-            ({ goal }) => goal ? `🚀 gpt boosting through "${goal}"` : "🚀 gpt boosting through",
-            ({ goal }) => goal ? `🎯 gpt locked on ${goal}` : "🎯 gpt locked on the target",
-        ],
-        "dispatch.gptCoder": [
-            ({ goal }) => goal ? `🧠 gpt-coder handles a tough patch: ${goal}` : "🧠 gpt-coder handles a tough patch",
-            ({ goal }) => goal ? `🧠 gpt-coder taking the hard one — ${goal}` : "🧠 gpt-coder taking the hard one",
-            ({ goal }) => goal ? `🛠 gpt-coder splicing the gnarly part of "${goal}"` : "🛠 gpt-coder splicing the gnarly part",
-        ],
         "dispatch.completed": [
             ({ to }) => `✅ ${to} done — control back to resolver`,
             ({ to }) => `✅ ${to} reported back — resolver resumes`,
@@ -463,6 +439,10 @@ const MESSAGES = {
         "system.ralphKeepGoing": "계속 진행하세요 — Ralph Loop 는 검증된 해결이 나올 때까지 반복합니다.",
         "system.sessionStats": ({ edits, calls, elapsed }) => `📊 세션 통계: ${edits}회 편집, ${calls}회 도구 호출, ${elapsed}초 경과.`,
         "system.iterationWarning": "실패와 함께 반복이 많아졌어요. 근본적으로 다른 접근을 고려하세요 — 하지만 멈추지는 마세요.",
+        "system.dispatchEscalate": ({ count, agent }) => `🔄 Ralph Loop: 서브에이전트(${agent ?? "subagent"})가 ${count}회 연속 실패했습니다. 같은 방식으로 재시도 금지. 먼저 루트 코즈를 진단하고, 정확한 수정으로 다시 위임하세요.`,
+        "system.dispatchStop": ({ count }) => `🛑 Ralph Loop: ${count}회 연속 dispatch 실패. 여기서 멈추고, 마지막 변경을 되돌리거나 안전 상태로 복구한 뒤, 구체적으로 무엇이 막혔는지 사용자에게 보고하세요.`,
+        "system.dispatchPivot": "🔀 전략 전환: 같은 작업의 dispatch 반복 실패. ARCHITECT 를 위임해 근본적으로 다른 접근을 설계받으세요.",
+        "system.awaitingVerify": ({ file }) => `⏳ 검증 대기: ${file ?? "방금 편집한 파일"} 이(가) 아직 검증되지 않았습니다. 완료 보고 전에 반드시 typecheck/lint/test 를 실행하세요. NO EVIDENCE = NOT COMPLETE.`,
         "compaction.contextHeader": ({ body }) => `프로젝트 컨텍스트 (보존): ${body}`,
         "tool.edit": "먼저 파일을 읽으세요. 가장 작은 정확한 변경을 만드세요. 편집 후 검증하세요.",
         "tool.write": "명시적으로 필요할 때만 새 파일을 만드세요. 기존 파일 편집을 우선합니다.",
@@ -560,26 +540,6 @@ const MESSAGES = {
             ({ goal }) => goal ? `🪤 디버거가 "${goal}" 함정 설치 중` : "🪤 디버거가 함정을 설치하는 중",
             ({ goal }) => goal ? `🧪 디버거가 ${goal} 를 최소 재현으로 격리` : "🧪 디버거가 최소 재현으로 격리 중",
         ],
-        "dispatch.codex": [
-            ({ goal }) => goal ? `🧠 코덱스가 ${goal} 처리` : "🧠 코덱스가 까다로운 추론 작업을 받습니다",
-            ({ goal }) => goal ? `🧠 코덱스가 "${goal}" 를 곱씹는 중` : "🧠 코덱스가 까다로운 부분을 곱씹는 중",
-            ({ goal }) => goal ? `📚 코덱스가 ${goal} 의 비전을 들춰보는 중` : "📚 코덱스가 비전을 들춰보는 중",
-        ],
-        "dispatch.glm": [
-            ({ goal }) => goal ? `⚡ GLM 이 ${goal} 처리` : "⚡ GLM 이 다음 슬라이스를 처리합니다",
-            ({ goal }) => goal ? `⚡ GLM 이 "${goal}" 를 빠르게 통과 중` : "⚡ GLM 이 다음 슬라이스를 빠르게 통과 중",
-            ({ goal }) => goal ? `🐎 GLM 패스트레인 — ${goal}` : "🐎 GLM 패스트레인",
-        ],
-        "dispatch.gpt": [
-            ({ goal }) => goal ? `🚀 GPT 가 ${goal} 진행` : "🚀 GPT 가 다음 슬라이스를 끌고 갑니다",
-            ({ goal }) => goal ? `🚀 GPT 가 "${goal}" 부스팅` : "🚀 GPT 가 부스팅 중",
-            ({ goal }) => goal ? `🎯 GPT 가 ${goal} 에 락온` : "🎯 GPT 가 타겟에 락온",
-        ],
-        "dispatch.gptCoder": [
-            ({ goal }) => goal ? `🧠 GPT 코더가 까다로운 패치: ${goal}` : "🧠 GPT 코더가 까다로운 패치를 받습니다",
-            ({ goal }) => goal ? `🧠 GPT 코더가 어려운 거 — ${goal}` : "🧠 GPT 코더가 어려운 거 맡습니다",
-            ({ goal }) => goal ? `🛠 GPT 코더가 "${goal}" 의 까다로운 부분을 봉합` : "🛠 GPT 코더가 까다로운 부분을 봉합 중",
-        ],
         "dispatch.completed": [
             ({ to }) => `✅ ${to} 완료 — 리졸버에게 제어 반환`,
             ({ to }) => `✅ ${to} 보고 도착 — 리졸버가 이어 받음`,