@siuver/omp-debug-mode 0.1.1 → 0.1.3

package/src/log-files.ts

@@ -24,6 +24,75 @@ export function readJsonlLines(file: string | null): string[] {
 	}
 }
 
+interface CountEntry {
+	size: number;
+	mtimeMs: number;
+	count: number;
+}
+
+/**
+ * Line counts keyed by file identity. The reproduction gate polls the active
+ * log once a second, so re-reading every archived run each time would scale
+ * with the length of the debugging session for no new information.
+ */
+export class JsonlLineCounter {
+	#cache = new Map<string, CountEntry>();
+
+	count(file: string | null): number {
+		if (!file) return 0;
+		const stat = fs.statSync(file, { throwIfNoEntry: false });
+		if (!stat) {
+			this.#cache.delete(file);
+			return 0;
+		}
+		const hit = this.#cache.get(file);
+		if (hit && hit.size === stat.size && hit.mtimeMs === stat.mtimeMs) return hit.count;
+		const count = readJsonlLines(file).length;
+		this.#cache.set(file, { size: stat.size, mtimeMs: stat.mtimeMs, count });
+		return count;
+	}
+
+	clear(): void {
+		this.#cache.clear();
+	}
+}
+
+export interface HypothesisTally {
+	id: string;
+	count: number;
+}
+
+const UNATTRIBUTED = "(unattributed)";
+
+/**
+ * Group observations by the hypothesis each probe was meant to settle, so the
+ * user and the agent can see which hypotheses actually produced evidence
+ * before anyone reads the raw log.
+ */
+export function summarizeHypotheses(lines: readonly string[]): HypothesisTally[] {
+	const counts = new Map<string, number>();
+	for (const line of lines) {
+		let id = UNATTRIBUTED;
+		try {
+			const entry = JSON.parse(line) as { hypothesisId?: unknown };
+			if (typeof entry.hypothesisId === "string" && entry.hypothesisId.trim().length > 0) {
+				id = entry.hypothesisId.trim();
+			}
+		} catch {
+			continue;
+		}
+		counts.set(id, (counts.get(id) ?? 0) + 1);
+	}
+	return [...counts]
+		.map(([id, count]) => ({ id, count }))
+		.sort((a, b) => (b.count !== a.count ? b.count - a.count : a.id < b.id ? -1 : 1));
+}
+
+export function describeHypotheses(tallies: readonly HypothesisTally[]): string {
+	if (tallies.length === 0) return "no hypothesis-attributed observations";
+	return tallies.map(t => `${t.id}=${t.count}`).join(", ");
+}
+
 export function prepareRunLog(debugDir: string, previousRun: string | null): string {
 	const activeFile = path.join(debugDir, ACTIVE_LOG_FILE);
 	const archivedFile = previousRun ? path.join(debugDir, `${previousRun}.jsonl`) : null;

package/src/main.ts

@@ -1,588 +1,24 @@
 /**
  * Debug Mode Extension — Cursor-style human-in-the-loop debugging for omp.
  *
- * State machine:
+ * State machine (matches Cursor Debug Mode):
  *   IDLE → /debug-mode <problem>
- *   → agent hypothesizes, adds @omp-probe instrumentation, attempts a fix
+ *   → agent writes 3-5 hypotheses and @omp-probe instrumentation (no product 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
+ *   → Proceed/add details → agent reads logs, evaluates hypotheses, fixes only
+ *     with evidence, keeps probes, and asks for a verification reproduce → loop
+ *   → Mark as fixed → agent removes probes + summarizes → teardown (logs deleted)
  *
- * - 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
+ * - `state.ts` — persisted round state and the injected blackboard
+ * - `probes.ts` — `@omp-probe` ledger and its on-disk ground truth
+ * - `log-files.ts` — stable `<cwd>/.omp/debug/current.jsonl` and run archival
+ * - `methodology.ts` — the Cursor Debug Mode prompt contract
+ * - `debug-mode.ts` — state machine, commands, and lifecycle wiring
  */
-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";
-
-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;
-	round: number;
-}
-
-interface DebugState {
-	active: boolean;
-	phase: Phase;
-	problem: string;
-	round: number;
-	runId: string | null;
-	probes: Probe[];
-	debugDir: string | null;
-	logCounts: Record<string, number>;
-	hasRoundContent: boolean;
-	cleanupReady: boolean;
-}
-
-
-function freshState(): DebugState {
-	return {
-		active: false,
-		phase: "idle",
-		problem: "",
-		round: 0,
-		runId: null,
-		probes: [],
-		debugDir: null,
-		logCounts: {},
-		hasRoundContent: false,
-		cleanupReady: false,
-	};
-}
-
-function probeIdsIn(text: unknown): string[] {
-	if (typeof text !== "string") return [];
-	const ids: string[] = [];
-	for (const m of text.matchAll(PROBE_MARK)) ids.push(m[1]);
-	return ids;
-}
-
-function logFileFor(s: DebugState, run = s.runId): string | null {
-	return resolveRunLogFile(s.debugDir, run, s.runId);
-}
-
-function blackboard(s: DebugState): string {
-	const probes = s.probes.map(p => `${p.id} (${p.file}, round ${p.round})`).join("\n  ") || "(none)";
-	const counts = Object.entries(s.logCounts)
-		.map(([run, n]) => `${run}: ${n}`)
-		.join(", ") || "(none yet)";
-	return `\
-[DEBUG MODE ACTIVE — round ${s.round}]
-
-Problem under investigation:
-${s.problem}
-
-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.
-Logs by run: ${counts}
-Current run id: ${s.runId ?? "(not started)"}`;
-}
-
-const METHODOLOGY = `\
-[DEBUG MODE METHODOLOGY — follow strictly]
-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.
-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.
-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.`;
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { registerDebugMode } from "./debug-mode";
 
 export default function debugModeExtension(pi: ExtensionAPI) {
-	const z = pi.zod;
-	const state: DebugState = freshState();
-	let uiCtx: ExtensionContext | null = null;
-
-	// ============================== log files ==============================
-
-	function initializeLogDirectory(ctx: ExtensionContext): boolean {
-		const dir = path.resolve(ctx.cwd, ".omp", "debug");
-		try {
-			fs.mkdirSync(dir, { recursive: true });
-			state.debugDir = dir;
-			return true;
-		} catch (err) {
-			pi.logger.error("debug-mode: cannot create log dir", { dir, err });
-			state.debugDir = null;
-			return false;
-		}
-	}
-
-	function readRunLines(run: string): string[] {
-		return readJsonlLines(logFileFor(state, run));
-	}
-
-	function refreshLogCounts(): void {
-		const runs = new Set(Object.keys(state.logCounts));
-		if (state.debugDir) {
-			try {
-				for (const file of fs.readdirSync(state.debugDir)) {
-					if (!file.endsWith(".jsonl")) continue;
-					if (file === ACTIVE_LOG_FILE) {
-						if (state.runId) runs.add(state.runId);
-					} else {
-						runs.add(file.replace(/\.jsonl$/, ""));
-					}
-				}
-			} catch {}
-		}
-		for (const run of runs) state.logCounts[run] = readRunLines(run).length;
-	}
-
-	function newRun(): string | null {
-		if (!state.debugDir) return null;
-		const run = `run${state.round}-${Date.now().toString(36)}`;
-		try {
-			prepareRunLog(state.debugDir, state.runId);
-		} catch (err) {
-			pi.logger.error("debug-mode: cannot initialize run log", {
-				file: path.join(state.debugDir, ACTIVE_LOG_FILE),
-				err,
-			});
-			return null;
-		}
-		state.runId = run;
-		state.logCounts[run] = 0;
-		return run;
-	}
-
-	// ============================== probe ledger ==============================
-
-	pi.on("tool_call", async (event) => {
-		if (!state.active) return;
-		if (event.toolName !== "edit" && event.toolName !== "write") return;
-		const input = event.input as Record<string, unknown>;
-		const file =
-			typeof input.path === "string" ? input.path : typeof input.file_path === "string" ? input.file_path : "(unknown)";
-		for (const v of Object.values(input)) {
-			for (const id of probeIdsIn(v)) {
-				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.
-	});
-
-	/** Ground truth: which registered probes still exist in code. */
-	async function checkLedger(): Promise<Probe[]> {
-		const alive: Probe[] = [];
-		const byFile = new Map<string, Probe[]>();
-		for (const p of state.probes) {
-			const list = byFile.get(p.file) ?? [];
-			list.push(p);
-			byFile.set(p.file, list);
-		}
-		for (const [file, probes] of byFile) {
-			let text: string;
-			try {
-				text = await Bun.file(file).text();
-			} catch {
-				continue; // file gone → probe gone
-			}
-			for (const p of probes) {
-				if (text.includes(`@omp-probe ${p.id}`)) alive.push(p);
-			}
-		}
-		return alive;
-	}
-
-	// ============================== UI ==============================
-
-	function refreshUi(): void {
-		const ctx = uiCtx;
-		if (!ctx?.hasUI) return;
-		if (!state.active) {
-			ctx.ui.setStatus("debug-mode", undefined);
-			ctx.ui.setWidget("debug-mode", undefined);
-			return;
-		}
-		const label =
-			state.phase === "waiting" ? "🐞 waiting-repro" : state.phase === "round" ? `🐞 round ${state.round}` : "🐞 cleanup";
-		ctx.ui.setStatus("debug-mode", ctx.ui.theme.fg("warning", label));
-		const lines: string[] = [];
-		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("dim", `run ${state.runId} — ${n} log entries`));
-		}
-		ctx.ui.setWidget("debug-mode", lines.length ? lines : undefined);
-	}
-
-	// ============================== prompt injection ==============================
-
-	pi.on("before_agent_start", async () => {
-		if (!state.active || (state.phase !== "round" && state.phase !== "cleanup")) return;
-		return {
-			message: {
-				customType: "debug-mode-context",
-				content: `${blackboard(state)}\n\n${METHODOLOGY}`,
-				display: false,
-			},
-		};
-	});
-
-	// Drop stale blackboard messages; the freshest is re-injected each round.
-	pi.on("context", async (event) => {
-		const filtered = event.messages.filter(
-			m => !(m.role === "custom" && (m as { customType?: string }).customType === "debug-mode-context"),
-		);
-		if (filtered.length !== event.messages.length) return { messages: filtered };
-	});
-
-	// ============================== round lifecycle ==============================
-
-	pi.on("agent_start", async () => {
-		if (state.active) state.hasRoundContent = false;
-	});
-
-	pi.on("message_end", async (event) => {
-		if (!state.active) return;
-		const msg = event.message as { role?: string };
-		if (msg?.role === "assistant") {
-			if (state.phase === "cleanup") state.cleanupReady = true;
-			state.hasRoundContent = true;
-		}
-	});
-
-	pi.on("session_stop", async (_event, ctx) => {
-		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);
-			return;
-		}
-		if (state.phase !== "round" || !state.hasRoundContent) return;
-		state.phase = "waiting";
-		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`,
-			"info",
-		);
-	});
-
-	pi.registerCommand("debug-mode", {
-		description: "Start debug mode: /debug-mode <problem description>",
-		handler: async (args, ctx) => {
-			uiCtx = ctx;
-			if (state.active) {
-				ctx.ui.notify("debug-mode: already active (use /debug-done or /debug-abort)", "error");
-				return;
-			}
-			const problem = args.trim();
-			if (!problem) {
-				ctx.ui.notify("Usage: /debug-mode <problem description — symptoms, expected vs actual, how to reproduce>", "error");
-				return;
-			}
-			startDebug(ctx, problem);
-		},
-	});
-
-	function startDebug(ctx: ExtensionContext, problem: string): void {
-		if (!initializeLogDirectory(ctx)) {
-			ctx.ui.notify("debug-mode: could not create the debug log directory; debug mode was not started", "error");
-			return;
-		}
-		state.active = true;
-		state.phase = "round";
-		state.problem = problem;
-		state.round = 1;
-		state.probes = [];
-		state.logCounts = {};
-		state.hasRoundContent = false;
-		if (!newRun()) {
-			Object.assign(state, freshState());
-			ctx.ui.notify("debug-mode: could not initialize the run log file; debug mode was not started", "error");
-			return;
-		}
-		refreshUi();
-		pi.sendMessage(
-			{
-				customType: "debug-mode-start",
-				content: `Starting debug mode. Problem report:\n\n${problem}\n\nBegin round 1: explore, hypothesize, instrument with direct file writes, and attempt a fix. Then give reproduction steps and stop.`,
-				display: true,
-			},
-			{ triggerTurn: true },
-		);
-	}
-
-	function finishDebug(ctx: ExtensionContext, verdict: "fixed" | "proceed"): void {
-		if (!state.active) {
-			ctx.ui.notify("debug-mode: not active", "error");
-			return;
-		}
-		if (state.phase !== "waiting") {
-			ctx.ui.notify(`debug-mode: not waiting for reproduction (phase: ${state.phase})`, "error");
-			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 },
-			);
-			// 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 },
-			);
-		}
-	}
-
-	async function teardown(ctx: ExtensionContext, keepFixes: boolean): Promise<void> {
-		if (state.debugDir) {
-			try {
-				fs.rmSync(state.debugDir, { recursive: true, force: true });
-			} catch (err) {
-				pi.logger.warn("debug-mode: failed to remove debug dir", { err });
-			}
-		}
-		const probesLeft = await checkLedger();
-		Object.assign(state, freshState());
-		pi.appendEntry(DEBUG_ENTRY, { ...state });
-		refreshUi();
-		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.`,
-				"warning",
-			);
-		} else if (keepFixes) {
-			ctx.ui.notify("Debug mode finished. Log files removed; working diff contains the fix — review with git diff.", "info");
-		}
-	}
-
-	// ============================== commands ==============================
-
-
-	pi.registerCommand("debug-done", {
-		description: "Answer the reproduction gate: /debug-done fixed|proceed",
-		handler: async (args, ctx) => {
-			uiCtx = ctx;
-			const verdict = args.trim().toLowerCase();
-			if (verdict !== "fixed" && verdict !== "proceed") {
-				ctx.ui.notify("Usage: /debug-done fixed|proceed", "error");
-				return;
-			}
-			finishDebug(ctx, verdict);
-		},
-	});
-
-	pi.registerCommand("debug-abort", {
-		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");
-			}
-		},
-	});
-
-	pi.registerCommand("debug-status", {
-		description: "Show debug mode state",
-		handler: async (_args, ctx) => {
-			uiCtx = ctx;
-			if (!state.active) {
-				ctx.ui.notify("debug-mode: idle", "info");
-				return;
-			}
-			refreshLogCounts();
-			const alive = await checkLedger();
-			ctx.ui.notify(
-				`debug-mode: phase=${state.phase} round=${state.round} run=${state.runId}\n` +
-					`probes (ledger ${state.probes.length}, alive ${alive.length}):\n` +
-					(alive.map(p => `  ${p.id} — ${p.file}`).join("\n") || "  (none)") +
-					`\nlogs: ${Object.entries(state.logCounts).map(([r, n]) => `${r}=${n}`).join(", ") || "(none)"}` +
-					`\ncurrent log file: ${logFileFor(state) ?? "(not initialized)"}`,
-				"info",
-			);
-		},
-	});
-
-	// ============================== tools ==============================
-
-	pi.registerTool({
-		name: "get_debug_logs",
-		label: "Get Debug Logs",
-		description:
-			"Read JSONL observations appended directly by debug-mode runtime probes. Each entry: {probe, ts, data}. Call with previous=true to analyze the last completed reproduction run.",
-		parameters: z.object({
-			run: z.string().optional().describe("Run id filter (default: current run)"),
-			probe: z.string().optional().describe("Probe id filter"),
-			previous: z.boolean().optional().describe("Use the previous (completed) run instead of the current one"),
-		}),
-		approval: "read",
-		async execute(_toolCallId, params) {
-			refreshLogCounts();
-			const runs = Object.keys(state.logCounts);
-			let run = params.run;
-			if (!run && params.previous) {
-				run = runs[runs.length - 2];
-				if (!run) {
-					return {
-						content: [{ type: "text", text: "(no completed previous debug run is available)" }],
-						details: { run: null, file: null, count: 0 },
-					};
-				}
-			}
-			if (!run) run = state.runId ?? undefined;
-
-			let lines = run ? readRunLines(run) : [];
-			if (params.probe) {
-				lines = lines.filter(line => {
-					try {
-						const entry = JSON.parse(line) as { probe?: unknown };
-						return entry.probe === params.probe;
-					} catch {
-						return false;
-					}
-				});
-			}
-			const text = lines.join("\n");
-			return {
-				content: [
-					{
-						type: "text",
-						text:
-							text ||
-							"(no logs captured — the instrumented path may not have executed, the build may be stale, the path may be wrong, or the file append may have failed)",
-					},
-				],
-				details: { run: run ?? null, file: run ? logFileFor(state, run) : null, count: lines.length },
-			};
-		},
-	});
-
-	pi.registerTool({
-		name: "list_debug_probes",
-		label: "List Debug Probes",
-		description:
-			"Ground-truth probe ledger for debug mode: rescans files for `@omp-probe <id>` markers and reports which probes are actually present in code, with their files. Use to verify cleanup is complete.",
-		parameters: z.object({}),
-		approval: "read",
-		async execute() {
-			const alive = await checkLedger();
-			return {
-				content: [
-					{
-						type: "text",
-						text:
-							alive.length === 0
-								? "Probe ledger is EMPTY — all probes removed."
-								: `Alive probes (${alive.length}):\n` + alive.map(p => `${p.id} — ${p.file}`).join("\n"),
-					},
-				],
-				details: { alive },
-			};
-		},
-	});
-
-	// ============================== lifecycle ==============================
-
-	pi.on("session_start", async (_event, ctx) => {
-		uiCtx = ctx;
-		const entries = ctx.sessionManager.getEntries();
-		const last = entries
-			.filter((e: { type: string; customType?: string }) => e.type === "custom" && e.customType === DEBUG_ENTRY)
-			.pop() as { data?: DebugState } | undefined;
-		if (last?.data?.active) {
-			Object.assign(state, last.data);
-			if (!state.debugDir || !fs.existsSync(state.debugDir)) initializeLogDirectory(ctx);
-			const currentFile = logFileFor(state);
-			if (currentFile) {
-				try {
-					const legacyRunFile = state.debugDir && state.runId ? path.join(state.debugDir, `${state.runId}.jsonl`) : null;
-					if (!fs.existsSync(currentFile) && legacyRunFile && fs.existsSync(legacyRunFile)) {
-						fs.renameSync(legacyRunFile, currentFile);
-					}
-					fs.writeFileSync(currentFile, "", { flag: "a" });
-				} catch (err) {
-					pi.logger.error("debug-mode: cannot restore run log", { file: currentFile, err });
-				}
-			}
-			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.`,
-				"info",
-			);
-		}
-		refreshUi();
-	});
-
-	pi.on("turn_start", async () => {
-		if (state.active) pi.appendEntry(DEBUG_ENTRY, { ...state });
-	});
-
-
 	pi.setLabel("Debug Mode");
+	registerDebugMode(pi);
 }