opencode-resolve 0.1.20 → 0.3.0

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;
@@ -79,10 +71,14 @@ const MESSAGES = {
         "system.strategyPivotHeader": ({ count }) => `🔀 STRATEGY PIVOT: ${count} total failures detected.`,
         "system.strategyPivotBody": "The current approach is not working. Dispatch ARCHITECT to analyze the problem from scratch and propose a fundamentally different strategy.",
         "system.strategyPivotTail": "Then apply the new strategy. Do NOT keep retrying the same approach.",
-        "system.ralphHeader": "🔄 Ralph Loop: heavy editing detected on same file(s):",
-        "system.ralphKeepGoing": "Keep driving — the Ralph Loop should keep iterating until verified resolution.",
+        "system.ralphHeader": "🔄 Ralph Loop: heavy editing detected on same file(s). Repetition is not itself the problem — repeating the *same* edit is:",
+        "system.ralphKeepGoing": "Read the diff before the next edit. If the root cause really is in this file, stay here — moving to an unrelated file to break the count only spreads the damage. Keep driving until verified.",
         "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`,
@@ -369,6 +345,11 @@ const MESSAGES = {
             "🌳 inspecting the diff",
             "🌳 listening to git",
         ],
+        "narration.checkpoint": [
+            "🛟 snapshotting the worktree before rollback",
+            "🛟 saving a checkpoint you can restore from",
+            "🛟 stashing a safety copy first",
+        ],
         "narration.fetch": [
             "🌐 fetching from the web",
             "🌐 grabbing the docs",
@@ -426,13 +407,14 @@ const MESSAGES = {
             "🪑 brief regroup",
         ],
         "strategy.smallerPieces": "Break the problem into smaller pieces. Edit one function at a time, verify between each.",
-        "strategy.differentFile": "Check if the error is actually in a DIFFERENT file — the real issue may be upstream.",
+        "strategy.differentFile": "Follow the evidence: if diagnostics point at a different file, the real cause may be upstream. Confirm that before editing anything else.",
         "strategy.readTest": "Read the test file if it exists — the test often reveals the expected behavior.",
         "strategy.checkImports": "Check imports — missing or wrong imports are a common cause of cascading errors.",
         "strategy.searchSimilar": "Use resolve-search to find similar patterns elsewhere in the codebase.",
         "strategy.rereadFile": "Re-read the file carefully. You may be missing existing code that conflicts with your edit.",
-        "strategy.tryDifferent": "Try a completely different approach — revert your last change and try a different fix.",
+        "strategy.tryDifferent": "The fix, not the file, is what should change. Try a different fix for the same root cause.",
         "strategy.useDiagnostics": "Use resolve-diagnostics to check current LSP errors before the next edit.",
+        "strategy.reviewDiff": "Run `git diff` on the hotspot file. Look for edits that repeat the same substitution or cancel each other out.",
         "strategy.suggestionLabel": "Strategy suggestion",
     },
     ko: {
@@ -459,10 +441,14 @@ const MESSAGES = {
         "system.strategyPivotHeader": ({ count }) => `🔀 전략 전환: 총 ${count}회의 실패가 감지됐어요.`,
         "system.strategyPivotBody": "지금 접근은 통하지 않아요. ARCHITECT 를 위임해서 문제를 처음부터 분석하고 근본적으로 다른 전략을 제안받으세요.",
         "system.strategyPivotTail": "그 다음 새 전략을 적용하세요. 같은 접근을 다시 시도하지 마세요.",
-        "system.ralphHeader": "🔄 Ralph Loop: 같은 파일을 너무 자주 수정 중이에요:",
-        "system.ralphKeepGoing": "계속 진행하세요 — Ralph Loop 는 검증된 해결이 나올 때까지 반복합니다.",
+        "system.ralphHeader": "🔄 Ralph Loop: 같은 파일을 반복 수정 중이에요. 반복 자체가 문제가 아니라, *같은 수정* 을 반복하는 게 문제입니다:",
+        "system.ralphKeepGoing": "다음 편집 전에 diff 를 읽으세요. 근본 원인이 정말 이 파일에 있다면 계속 여기서 작업하세요 — 횟수를 피하려고 무관한 파일로 옮겨가면 오염만 번집니다. 검증될 때까지 계속.",
         "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 +546,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} 보고 도착 — 리졸버가 이어 받음`,
@@ -762,6 +728,11 @@ const MESSAGES = {
             "🌳 diff 점검 중",
             "🌳 git 말 듣는 중",
         ],
+        "narration.checkpoint": [
+            "🛟 롤백 전에 작업트리 스냅샷 뜨는 중",
+            "🛟 복구용 체크포인트 저장 중",
+            "🛟 만약을 위해 안전 사본 남기는 중",
+        ],
         "narration.fetch": [
             "🌐 웹에서 가져오는 중",
             "🌐 문서 끌어오는 중",
@@ -819,13 +790,14 @@ const MESSAGES = {
             "🪑 잠깐 정비",
         ],
         "strategy.smallerPieces": "문제를 더 작은 단위로 쪼개세요. 한 번에 함수 하나씩 편집하고, 각 사이에 검증하세요.",
-        "strategy.differentFile": "에러가 실제로는 다른 파일에 있는지 확인하세요 — 진짜 원인은 상류일 수 있습니다.",
+        "strategy.differentFile": "증거를 따라가세요: 진단이 다른 파일을 가리킨다면 진짜 원인은 상류일 수 있습니다. 다른 파일을 건드리기 전에 먼저 확인하세요.",
         "strategy.readTest": "테스트 파일이 있으면 먼저 읽으세요 — 기대 동작이 거기에 드러나 있을 때가 많습니다.",
         "strategy.checkImports": "import 를 확인하세요 — 누락되거나 잘못된 import 가 연쇄 에러의 흔한 원인입니다.",
         "strategy.searchSimilar": "resolve-search 로 코드베이스 내 유사 패턴을 찾으세요.",
         "strategy.rereadFile": "파일을 다시 차분히 읽으세요. 편집과 충돌하는 기존 코드를 놓쳤을 수 있습니다.",
-        "strategy.tryDifferent": "완전히 다른 접근을 시도하세요 — 마지막 변경을 되돌리고 다른 방법으로 고치세요.",
+        "strategy.tryDifferent": "바꿔야 할 건 파일이 아니라 해법입니다. 같은 근본 원인에 대해 다른 수정을 시도하세요.",
         "strategy.useDiagnostics": "다음 편집 전에 resolve-diagnostics 로 현재 LSP 에러를 확인하세요.",
+        "strategy.reviewDiff": "핫스팟 파일에 `git diff` 를 실행하세요. 같은 치환을 반복했거나 서로 상쇄되는 편집이 있는지 확인하세요.",
         "strategy.suggestionLabel": "전략 제안",
     },
 };

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);
 }
@@ -15,6 +15,10 @@ function readOnlyToolWriteDenied(ctx, action) {
     return `Permission denied: agent '${ctx.agent ?? "unknown"}' is read-only and cannot ${action}. Dispatch resolver/coder for workspace writes.`;
 }
 function commandExecutionDenied(command) {
+    // Deliberately called without `permissions` — this path executes directly and
+    // never reaches `tool.execute.before`, so a rollback here would run without a
+    // checkpoint. `permissions.allowGitReset`/`allowGitClean` only relax the
+    // OpenCode bash tool, which is checkpointed.
     const action = classifyBashCommand(command);
     if (action === "allow")
         return undefined;
@@ -23,6 +27,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 +111,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 +266,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 +305,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 +574,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 +1018,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 +1030,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 +1063,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 +1165,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 +1302,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,29 @@ export type ResolveAgentConfig = {
         external_directory?: PermissionValue;
     };
 };
-export type ProfileName = "mix" | "glm" | "gpt";
 export type TierName = "bronze" | "silver" | "gold";
 export type LanguageSetting = "auto" | "en" | "ko";
+/** Opt-in relaxations of the universal bash safety policy. Off by default. */
+export type ResolvePermissions = {
+    /** Let resolve agents run `git reset --hard` (a checkpoint ref is written first). */
+    allowGitReset?: boolean;
+    /** Let resolve agents run `git clean -f...` (a checkpoint ref is written first). */
+    allowGitClean?: boolean;
+};
+export type RollbackKind = "reset" | "clean";
 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;
+    permissions?: ResolvePermissions;
 };
 export type ResolvePluginOptions = ResolveConfig & {
     config?: string;

package/dist/utils.d.ts

@@ -1,8 +1,5 @@
-import { ProjectContext, ResolveConfig } from "./types.js";
+import { ProjectContext, ResolveConfig, ResolvePermissions, RollbackKind } 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;
@@ -13,20 +10,23 @@ export declare function truncateOutput(text: string, maxLen: number): string;
 export declare function sanitizeShellArg(input: string): string;
 export declare function isMissingFileError(error: unknown): boolean;
 export declare function formatError(error: unknown): string;
-export declare function classifyBashCommand(pattern: string): "allow" | "deny" | "ask";
+/**
+ * Which rollback command, if any, this bash line runs. Both are destructive and
+ * denied by default; `permissions.allowGitReset` / `allowGitClean` un-gate them,
+ * and the caller writes a checkpoint ref before execution.
+ */
+export declare function detectRollbackCommand(pattern: string): RollbackKind | undefined;
+export declare function classifyBashCommand(pattern: string, permissions?: ResolvePermissions): "allow" | "deny" | "ask";
 export declare function existsFile(path: string): Promise<boolean>;
 export declare function existsPath(path: string): Promise<boolean>;
 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 GIT_HARD_RESET_PATTERN: RegExp;
+export declare const GIT_FORCE_CLEAN_PATTERN: RegExp;
+export declare const GIT_CLEAN_IGNORED_PATTERN: RegExp;
 export declare const BANNED_COMMANDS: ReadonlyArray<RegExp>;
 export declare const DANGEROUS_BASH_PATTERNS: ReadonlyArray<RegExp>;
 export declare const ALWAYS_SAFE_COMMANDS: ReadonlyArray<string>;