@siuver/omp-debug-mode 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.1.7 - 2026-09-09
+
+- Added `/debug-clear`, which empties this round's `current.jsonl` without advancing. A botched reproduction can be thrown away and rerun on the same round; archived runs stay on disk. The live counter on `/debug-proceed` drops to zero, and a busy truncate is retried the same way as rotation.
+- Cut the repetition out of the user-turn widgets, where one screen said `/debug-proceed` three times (call to action, the agent's closing step, the actions strip), the round number three times (footer plus both exit lines), and "nothing was captured" twice (the proceed line plus a `run <id> — 0 log entries` footer). The round number now lives only in the footer, the captured counts live only on the `/debug-proceed` line that acts on them — still climbing live while you reproduce — and the run id is gone from the widget entirely, since it is not something you type.
+- The actions strip under the editor is a dim cheat-sheet headed `Tips:`, not a second headline. `/debug-proceed` no longer lights up when logs arrive (empty vs captured stays in the wording), the leftover-commands line stays dim, and `Reply in the editor` is gone: that exit is still legal, but listing it next to the editor restated what the cursor already is.
+- The widget renumbers reproduction steps itself and drops any step naming `/debug-proceed` or `/debug-done`. The agent numbers its list about as often as it does not, and an unnumbered run of dim lines reads as one paragraph instead of a sequence — while the injected contract used to *require* a closing line naming the commands, which the model then also wrote in as a final numbered step the user cannot perform until every other step is done. The methodology, the start/proceed prompts, and the user-turn briefing now forbid naming either command in prose or in the steps, and ask for one short line saying what to do instead.
+- Widget lines are clipped by terminal columns instead of character count. A CJK step counts one unit per character while occupying two columns, so a Chinese reproduction step passed the 90-character budget untouched at 180 columns wide and was wrapped or truncated by the host.
+- Stopped spelling the `-` sentinel as `<request-id|->` under the editor: it renders as an arrow directly beneath three lines that use `→` to mean "and then this happens". The command's own completion already offers `-` as its first entry.
+
 ## 0.1.6 - 2026-08-31
 
 - `/debug-proceed` now recreates a missing log directory, stops the live log watcher before rotating `current.jsonl`, retries a busy truncate, and reports the OS error instead of a bare "could not initialize the next run log file". A failed truncate no longer deletes the archive it just copied — that rollback destroyed the completed run when the instrumented app still had the file open.

package/README.md

@@ -13,6 +13,7 @@ The plugin makes the agent form 3-5 hypotheses, choose the cheapest reliable evi
 | `/debug-evidence <request-id\|-> <path>` | Attaches one user-provided evidence file. The first argument always names what the file answers: an evidence request ID, or `-` for a file no request asked for. Typing the command lists the available selectors under the editor. Files are referenced in place and never copied or deleted. |
 | `/debug-done` | Marks the problem as fixed: the agent removes every probe and summarizes the result. |
 | `/debug-status` | Shows the current stage, round, run, how the round was handed back, live probes, captured log counts, pending evidence requests, and attached/unavailable artifacts. |
+| `/debug-clear` | Empties the current run's `current.jsonl` so you can reproduce again on this round. Archived runs are left alone. |
 | `/debug-abort` | Stops debug mode and removes its logs after confirmation while leaving code changes in the working tree. |
 
 ## Stages
@@ -92,23 +93,26 @@ Footer status stays a one-line label (`🐞 round N · reproduce`). The round it
 **Above the editor** — what this round asked you to do:
 
 ```text
-Reproduce the bug now, then /debug-proceed.
+Reproduce the bug now.
 ↪ E1 Capture a frame: Capture the failing frame.
 1. Restart the game.
 2. Jump near the pit.
 ```
 
-**Below the editor** — the three exits, then the remaining commands, then the live log counter:
+**Below the editor** — a dim cheat-sheet of the commands:
 
 ```text
-/debug-proceed → close round 2, analyze 14 log entries, 1 artifact
-Reply in the editor → round 2 stays open, the run keeps recording
+Tips:
+/debug-proceed → close this round, analyze 14 log entries, 1 artifact
 /debug-done → bug is fixed: remove probes and summarize
-/debug-evidence <request-id|-> <path> · /debug-abort · /debug-status
-run run2-abc — 14 log entries
+/debug-evidence <request-id> <path> · /debug-clear · /debug-abort · /debug-status
 ```
 
-The `/debug-proceed` line names what would actually be analyzed and turns into a warning (`close round 2 with nothing captured yet`) while the count is zero, so running it prematurely is a visible choice rather than a surprise. The counter updates live while you reproduce. The same commands are offered in every mode, including `incomplete`. There is no Proceed/Mark as fixed button: type the slash command.
+Each fact appears once. The round number lives in the footer, so the exit lines say "this round"; the captured counts live on the `/debug-proceed` line, which is the only thing that acts on them, and they climb in place while you reproduce. The strip is all dim so it sits next to the prompt as a reminder rather than as a second headline — empty vs captured is in the wording (`close this round with nothing captured yet`), not the color. Replying in the editor is still a legal exit; it is just not listed here, because the editor is already where that line would have pointed.
+
+Steps are renumbered by the widget, so an unnumbered list from the agent still reads as a sequence, and a step that names `/debug-proceed` or `/debug-done` is dropped: the commands belong under the editor, and the injected contract tells the agent not to write them into the steps in the first place. Lines are clipped by terminal columns rather than by character count, so a step written in Chinese or Japanese is not sent out at double width.
+
+The same commands are offered in every mode, including `incomplete`. `/debug-evidence` also accepts `-` in place of a request ID for a file no request asked for; the command's own completion offers it. There is no Proceed/Mark as fixed button: type the slash command.
 
 Every round stops at these widgets and you interact through commands only.
 
@@ -149,9 +153,9 @@ Example: for a GPU-rendering symptom whose disputed state only exists inside a f
 1. Run `/debug-mode <problem description>`.
 2. The Agent records 3-5 hypotheses and picks an evidence method for each under the least-user-intervention priority. If the route is `runtime_probe`, it inserts minimal probes marked with `@omp-probe <id>` inside `#region agent log` blocks in the same turn, before closing the round; round 1 does not apply a product fix (probe edits are not a product fix). The start prompt and a per-turn `debug-mode-context` message name the exact JSONL path and require every probe to append to it, including `hypothesisId`; console output (including Unity `Debug.Log`) is supplemental only. The context filter keeps the newest of those messages so the model sees the contract instead of dropping it. Steps are user actions only (reproduce, capture, restart).
 
-3. The Agent closes the round with `hand_off_to_user`, which is what puts the steps in your widget. Follow them in the real application so the instrumented code writes its observations, watching the widget counter climb — or supply the requested evidence with `/debug-evidence` or `/debug-proceed <details>`. Restart the app or service if the instrumented build would otherwise be stale.
+3. The Agent closes the round with `hand_off_to_user`, which is what puts the steps in your widget. Follow them in the real application so the instrumented code writes its observations, watching the count on the `/debug-proceed` line climb — or supply the requested evidence with `/debug-evidence` or `/debug-proceed <details>`. Restart the app or service if the instrumented build would otherwise be stale.
 
-4. Continue with `/debug-proceed [details]` (optionally record a user observation, then evaluate evidence), `/debug-done` (clean up and summarize), `/debug-evidence` (attach a file), or `/debug-status` (inspect the current round state). Replying normally instead hands the round back to the agent without closing it. Each round stops at the widget; all interaction is command-driven.
+4. Continue with `/debug-proceed [details]` (optionally record a user observation, then evaluate evidence), `/debug-clear` (empty this round's log and reproduce again), `/debug-done` (clean up and summarize), `/debug-evidence` (attach a file), or `/debug-status` (inspect the current round state). Replying normally instead hands the round back to the agent without closing it. Each round stops at the widget; all interaction is command-driven.
 5. On Proceed, the Agent reads the evidence (logs, your observations, attached artifacts), cites the evidence method plus log-line numbers or artifact/report paths for each hypothesis, and only then may apply a fix. Probes stay in place. Reproduce again to verify. If verification fails, rejected-hypothesis code changes are reverted before the next round.
 6. On `/debug-done`, the Agent removes every probe and summarizes the root cause and fix in 1-2 lines. If the ledger is still not empty when that turn settles, cleanup is sent back once with the remaining markers listed; a second incomplete attempt tears down anyway and warns you which probes are still in your source.
 
@@ -177,7 +181,7 @@ That exact stable path is injected into the Agent prompt. The prompt requires ev
 
 `get_debug_logs`, the proceed prompt, and `/debug-status` summarize each run by `hypothesisId`, so you can see which hypotheses produced evidence before reading a single raw line. A hypothesis with no entries was not exercised, which is not the same as being rejected.
 
-When you run `/debug-proceed [details]`, the plugin records non-empty details as a user observation, archives the completed file as `<run-id>.jsonl`, and creates an empty `current.jsonl` for the next reproduction. If that rotation fails (typical on Windows while the instrumented app still has `current.jsonl` open), the round stays open, the archive is kept, and the error names the OS reason — close the app and retry. Because the active run is truncated at the start of every round, `get_debug_logs` defaults to the newest run that actually captured observations and names the run it read; `previous=true` forces the last completed run. `/debug-status` shows the current absolute file path and the per-run log counts.
+When you run `/debug-proceed [details]`, the plugin records non-empty details as a user observation, archives the completed file as `<run-id>.jsonl`, and creates an empty `current.jsonl` for the next reproduction. If that rotation fails (typical on Windows while the instrumented app still has `current.jsonl` open), the round stays open, the archive is kept, and the error names the OS reason — close the app and retry. `/debug-clear` truncates `current.jsonl` in place without archiving or opening a new round, so a reproduction you want to throw away does not become the evidence for `/debug-proceed`. Because the active run is truncated at the start of every round, `get_debug_logs` defaults to the newest run that actually captured observations and names the run it read; `previous=true` forces the last completed run. `/debug-status` shows the current absolute file path and the per-run log counts.
 
 ## Probe Ledger
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siuver/omp-debug-mode",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "description": "Evidence-driven, human-in-the-loop debugging with autonomous probes and user-assisted artifacts for oh-my-pi.",
   "license": "MIT",

package/src/debug-mode.ts

@@ -21,6 +21,7 @@ import {
 	JsonlLineCounter,
 	describeHypotheses,
 	prepareRunLog,
+	clearActiveLog,
 	readJsonlLines,
 	summarizeHypotheses,
 } from "./log-files";
@@ -55,6 +56,7 @@ const COMMAND_PROCEED = "debug-proceed";
 const COMMAND_EVIDENCE = "debug-evidence";
 const COMMAND_ABORT = "debug-abort";
 const COMMAND_STATUS = "debug-status";
+const COMMAND_CLEAR = "debug-clear";
 
 /** Compact transcript lines for the prompts this extension injects. */
 const MESSAGE_SUMMARIES: Record<string, string> = {
@@ -587,6 +589,41 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		await setDebugToolsActive(false);
 	}
 
+	/** Empty this round's live log without advancing. Archived runs stay. */
+	async function clearDebugLog(ctx: ExtensionCommandContext): Promise<void> {
+		if (!activeSession(ctx)) return;
+		await ctx.waitForIdle();
+		if (!state.active || !state.debugDir) return;
+		refreshLogCounts();
+		if (!state.active) return;
+		const discarded = currentLogCount();
+		unwatchLogFile();
+		try {
+			clearActiveLog(state.debugDir);
+		} catch (err) {
+			watchLogFile();
+			const error = fsErrorMessage(err);
+			pi.logger.error("debug-mode: cannot clear run log", {
+				file: path.join(state.debugDir, ACTIVE_LOG_FILE),
+				err,
+			});
+			ctx.ui.notify(
+				`debug-mode: could not clear the run log file (${error}).${runLogHint(error)}`,
+				"error",
+			);
+			return;
+		}
+		refreshLogCounts();
+		watchLogFile();
+		refreshUi();
+		ctx.ui.notify(
+			discarded === 0
+				? "debug-mode: current run log is already empty"
+				: `debug-mode: cleared ${discarded === 1 ? "1 log entry" : `${discarded} log entries`} from this round`,
+			"info",
+		);
+	}
+
 	/**
 	 * Attach one user-provided evidence file to the current round. The file is
 	 * referenced in place — never copied, moved or deleted — and the action does
@@ -704,6 +741,14 @@ export function registerDebugMode(pi: ExtensionAPI): void {
 		},
 	});
 
+	pi.registerCommand(COMMAND_CLEAR, {
+		description: "Empty the current run log so this round can record a fresh reproduction",
+		handler: async (_args, ctx) => {
+			uiCtx = ctx;
+			await clearDebugLog(ctx);
+		},
+	});
+
 	pi.registerCommand(COMMAND_STATUS, {
 		description: "Show debug mode state",
 		handler: async (_args, ctx) => {

package/src/log-files.ts

@@ -140,6 +140,13 @@ function truncateActiveLog(activeFile: string): void {
 	throw last;
 }
 
+export function clearActiveLog(debugDir: string): string {
+	fs.mkdirSync(debugDir, { recursive: true });
+	const activeFile = path.join(debugDir, ACTIVE_LOG_FILE);
+	truncateActiveLog(activeFile);
+	return activeFile;
+}
+
 export function prepareRunLog(debugDir: string, previousRun: string | null): string {
 	fs.mkdirSync(debugDir, { recursive: true });
 	const activeFile = path.join(debugDir, ACTIVE_LOG_FILE);

package/src/methodology.ts

@@ -1,5 +1,15 @@
-export const PROCEED_REMINDER =
-	"When done, run /debug-proceed to analyze this round, or /debug-done if the bug is fixed.";
+/**
+ * The widget under the editor names every command already, so prose that
+ * repeats them is the same instruction three times on one screen: the call to
+ * action, the model's own closing line, and the actions strip all said
+ * `/debug-proceed`. A model told to "tell the user to run /debug-proceed" also
+ * writes it into `<reproduction_steps>`, where it becomes a numbered step the
+ * user cannot perform until every other step is done.
+ */
+export const COMMAND_ECHO_RULE =
+	"Do NOT name /debug-proceed or /debug-done in your closing prose or inside <reproduction_steps>: the widget " +
+	"under the user's editor already offers both, and repeating them puts the same instruction on screen three " +
+	"times. Close with one short line saying what to do — reproduce, capture, answer — never which command to type.";
 
 export const EVIDENCE_PLAN_TAG = "evidence_plan";
 
@@ -94,13 +104,13 @@ This is OMP Debug Mode. Follow the steps in order. Do not skip them.
    combined reproduction/capture sequence the USER performs now as the steps
    argument of ${HANDOFF_TOOL} — the widget the user reads is built from that
    call, not from your prose. A <reproduction_steps> numbered list (no header
-   inside the tag) followed by "${PROCEED_REMINDER}" is read as content but
-   closes nothing, so make the call even when you also wrote the prose.
+   inside the tag) is read as content but closes nothing, so make the call even
+   when you also wrote the prose.
    ${CLOSE_ROUND_RULES}
-   Never say "click" or "press Proceed": those buttons do not exist. Name
-   /debug-proceed and /debug-done by those exact commands. Never ask the user to
-   reply "done". Remind them to restart the app or service if the instrumented
-   code would otherwise be stale.
+   ${COMMAND_ECHO_RULE}
+   Never say "click" or "press Proceed": those buttons do not exist, and never
+   ask the user to reply "done". Remind them to restart the app or service if
+   the instrumented code would otherwise be stale.
    Then STOP. The user reproduces out-of-band.
    No logs may be expected for user_report/user_artifact plans: evaluate the
    requested user evidence instead of treating absent probes as a failed round.
@@ -150,7 +160,7 @@ export function buildStartMessage(problem: string, logFile: string): string {
 		"Call list_debug_evidence whenever you need the request/observation/artifact ledger. " +
 		"Cite evidence as hypothesis ID plus log-line number or attached observation/artifact/report path. " +
 		`Then close with ${HANDOFF_TOOL} — prose alone never closes a round, so make the call even if you also wrote ` +
-		`a <${EVIDENCE_PLAN_TAG}> block — tell the user "${PROCEED_REMINDER}" and STOP.`
+		`a <${EVIDENCE_PLAN_TAG}> block. ${COMMAND_ECHO_RULE} Then STOP.`
 	);
 }
 
@@ -187,7 +197,7 @@ export function buildProceedMessage(args: {
 		" " +
 		HANDOFF_RULE +
 		" " +
-		`Then end with ${HANDOFF_TOOL} — prose alone never closes a round — tell the user "${PROCEED_REMINDER}" and STOP.`
+		`Then end with ${HANDOFF_TOOL} — prose alone never closes a round. ${COMMAND_ECHO_RULE} Then STOP.`
 	);
 }
 

package/src/state.ts

@@ -499,9 +499,9 @@ export function stageBriefing(session: DebugSession): string {
 			"finishing the turn in which you just called hand_off_to_user, or you were resumed by a reminder or " +
 			"another automatic continuation. Either way the user has not acted, no reproduction has run, and no new " +
 			"observation exists. Do not read logs, do not analyze, do not resume the plan. Write one short line " +
-			"addressed to the user — what to do now, and that /debug-proceed comes after they reproduce (or " +
-			"/debug-done if the bug is already fixed) — then end the turn. Never report " +
-			"that you were reminded and never restate this briefing back to them."
+			"addressed to the user saying what to do now — reproduce, capture, or answer — and end the turn. Do " +
+			"not name /debug-proceed or /debug-done: the widget under their editor already offers both. Never " +
+			"report that you were reminded and never restate this briefing back to them."
 		);
 	}
 	return (

package/src/ui.ts

@@ -28,8 +28,24 @@ export function statusLabel(session: DebugSession): string {
 	return `🐞 round ${round.index} · needs input`;
 }
 
+/**
+ * Clip to terminal columns, not to code units. Reproduction steps are written
+ * in whatever language the user reports the bug in, and a CJK step counts one
+ * unit per character while occupying two columns — measured by `length` a line
+ * of Chinese fits the budget at twice the real width and the host wraps or
+ * truncates it instead.
+ */
 function clip(text: string): string {
-	return text.length > WIDGET_MAX_WIDTH ? `${text.slice(0, WIDGET_MAX_WIDTH - 1)}…` : text;
+	if (Bun.stringWidth(text) <= WIDGET_MAX_WIDTH) return text;
+	let width = 0;
+	let kept = "";
+	for (const char of text) {
+		const next = width + Bun.stringWidth(char);
+		if (next > WIDGET_MAX_WIDTH - 1) break;
+		width = next;
+		kept += char;
+	}
+	return `${kept}…`;
 }
 
 function paint(ctx: ExtensionContext, lines: WidgetLine[]): string[] {
@@ -41,8 +57,15 @@ function clearWidgets(ctx: ExtensionContext): void {
 	ctx.ui.setWidget(WIDGET_ACTIONS_KEY, undefined);
 }
 
-/** Remaining commands after the three exits have their own lines. */
-const OTHER_COMMANDS = "/debug-evidence <request-id|-> <path> · /debug-abort · /debug-status";
+const TIPS_HEADER = "Tips:";
+
+/**
+ * Remaining commands after the exits have their own lines. The `-`
+ * sentinel is deliberately not spelled out here: `<request-id|->` renders as an
+ * arrow next to lines that use `→` to mean "and then this happens", and
+ * the command's own completion offers `-` as its first entry anyway.
+ */
+const OTHER_COMMANDS = "/debug-evidence <request-id> <path> · /debug-clear · /debug-abort · /debug-status";
 
 function plural(count: number, singular: string): string {
 	return `${count} ${singular}${count === 1 ? "" : "s"}`;
@@ -52,20 +75,23 @@ function logEntries(count: number): string {
 	return count === 1 ? "1 log entry" : `${count} log entries`;
 }
 
+/**
+ * What this round wants from the user, without naming a command: the actions
+ * widget sits directly under the editor and names all of them already.
+ */
 function callToAction(mode: HandoffMode): string {
-	if (mode === "reproduce") return "Reproduce the bug now, then /debug-proceed.";
-	if (mode === "capture") return "Supply the requested report or file, then /debug-proceed.";
+	if (mode === "reproduce") return "Reproduce the bug now.";
+	if (mode === "capture") return "Supply the requested report or file.";
 	if (mode === "question") return "Reply in the editor. The agent is waiting on an answer, not a reproduction.";
 	return "The agent stopped without saying what to reproduce or capture.";
 }
 
 /**
  * What `/debug-proceed` does right now, with the numbers it would act on.
- * Naming the real effect is the only way to tell it apart from an ordinary
- * reply, and that difference is what the two former user stages never explained.
+ * The actions strip is a dim cheat-sheet under the editor, so this line never
+ * lights up: captured vs empty is in the wording, not the tone.
  */
 export function proceedLine(session: DebugSession, logCount: number): WidgetLine {
-	const round = currentRound(session);
 	const captured: string[] = [];
 	if (logCount > 0) captured.push(logEntries(logCount));
 	if (session.observations.length > 0) captured.push(plural(session.observations.length, "observation"));
@@ -73,23 +99,14 @@ export function proceedLine(session: DebugSession, logCount: number): WidgetLine
 	return {
 		text: clip(
 			captured.length > 0
-				? `/debug-proceed → close round ${round.index}, analyze ${captured.join(", ")}`
-				: `/debug-proceed → close round ${round.index} with nothing captured yet`,
+				? `/debug-proceed → close this round, analyze ${captured.join(", ")}`
+				: "/debug-proceed → close this round with nothing captured yet",
 		),
-		tone: captured.length > 0 ? "accent" : "warning",
-	};
-}
-
-/** The other half of the same choice, so declining `/debug-proceed` is informed too. */
-export function replyLine(session: DebugSession): WidgetLine {
-	const round = currentRound(session);
-	return {
-		text: clip(`Reply in the editor → round ${round.index} stays open, the run keeps recording`),
 		tone: "dim",
 	};
 }
 
-/** The third exit: the bug is actually gone. */
+/** The other exit: the bug is actually gone. */
 export function doneLine(): WidgetLine {
 	return {
 		text: clip("/debug-done → bug is fixed: remove probes and summarize"),
@@ -97,6 +114,27 @@ export function doneLine(): WidgetLine {
 	};
 }
 
+/** A model ordinal in any of the shapes the prompt's numbered list produces. */
+const LEADING_ORDINAL = /^\s*\d+\s*[.)、]\s*/;
+
+/**
+ * Every step carries the widget's own ordinal. The model numbers its list about
+ * as often as it does not, and an unnumbered run of dim lines reads as one
+ * paragraph rather than as a sequence to work through.
+ */
+export function numberedSteps(steps: readonly string[]): string[] {
+	const kept: string[] = [];
+	for (const step of steps) {
+		// The commands are named once, under the editor. A step that repeats them
+		// is the third copy on one screen, and the prompt forbids writing it.
+		if (/\/debug-(?:proceed|done)\b/i.test(step)) continue;
+		const body = step.replace(LEADING_ORDINAL, "").trim();
+		if (body.length === 0) continue;
+		kept.push(`${kept.length + 1}. ${body}`);
+	}
+	return kept;
+}
+
 function appendFoldedSteps(lines: WidgetLine[], steps: readonly string[]): void {
 	const stepBudget = Math.max(0, WIDGET_MAX_LINES - lines.length);
 	if (stepBudget === 0 || steps.length === 0) return;
@@ -121,27 +159,23 @@ export function userTurnContextLines(
 	for (const request of pendingEvidence.slice(0, 2)) {
 		lines.push({ text: clip(`↪ ${request.id} ${request.title}: ${request.instructions[0] ?? ""}`), tone: "accent" });
 	}
-	const steps = mode === "reproduce" || mode === "capture" ? round.reproductionSteps : [];
+	const steps = mode === "reproduce" || mode === "capture" ? numberedSteps(round.reproductionSteps) : [];
 	appendFoldedSteps(lines, steps);
 	return lines.slice(0, WIDGET_MAX_LINES);
 }
 
 /**
- * Below the editor: the three exits plus the live log counter, sitting next to
- * the prompt so the user does not have to hunt above the transcript for what
- * to type.
+ * Below the editor: a dim cheat-sheet next to the prompt so the user does not
+ * have to hunt above the transcript for what to type. A reply in the editor is
+ * still a legal exit — it just is not listed here, because the editor is
+ * already where that line would have pointed.
  */
 export function userTurnActionLines(session: DebugSession, logCount: number): WidgetLine[] {
-	const round = currentRound(session);
 	return [
+		{ text: TIPS_HEADER, tone: "dim" },
 		proceedLine(session, logCount),
-		replyLine(session),
 		doneLine(),
-		{ text: clip(OTHER_COMMANDS), tone: "accent" },
-		{
-			text: `run ${round.runId ?? "none"} — ${logEntries(logCount)}`,
-			tone: logCount > 0 ? "accent" : "dim",
-		},
+		{ text: clip(OTHER_COMMANDS), tone: "dim" },
 	];
 }