@siuver/omp-debug-mode 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.2 - 2026-08-20
+
+- Added an interactive round-review menu with Mark as fixed, Proceed, Add reproduction details, and Abort actions.
+- Added `/debug-review` to reopen the menu and `/debug-note <details>` to return to the editor, add user evidence, and continue the workflow.
+- Kept `/debug-done fixed|proceed` as compatible shortcuts and added interactive confirmation for zero-log completion, zero-log progression, and abort.
+
 ## 0.1.1 - 2026-08-20
 
 - Replaced the localhost HTTP collector with direct JSONL file appends from instrumented runtime code.

package/README.md

@@ -9,20 +9,32 @@ The plugin makes the agent form hypotheses, add temporary runtime probes, attemp
 | Command | Purpose |
 | --- | --- |
 | `/debug-mode <problem>` | Starts a debugging session from a symptom, expected result, actual result, and reproduction description. |
+| `/debug-review` | Reopens the interactive action menu for the completed round. |
+| `/debug-note <details>` | Adds reproduction details from the editor and starts the next evidence-driven round. |
 | `/debug-status` | Shows the current phase, round, run, live probes, and captured log counts. |
-| `/debug-done fixed` | Confirms the fix and asks the agent to remove every probe and summarize the root cause and final change. |
-| `/debug-done proceed` | Reports that the issue remains, asks the agent to analyze the captured logs, and starts another hypothesis/instrument/fix round. |
-| `/debug-abort` | Stops debug mode and removes its logs while leaving code changes in the working tree. |
+| `/debug-done fixed` | Non-menu shortcut that confirms the fix and asks the agent to remove every probe and summarize the result. |
+| `/debug-done proceed` | Non-menu shortcut that analyzes the captured logs and starts another hypothesis/instrument/fix round. |
+| `/debug-abort` | Stops debug mode and removes its logs after confirmation while leaving code changes in the working tree. |
+
+## Interactive Round Review
+
+When the Agent completes a debugging round, the plugin enters the reproduction gate and opens an action menu:
+
+- **Mark as fixed** - asks the Agent to clean up probes and summarize the root cause and fix. If the round captured no runtime logs, the plugin asks for confirmation first.
+- **Proceed with captured logs** - refreshes the log file at selection time, archives the completed run, and starts the next analysis and fix round. If no runtime observations exist, the plugin asks for confirmation before proceeding.
+- **Add reproduction details** - closes the menu and pre-fills the editor with `/debug-note ` so you can add symptoms, environment details, or reproduction results before continuing.
+- **Abort debug mode** - asks for confirmation, removes debug logs, and keeps applied code changes.
+
+Pressing `Esc` simply closes the menu and leaves the workflow at the reproduction gate. After reproducing the issue in another application, run `/debug-review` to reopen it. The existing `/debug-done fixed|proceed` commands remain available for non-interactive and shortcut use.
 
 ## Workflow
 
 1. Run `/debug-mode <problem description>`.
-2. The agent investigates, records hypotheses, inserts minimal probes marked with `@omp-probe <id>`, and attempts a fix. Each probe appends its runtime observation directly to the exact JSONL file provided in the injected prompt.
-3. When the agent stops, reproduce the issue in the real application so the instrumented code writes its observations.
-4. Run `/debug-done fixed` if the issue is resolved, or `/debug-done proceed` to make the agent read the completed run's JSONL file, analyze the evidence, and continue.
-5. On success, the agent removes all probes, verifies the probe ledger is empty, and summarizes the root cause and fix.
+2. The Agent investigates, records hypotheses, inserts minimal probes marked with `@omp-probe <id>`, and attempts a fix. The injected prompt strongly requires every probe to append runtime observations directly to the exact JSONL path; console output is supplemental only.
+3. When the Agent stops, dismiss the review menu if necessary and reproduce the issue in the real application so the instrumented code writes its observations.
+4. Reopen `/debug-review` and mark the issue fixed, proceed with logs, or return to the editor to submit `/debug-note <details>`.
 
-The extension also provides the read-only `get_debug_logs` and `list_debug_probes` tools so the agent can inspect runtime evidence and verify cleanup.
+The extension also provides the read-only `get_debug_logs` and `list_debug_probes` tools so the Agent can inspect runtime evidence and verify cleanup.
 
 ## Runtime Data
 
@@ -38,9 +50,9 @@ That exact stable path is injected into the Agent prompt. The prompt requires ev
 {"probe":"player-state","ts":1787193600000,"data":{"isGrounded":false}}
 ```
 
-Probes append directly to `current.jsonl`; they must not overwrite it, and they should flush and close the file promptly rather than retaining an exclusive handle. The stable filename means probes retained across rounds continue writing to the correct place without being rewritten just to change a path. The mechanism does not use HTTP, localhost, sockets, or any other network transport, so environments such as the Unity Editor can use their normal filesystem APIs. The target process still needs permission to access the displayed absolute path.
+If the log file contains zero entries, treat that as instrumentation or execution-path evidence. Check the build, path permissions, code path, and file append errors; do not ask the user to copy Unity Console output. Use `/debug-note` for reproduction details, not manual console transcription.
 
-When you run `/debug-done proceed`, the plugin archives the completed file as `<run-id>.jsonl`, creates an empty `current.jsonl` for the next reproduction, and makes the Agent analyze the archived evidence through `get_debug_logs`. `/debug-status` shows the current absolute file path and log count.
+When you proceed from the review menu, `/debug-done proceed`, or `/debug-note`, the plugin archives the completed file as `<run-id>.jsonl`, creates an empty `current.jsonl` for the next reproduction, and makes the Agent analyze the archived evidence through `get_debug_logs`. `/debug-status` shows the current absolute file path and log count.
 
 ## Install
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siuver/omp-debug-mode",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "A Cursor Debug Mode replica for evidence-driven, human-in-the-loop debugging in oh-my-pi.",
   "license": "MIT",

package/src/main.ts

@@ -5,26 +5,27 @@
  *   IDLE → /debug-mode <problem>
  *   → agent hypothesizes, adds @omp-probe instrumentation, attempts a fix
  *   → WAITING_REPRO: agent stops; user reproduces out-of-band
- *   → /debug-done fixed   → agent removes probes + summarizes → teardown (logs deleted)
- *   → /debug-done proceed → agent analyzes captured logs, re-instruments + fixes → loop
+ *   → Mark as fixed → agent removes probes + summarizes → teardown (logs deleted)
+ *   → Proceed/add details → agent analyzes logs, re-instruments + fixes → loop
  *
  * - Stable JSONL file at <cwd>/.omp/debug/current.jsonl — runtime probes append
  *   observations directly with the target environment's native file APIs
  * - Probe ledger: tool_call interception on edit/write records @omp-probe ids;
  *   ground truth is rescanned from disk (checkLedger)
  * - Tools: get_debug_logs, list_debug_probes
- * - Commands: /debug-mode, /debug-status, /debug-done fixed|proceed, /debug-abort
+ * - Commands: /debug-mode, /debug-review, /debug-note, /debug-status, /debug-done, /debug-abort
  */
 import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { ACTIVE_LOG_FILE, prepareRunLog, readJsonlLines, resolveRunLogFile } from "./log-files";
+import { REVIEW_ABORT, REVIEW_ADD_DETAILS, REVIEW_MARK_FIXED, REVIEW_OPTIONS, REVIEW_PROCEED } from "./review-actions";
 
 const DEBUG_ENTRY = "com.omp.debug-mode.state";
 const PROBE_MARK = /@omp-probe\s+([A-Za-z0-9_-]+)/g;
-
 type Phase = "idle" | "round" | "waiting" | "cleanup";
 
+
 interface Probe {
 	id: string;
 	file: string;
@@ -48,7 +49,6 @@ interface DebugState {
 function freshState(): DebugState {
 	return {
 		active: false,
-		phase: "idle",
 		problem: "",
 		round: 0,
 		runId: null,
@@ -86,8 +86,8 @@ Deployed probes (ground truth, maintained by the extension):
   ${probes}
 
 Current run log file (absolute path): ${logFileFor(s) ?? "(not initialized)"}
-Runtime probes MUST append JSONL directly to that exact file using the target runtime's native file APIs.
-Probe code MUST carry the marker comment \`// @omp-probe <id>\` adjacent to it.
+Runtime probes MUST append JSONL directly to that exact file using the target environment's native file APIs.
+Console output such as Unity Debug.Log may supplement diagnostics but is never the runtime evidence for this workflow. Never ask the user to transcribe console output.
 Logs by run: ${counts}
 Current run id: ${s.runId ?? "(not started)"}`;
 }
@@ -97,25 +97,26 @@ const METHODOLOGY = `\
 Each round consists of, in order:
 1. Restate hypotheses (mark each: pending / ruled-out / confirmed via runtime evidence).
 2. Update instrumentation: remove probes that yielded no information, add probes that
-   discriminate between remaining hypotheses. Each probe must use the target runtime's
-   native file append API to append exactly one compact JSON object plus a newline to the
-   exact absolute log file shown above. Use the schema {"probe":"<id>","ts":<epoch-ms>,
-   "data":<JSON-serializable-observation>}. Append; never overwrite or truncate. Open,
-   append, flush, and close promptly for each observation; do not retain an exclusive file
-   handle across the reproduction gate. Do not use HTTP, POST, localhost, sockets, or any
-   network transport. Escape the path correctly for the target language. Keep the marker
-   comment \`// @omp-probe <id>\` adjacent to the code.
+   discriminate between remaining hypotheses. Every runtime probe MUST append exactly
+   one compact JSON object plus a newline to the exact absolute log file shown above.
+   Use {"probe":"<id>","ts":<epoch-ms>,"data":<JSON-serializable-observation>}.
+   Append; never overwrite or truncate. Open, append, flush, and close promptly for each
+   observation. Do not use HTTP, POST, localhost, sockets, or any network transport.
+   Use the target environment's native file API and ensure the code path writes the file.
+   Console logging may supplement the file but never replaces it. Do not ask the user to
+   copy or summarize console output.
 3. ATTEMPT A FIX for your leading hypothesis in the same round. Instrumentation without
    a fix is an incomplete round — the loop only advances when you fix something.
 4. End the round by writing concise reproduction steps for the user (exact commands or
-   actions, what to observe). Then STOP — the user reproduces out-of-band and answers
-   with /debug-done fixed or /debug-done proceed.
+   actions, what to observe). Then STOP — the user reproduces out-of-band and uses
+   the review menu, /debug-note, or /debug-done fixed|proceed.
 When told the fix is confirmed: remove every probe, verify with the list_debug_probes
 tool that the ledger is empty, then summarize root cause and the final fix.`;
 
 export default function debugModeExtension(pi: ExtensionAPI) {
 	const z = pi.zod;
 	const state: DebugState = freshState();
+	let reviewMenuOpen = false;
 	let uiCtx: ExtensionContext | null = null;
 
 	// ============================== log files ==============================
@@ -171,8 +172,10 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		return run;
 	}
 
+
 	// ============================== probe ledger ==============================
 
+
 	pi.on("tool_call", async (event) => {
 		if (!state.active) return;
 		if (event.toolName !== "edit" && event.toolName !== "write") return;
@@ -184,8 +187,7 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 				if (!state.probes.some(p => p.id === id)) state.probes.push({ id, file, round: state.round });
 			}
 		}
-		// removal detection: edit inputs alone can't prove deletion — checkLedger()
-		// rescans files for ground truth on demand.
+		// Removal detection rescans files for ground truth on demand.
 	});
 
 	/** Ground truth: which registered probes still exist in code. */
@@ -228,7 +230,7 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		if (state.phase === "waiting") {
 			refreshLogCounts();
 			const n = state.runId ? (state.logCounts[state.runId] ?? 0) : 0;
-			lines.push(ctx.ui.theme.fg("accent", "reproduce the bug, then: /debug-done fixed | proceed"));
+			lines.push(ctx.ui.theme.fg("accent", "reproduce the bug, then: /debug-review"));
 			lines.push(ctx.ui.theme.fg("dim", `run ${state.runId} — ${n} log entries`));
 		}
 		ctx.ui.setWidget("debug-mode", lines.length ? lines : undefined);
@@ -274,16 +276,20 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		if (!state.active) return;
 		if (state.phase === "cleanup") {
 			// Cleanup turn settled: keep fixes and remove the temporary logs.
-			if (state.cleanupReady) await teardown(ctx, true);
+			if (state.cleanupReady) await teardown(ctx, "finished");
 			return;
 		}
 		if (state.phase !== "round" || !state.hasRoundContent) return;
 		state.phase = "waiting";
+		pi.appendEntry(DEBUG_ENTRY, { ...state });
 		refreshUi();
 		ctx.ui.notify(
-			`Debug round ${state.round} paused.\nReproduce the bug now, then run:\n  /debug-done fixed   — fix confirmed, clean up & summarize\n  /debug-done proceed — analyze logs, next round`,
+			`Debug round ${state.round} paused. Reproduce the bug, then choose an action or run /debug-review.`,
 			"info",
 		);
+		if (ctx.hasUI) {
+			void openReviewMenu(ctx).catch(err => pi.logger.warn("debug-mode: review menu failed", { err }));
+		}
 	});
 
 	pi.registerCommand("debug-mode", {
@@ -291,7 +297,7 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		handler: async (args, ctx) => {
 			uiCtx = ctx;
 			if (state.active) {
-				ctx.ui.notify("debug-mode: already active (use /debug-done or /debug-abort)", "error");
+				ctx.ui.notify("debug-mode: already active (use /debug-review, /debug-done, or /debug-abort)", "error");
 				return;
 			}
 			const problem = args.trim();
@@ -331,65 +337,94 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		);
 	}
 
-	function finishDebug(ctx: ExtensionContext, verdict: "fixed" | "proceed"): void {
+	function ensureWaiting(ctx: ExtensionContext): boolean {
 		if (!state.active) {
 			ctx.ui.notify("debug-mode: not active", "error");
-			return;
+			return false;
 		}
 		if (state.phase !== "waiting") {
 			ctx.ui.notify(`debug-mode: not waiting for reproduction (phase: ${state.phase})`, "error");
-			return;
+			return false;
 		}
+		return true;
+	}
+
+	async function markDebugFixed(ctx: ExtensionContext): Promise<void> {
+		if (!ensureWaiting(ctx)) return;
 		refreshLogCounts();
-		if (verdict === "fixed") {
-			state.phase = "cleanup";
-			state.cleanupReady = false;
-			refreshUi();
-			pi.sendMessage(
-				{
-					customType: "debug-mode-fixed",
-					content:
-						"User marked the problem FIXED.\n" +
-						"1. Remove every debug probe from the code (probe ledger below; verify with list_debug_probes after edits).\n" +
-						"2. Then summarize: root cause, the fix applied, what remains in the working diff.\n" +
-						`Probe ledger: ${JSON.stringify(state.probes)}`,
-					display: true,
-				},
-				{ triggerTurn: true },
+		const logCount = state.runId ? (state.logCounts[state.runId] ?? 0) : 0;
+		if (logCount === 0 && ctx.hasUI) {
+			const confirmed = await ctx.ui.confirm(
+				"Mark as fixed without runtime logs?",
+				"No runtime observations were captured for this round. Mark the problem as fixed anyway?",
 			);
-			// teardown happens when the cleanup turn settles (session_stop above)
-		} else {
-			const run = state.runId ?? "(none)";
-			const n = state.logCounts[run] ?? 0;
-			const previousRound = state.round;
-			state.round += 1;
-			state.phase = "round";
-			state.hasRoundContent = false;
-			if (!newRun()) {
-				state.round = previousRound;
-				state.phase = "waiting";
-				ctx.ui.notify("debug-mode: could not initialize the next run log file; staying at the reproduction gate", "error");
-				refreshUi();
-				return;
-			}
-			refreshUi();
-			pi.sendMessage(
-				{
-					customType: "debug-mode-proceed",
-					content:
-						`User chose PROCEED — the fix did not resolve it (run ${run} captured ${n} log entries).\n` +
-						(n === 0
-							? "No logs were captured: the instrumented code path may not have executed, the build may be stale, the path may be wrong, or the file append may have failed — treat that as a signal.\n"
-							: "") +
-						"Read the logs with get_debug_logs, rule out / strengthen hypotheses, re-instrument, attempt the next fix, give reproduction steps, and stop.",
-					display: true,
-				},
-				{ triggerTurn: true },
+			if (!confirmed) return;
+		}
+		if (!state.active || state.phase !== "waiting") return;
+
+		state.phase = "cleanup";
+		state.cleanupReady = false;
+		refreshUi();
+		pi.sendMessage(
+			{
+				customType: "debug-mode-fixed",
+				content:
+					"User marked the problem FIXED.\n" +
+					"1. Remove every debug probe from the code (probe ledger below; verify with list_debug_probes after edits).\n" +
+					"2. Then summarize: root cause, the fix applied, what remains in the working diff.\n" +
+					`Probe ledger: ${JSON.stringify(state.probes)}`,
+				display: true,
+			},
+			{ triggerTurn: true },
+		);
+	}
+
+	async function advanceDebug(ctx: ExtensionContext, reproductionDetails?: string): Promise<void> {
+		if (!ensureWaiting(ctx)) return;
+		refreshLogCounts();
+		const run = state.runId ?? "(none)";
+		const logCount = state.logCounts[run] ?? 0;
+		if (logCount === 0 && !reproductionDetails && ctx.hasUI) {
+			const confirmed = await ctx.ui.confirm(
+				"Proceed without runtime logs?",
+				"No runtime observations were captured for this round. Continue to another analysis and fix round anyway?",
 			);
+			if (!confirmed) return;
 		}
+		if (!state.active || state.phase !== "waiting") return;
+
+		const previousRound = state.round;
+		state.round += 1;
+		state.phase = "round";
+		state.hasRoundContent = false;
+		if (!newRun()) {
+			state.round = previousRound;
+			state.phase = "waiting";
+			ctx.ui.notify("debug-mode: could not initialize the next run log file; staying at the reproduction gate", "error");
+			refreshUi();
+			return;
+		}
+		refreshUi();
+
+		const userEvidence = reproductionDetails
+			? `User added reproduction details after run ${run}:\n\n${reproductionDetails}\n\nTreat these details as evidence alongside the captured logs.\n`
+			: `User chose PROCEED — the fix did not resolve it (run ${run} captured ${logCount} log entries).\n`;
+		pi.sendMessage(
+			{
+				customType: reproductionDetails ? "debug-mode-note" : "debug-mode-proceed",
+				content:
+					userEvidence +
+					(logCount === 0
+						? "No logs were captured: the instrumented code path may not have executed, the build may be stale, the path may be wrong, or the file append may have failed — treat that as a signal.\n"
+						: `Run ${run} captured ${logCount} log entries.\n`) +
+					"Read the previous run with get_debug_logs, update the hypotheses, re-instrument, attempt the next fix, give reproduction steps, and stop.",
+				display: true,
+			},
+			{ triggerTurn: true },
+		);
 	}
 
-	async function teardown(ctx: ExtensionContext, keepFixes: boolean): Promise<void> {
+	async function teardown(ctx: ExtensionContext, outcome: "finished" | "aborted"): Promise<void> {
 		if (state.debugDir) {
 			try {
 				fs.rmSync(state.debugDir, { recursive: true, force: true });
@@ -401,13 +436,63 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		Object.assign(state, freshState());
 		pi.appendEntry(DEBUG_ENTRY, { ...state });
 		refreshUi();
+		const resultLabel = outcome === "finished" ? "finished" : "aborted";
 		if (probesLeft.length > 0) {
 			ctx.ui.notify(
-				`debug-mode ended, but ${probesLeft.length} probe(s) remain in code: ${probesLeft.map(p => p.id).join(", ")} — remove manually.`,
+				`Debug mode ${resultLabel}, but ${probesLeft.length} probe(s) remain in code: ${probesLeft.map(p => p.id).join(", ")} — remove manually. Applied fixes remain in the working diff.`,
 				"warning",
 			);
-		} else if (keepFixes) {
-			ctx.ui.notify("Debug mode finished. Log files removed; working diff contains the fix — review with git diff.", "info");
+		} else {
+			ctx.ui.notify(
+				`Debug mode ${resultLabel}. Log files removed; applied fixes remain in the working diff for review.`,
+				"info",
+			);
+		}
+	}
+
+	async function abortDebug(ctx: ExtensionContext): Promise<void> {
+		if (!state.active) {
+			ctx.ui.notify("debug-mode: not active", "error");
+			return;
+		}
+		if (ctx.hasUI) {
+			const confirmed = await ctx.ui.confirm(
+				"Abort debug mode?",
+				"Delete captured debug logs and stop the workflow? Applied code changes will remain in the working diff.",
+			);
+			if (!confirmed) return;
+		}
+		if (!state.active) return;
+		await teardown(ctx, "aborted");
+	}
+
+	async function openReviewMenu(ctx: ExtensionContext): Promise<void> {
+		if (!ensureWaiting(ctx)) return;
+		if (!ctx.hasUI) {
+			ctx.ui.notify("/debug-review requires an interactive UI; use /debug-done fixed|proceed instead.", "warning");
+			return;
+		}
+		if (reviewMenuOpen) {
+			ctx.ui.notify("debug-mode: review menu is already open", "info");
+			return;
+		}
+
+		reviewMenuOpen = true;
+		try {
+			const choice = await ctx.ui.select(`Review debug round ${state.round}`, [...REVIEW_OPTIONS]);
+			if (!choice) return;
+			if (choice === REVIEW_MARK_FIXED) {
+				await markDebugFixed(ctx);
+			} else if (choice === REVIEW_PROCEED) {
+				await advanceDebug(ctx);
+			} else if (choice === REVIEW_ADD_DETAILS) {
+				ctx.ui.setEditorText("/debug-note ");
+				ctx.ui.notify("Add reproduction details in the editor, then submit /debug-note.", "info");
+			} else if (choice === REVIEW_ABORT) {
+				await abortDebug(ctx);
+			}
+		} finally {
+			reviewMenuOpen = false;
 		}
 	}
 
@@ -419,11 +504,34 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		handler: async (args, ctx) => {
 			uiCtx = ctx;
 			const verdict = args.trim().toLowerCase();
-			if (verdict !== "fixed" && verdict !== "proceed") {
+			if (verdict === "fixed") {
+				await markDebugFixed(ctx);
+			} else if (verdict === "proceed") {
+				await advanceDebug(ctx);
+			} else {
 				ctx.ui.notify("Usage: /debug-done fixed|proceed", "error");
+			}
+		},
+	});
+
+	pi.registerCommand("debug-review", {
+		description: "Open the interactive action menu for a completed debug round",
+		handler: async (_args, ctx) => {
+			uiCtx = ctx;
+			await openReviewMenu(ctx);
+		},
+	});
+
+	pi.registerCommand("debug-note", {
+		description: "Add reproduction details and continue: /debug-note <details>",
+		handler: async (args, ctx) => {
+			uiCtx = ctx;
+			const details = args.trim();
+			if (!details) {
+				ctx.ui.notify("Usage: /debug-note <reproduction details>", "error");
 				return;
 			}
-			finishDebug(ctx, verdict);
+			await advanceDebug(ctx, details);
 		},
 	});
 
@@ -431,20 +539,7 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 		description: "Abort debug mode: delete logs (fixes stay in the working diff)",
 		handler: async (_args, ctx) => {
 			uiCtx = ctx;
-			if (!state.active) {
-				ctx.ui.notify("debug-mode: not active", "error");
-				return;
-			}
-			const ledger = await checkLedger();
-			await teardown(ctx, true);
-			if (ledger.length > 0) {
-				ctx.ui.notify(
-					`Debug mode aborted. These probes remain (remove manually or ask the agent):\n${ledger.map(p => `  ${p.id} — ${p.file}`).join("\n")}\nApplied fixes are kept in the working diff.`,
-					"warning",
-				);
-			} else {
-				ctx.ui.notify("Debug mode aborted. No probes in code; applied fixes are kept in the working diff.", "info");
-			}
+			await abortDebug(ctx);
 		},
 	});
 
@@ -471,6 +566,7 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 
 	// ============================== tools ==============================
 
+
 	pi.registerTool({
 		name: "get_debug_logs",
 		label: "Get Debug Logs",
@@ -572,7 +668,7 @@ export default function debugModeExtension(pi: ExtensionAPI) {
 			}
 			refreshLogCounts();
 			ctx.ui.notify(
-				`debug-mode resumed: phase=${state.phase} round=${state.round}, log=${currentFile ?? "unavailable"}. Use /debug-status, /debug-done fixed|proceed, or /debug-abort.`,
+				`debug-mode resumed: phase=${state.phase} round=${state.round}, log=${currentFile ?? "unavailable"}. Use /debug-status, /debug-review, /debug-done fixed|proceed, or /debug-abort.`,
 				"info",
 			);
 		}

package/src/review-actions.ts

@@ -0,0 +1,11 @@
+export const REVIEW_MARK_FIXED = "Mark as fixed";
+export const REVIEW_PROCEED = "Proceed with captured logs";
+export const REVIEW_ADD_DETAILS = "Add reproduction details";
+export const REVIEW_ABORT = "Abort debug mode";
+
+export const REVIEW_OPTIONS = [
+	REVIEW_MARK_FIXED,
+	REVIEW_PROCEED,
+	REVIEW_ADD_DETAILS,
+	REVIEW_ABORT,
+] as const;