@hheei/omp-optimizer 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [Unreleased]
+
+### Added
+
+- Added the `omp-optimizer` extension with Caveman, RTK, and Ponytail modes behind `/optimizer`.
+- Added OMP-native status-bar, custom UI, session-entry, persistence, and execution integrations.
+
+### Changed
+
+- Updated the optimizer panel to use OMP's native `SettingsList` interaction and theme styling.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 xynogen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @hheei/omp-optimizer
+
+`@hheei/omp-optimizer` is an Oh My Pi extension that combines five tools behind one
+`/optimizer` command:
+
+## Fork provenance
+
+This extension is forked from [`pix-optimizer`](https://github.com/xynogen/pix-mono/tree/main/packages/pix-optimizer) in [`xynogen/pix-mono`](https://github.com/xynogen/pix-mono). It has been adapted for Oh My Pi's public Extension API and does not retain the original pix host integration. The T2S tool is ported from [`@hheei/pi-t2s`](https://github.com/hheei/hepi-mono/tree/main/packages/pi-t2s).
+
+- **Caveman** — injects a terse-output system prompt (`off`, `lite`, `full`,
+  `ultra`, `micro`).
+- **RTK** — injects the RTK prompt and rewrites supported `bash` command chains
+  to use `rtk` when the binary is available. Direct `sudo` segments are blocked
+  so the model can use OMP's `sudo_run` flow when available.
+- **Ponytail** — injects a minimal-code/YAGNI system prompt (`off`, `lite`,
+  `full`, `ultra`).
+- **T2S** — converts interactive Traditional Chinese prose to Simplified Chinese while preserving inline and fenced code (`on`, `off`).
+- **Edit Guard** — when enabled, aborts malformed `apply_patch`/unified-diff `@@` syntax in hashline edits and shell `apply_patch` calls when that tool is unavailable (`on`, `off`).
+
+## Install and load
+
+From this checkout, load the extension file directly:
+
+```text
+packages/hepi/omp-optimizer/src/index.ts
+```
+
+For a published package, the manifest uses OMP's `omp.extensions` field:
+
+```json
+{
+  "omp": {
+    "extensions": ["./src/index.ts"]
+  }
+}
+```
+
+After publishing, install it through OMP:
+
+```bash
+./scripts/omp install @hheei/omp-optimizer
+```
+
+## Usage
+
+Run `/optimizer` and use OMP's configured selection keys (normally `↑↓`) to
+move between tools. `Enter` and `Space` cycle the selected value; `Esc` closes
+the panel. The optional `q` shortcut also closes it. T2S and Edit Guard are
+configured from the same panel. Edit Guard is enabled by default: it blocks
+unified-diff syntax in hashline payloads and shell `apply_patch` calls when
+`apply_patch` is not an active tool. In print/RPC mode, the command emits a
+plain status summary instead of opening the interactive panel.
+
+State is persisted by the extension under the active OMP agent directory as
+`optimizer.json`. Session custom entries are also recorded through
+`pi.appendEntry`, so branch/session navigation can restore the in-session value.
+
+## OMP integration
+
+The implementation uses OMP's public extension APIs and built-in packages:
+
+- `ExtensionAPI` lifecycle hooks and `appendEntry` for prompt injection and
+  session state.
+- `ctx.ui.custom`, `ctx.ui.setStatus`, `ctx.ui.notify`, and the OMP theme for
+  the panel and status bar.
+- `ExtensionAPI.exec` for the RTK availability probe.
+- `@oh-my-pi/pi-utils` for the active agent directory and centralized logging.
+
+No `pix-pretty` or Pi fork compatibility package is required.
+
+The status bar and `/optimizer` panel use Nerd Font glyphs. Use a terminal font
+with Nerd Font support for the intended icons.
+
+## Development
+
+Run the focused tests from the repository root:
+
+```bash
+bun test packages/hepi/omp-optimizer/src
+```
+
+## License
+
+MIT. See `LICENSE`.

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@hheei/omp-optimizer",
+	"version": "0.1.0",
+	"description": "Token-optimization and Traditional-to-Simplified Chinese extension for Oh My Pi",
+	"type": "module",
+	"main": "src/index.ts",
+	"scripts": {
+		"check": "biome check . --no-errors-on-unmatched && tsgo -p tsconfig.json --noEmit",
+		"test": "bun test src"
+	},
+	"omp": {
+		"extensions": ["./src/index.ts"]
+	},
+	"keywords": ["omp", "omp-extension", "optimizer", "caveman", "rtk", "ponytail", "t2s", "traditional-chinese"],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/hheei/oh-my-pi.git",
+		"directory": "packages/hepi/omp-optimizer"
+	},
+	"dependencies": {
+		"opencc-js": "^1.4.0"
+	},
+	"peerDependencies": {
+		"@oh-my-pi/pi-coding-agent": "*",
+		"@oh-my-pi/pi-tui": "*",
+		"@oh-my-pi/pi-ai": "*",
+		"@oh-my-pi/pi-utils": "*"
+	}
+}

package/src/capability.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, mock } from "bun:test";
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { canExecute } from "./capability.ts";
+
+function executor(impl: ExtensionAPI["exec"]): Pick<ExtensionAPI, "exec"> {
+	return { exec: impl };
+}
+
+describe("canExecute", () => {
+	it("runs the requested capability probe without a shell", async () => {
+		const exec = mock(async () => ({
+			stdout: "jq-1.7",
+			stderr: "",
+			code: 0,
+			killed: false,
+		}));
+
+		expect(await canExecute(executor(exec), "jq", ["--version"])).toBe(true);
+		expect(exec).toHaveBeenCalledWith("jq", ["--version"], { timeout: 3000 });
+	});
+
+	it("supports a custom timeout", async () => {
+		const exec = mock(async () => ({ stdout: "rtk 0.30.0", stderr: "", code: 0, killed: false }));
+
+		expect(await canExecute(executor(exec), "rtk", ["--version"], 1000)).toBe(true);
+		expect(exec).toHaveBeenCalledWith("rtk", ["--version"], { timeout: 1000 });
+	});
+
+	it("returns false for a non-zero exit", async () => {
+		const exec = mock(async () => ({ stdout: "", stderr: "failed", code: 1, killed: false }));
+
+		expect(await canExecute(executor(exec), "jq", ["--version"])).toBe(false);
+	});
+
+	it("returns false when the executable cannot be spawned", async () => {
+		const exec = mock(async () => {
+			throw new Error("ENOENT");
+		});
+
+		expect(await canExecute(executor(exec), "rtk", ["--version"])).toBe(false);
+	});
+});

package/src/capability.ts

@@ -0,0 +1,16 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+
+/** Test whether a command can perform a harmless operation through Pi's executor. */
+export async function canExecute(
+	pi: Pick<ExtensionAPI, "exec">,
+	command: string,
+	args: string[],
+	timeout = 3000,
+): Promise<boolean> {
+	try {
+		const result = await pi.exec(command, args, { timeout });
+		return result.code === 0;
+	} catch {
+		return false;
+	}
+}

package/src/caveman.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, it } from "bun:test";
+import {
+	buildHelp,
+	buildPrompt,
+	LEVEL_NUMBERS,
+	LEVELS,
+	type Level,
+	resolveLevel,
+	STATUS_LABELS,
+	STOP_ALIASES,
+	toggleLevel,
+} from "./caveman.ts";
+
+// ── LEVELS ────────────────────────────────────────────────────────────────────
+
+describe("LEVELS", () => {
+	it("contains off as first entry", () => {
+		expect(LEVELS[0]).toBe("off");
+	});
+
+	it("contains all expected levels", () => {
+		const expected: Level[] = ["off", "lite", "full", "ultra", "micro"];
+		for (const l of expected) expect(LEVELS).toContain(l);
+	});
+});
+
+// ── STOP_ALIASES ──────────────────────────────────────────────────────────────
+
+describe("STOP_ALIASES", () => {
+	it("includes off, stop, quit", () => {
+		expect(STOP_ALIASES.has("off")).toBe(true);
+		expect(STOP_ALIASES.has("stop")).toBe(true);
+		expect(STOP_ALIASES.has("quit")).toBe(true);
+	});
+
+	it("does not include active levels", () => {
+		expect(STOP_ALIASES.has("full")).toBe(false);
+		expect(STOP_ALIASES.has("ultra")).toBe(false);
+	});
+});
+
+// ── STATUS_LABELS ─────────────────────────────────────────────────────────────
+
+describe("STATUS_LABELS", () => {
+	it("has a label for every non-off level", () => {
+		const nonOff = LEVELS.filter((l) => l !== "off") as Exclude<Level, "off">[];
+		for (const l of nonOff) {
+			expect(STATUS_LABELS[l]).toBeTruthy();
+		}
+	});
+
+	it("latin levels are uppercase", () => {
+		expect(STATUS_LABELS.lite).toBe("LITE");
+		expect(STATUS_LABELS.full).toBe("FULL");
+		expect(STATUS_LABELS.ultra).toBe("ULTRA");
+		expect(STATUS_LABELS.micro).toBe("MICRO");
+	});
+});
+
+// ── resolveLevel ──────────────────────────────────────────────────────────────
+
+describe("resolveLevel", () => {
+	it("resolves valid levels", () => {
+		expect(resolveLevel("lite")).toBe("lite");
+		expect(resolveLevel("full")).toBe("full");
+		expect(resolveLevel("ultra")).toBe("ultra");
+		expect(resolveLevel("micro")).toBe("micro");
+		expect(resolveLevel("off")).toBe("off");
+	});
+
+	it("maps stop aliases to off", () => {
+		expect(resolveLevel("stop")).toBe("off");
+		expect(resolveLevel("quit")).toBe("off");
+	});
+
+	it("is case-insensitive", () => {
+		expect(resolveLevel("FULL")).toBe("full");
+		expect(resolveLevel("Ultra")).toBe("ultra");
+		expect(resolveLevel("STOP")).toBe("off");
+	});
+
+	it("trims whitespace", () => {
+		expect(resolveLevel("  full  ")).toBe("full");
+	});
+
+	it("returns null for unknown input", () => {
+		expect(resolveLevel("unknown")).toBeNull();
+		expect(resolveLevel("")).toBeNull();
+		expect(resolveLevel("config")).toBeNull(); // config handled separately
+	});
+});
+
+// ── numeric levels ────────────────────────────────────────────────────────────
+
+describe("numeric levels", () => {
+	it("maps 1/2/3 to lite/full/ultra", () => {
+		expect(resolveLevel("1")).toBe("lite");
+		expect(resolveLevel("2")).toBe("full");
+		expect(resolveLevel("3")).toBe("ultra");
+	});
+
+	it("maps 0 to off", () => {
+		expect(resolveLevel("0")).toBe("off");
+	});
+
+	it("LEVEL_NUMBERS only covers 1-3", () => {
+		expect(Object.keys(LEVEL_NUMBERS).sort()).toEqual(["1", "2", "3"]);
+	});
+
+	it("rejects out-of-range numbers", () => {
+		expect(resolveLevel("4")).toBeNull();
+		expect(resolveLevel("9")).toBeNull();
+	});
+
+	it("trims whitespace around numbers", () => {
+		expect(resolveLevel("  2  ")).toBe("full");
+	});
+});
+
+// ── buildHelp ─────────────────────────────────────────────────────────────────
+
+describe("buildHelp", () => {
+	it("lists numeric shortcuts", () => {
+		const help = buildHelp("off");
+		expect(help).toContain("1");
+		expect(help).toContain("lite");
+		expect(help).toContain("2");
+		expect(help).toContain("full");
+		expect(help).toContain("3");
+		expect(help).toContain("ultra");
+	});
+
+	it("shows current level when active", () => {
+		expect(buildHelp("ultra")).toContain("ULTRA");
+	});
+
+	it("shows off when disabled", () => {
+		expect(buildHelp("off")).toContain("off");
+	});
+
+	it("mentions config", () => {
+		expect(buildHelp("off")).toContain("config");
+	});
+
+	it("does not mention wenyan", () => {
+		expect(buildHelp("off").toLowerCase()).not.toContain("wenyan");
+	});
+});
+
+// ── toggleLevel ───────────────────────────────────────────────────────────────
+
+describe("toggleLevel", () => {
+	it("off → full", () => {
+		expect(toggleLevel("off")).toBe("full");
+	});
+
+	it("full → off", () => {
+		expect(toggleLevel("full")).toBe("off");
+	});
+
+	it("any non-off level → off", () => {
+		const nonOff = LEVELS.filter((l) => l !== "off") as Level[];
+		for (const l of nonOff) {
+			expect(toggleLevel(l)).toBe("off");
+		}
+	});
+});
+
+// ── buildPrompt ───────────────────────────────────────────────────────────────
+
+describe("buildPrompt", () => {
+	it("returns empty string for off", () => {
+		expect(buildPrompt("off")).toBe("");
+	});
+
+	it("returns MICRO_PROMPT for micro (no BASE)", () => {
+		const p = buildPrompt("micro");
+		expect(p).toContain("Token efficiency");
+		expect(p).not.toContain("CAVEMAN MODE");
+	});
+
+	it("includes BASE for all standard levels", () => {
+		const standard = ["lite", "full", "ultra"] as Level[];
+		for (const l of standard) {
+			expect(buildPrompt(l)).toContain("CAVEMAN MODE");
+		}
+	});
+
+	it("includes SAFETY clause for all standard levels", () => {
+		const standard = ["lite", "full", "ultra"] as Level[];
+		for (const l of standard) {
+			expect(buildPrompt(l)).toContain("Auto-clarity");
+		}
+	});
+
+	it("each level has distinct intensity instructions", () => {
+		const lite = buildPrompt("lite");
+		const ultra = buildPrompt("ultra");
+		expect(lite).toContain("Keep articles");
+		expect(ultra).toContain("Abbreviate");
+		expect(lite).not.toContain("Abbreviate");
+	});
+});

package/src/caveman.ts

@@ -0,0 +1,140 @@
+/**
+ * caveman.ts — pure logic + Pi extension
+ *
+ * Pure helpers exported for tests; caveman(pi) is the extension entry,
+ * called by index.ts alongside rtk(pi).
+ */
+
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import {
+	createMode,
+	resolveLevel as resolveLevelGeneric,
+	toggleLevel as toggleLevelGeneric,
+} from "./mode.ts";
+import type { OptimizerHandle, OptimizerStatus } from "./status.ts";
+
+// ── Levels ────────────────────────────────────────────────────────────────────
+
+export const LEVELS = ["off", "lite", "full", "ultra", "micro"] as const;
+
+export type Level = (typeof LEVELS)[number];
+
+export const STOP_ALIASES = new Set(["off", "stop", "quit", "0"]);
+
+// Numeric shortcuts: /caveman 1|2|3
+export const LEVEL_NUMBERS: Record<string, Level> = {
+	"1": "lite",
+	"2": "full",
+	"3": "ultra",
+};
+
+// ── Status labels ─────────────────────────────────────────────────────────────
+
+export const STATUS_LABELS: Record<Exclude<Level, "off">, string> = {
+	lite: "LITE",
+	full: "FULL",
+	ultra: "ULTRA",
+	micro: "MICRO",
+};
+
+// ── Prompt fragments ──────────────────────────────────────────────────────────
+
+const BASE = `\
+IMPORTANT: You are in CAVEMAN MODE. Respond terse like smart caveman. \
+All technical substance stay. Only fluff die.
+
+Rules:
+- Drop articles (a/an/the), filler (just/really/basically/actually/simply), \
+pleasantries, hedging
+- Fragments OK. Short synonyms preferred. Technical terms exact
+- Code blocks unchanged. Errors quoted exact
+- Pattern: [thing] [action] [reason]. [next step].
+
+Bad: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Good: "Bug in auth middleware. Token expiry check use \`<\` not \`<=\`. Fix:"`;
+
+const MICRO_PROMPT = `# Token efficiency
+Respond like smart caveman. Cut all filler, keep technical substance.
+- Drop articles (a, an, the), filler (just, really, basically, actually).
+- Drop pleasantries (sure, certainly, happy to).
+- No hedging. Fragments fine. Short synonyms.
+- Technical terms stay exact. Code blocks unchanged.
+- Pattern: [thing] [action] [reason]. [next step].`;
+
+const INTENSITY: Record<Exclude<Level, "off" | "micro">, string> = {
+	lite: `\
+No filler/hedging. Keep articles + full sentences. Professional but tight.
+Example: "Your component re-renders because you create a new object reference each render. Wrap it in \`useMemo\`."`,
+
+	full: `\
+Drop articles, fragments OK, short synonyms.
+Example: "New object ref each render. Inline object prop = new ref = re-render. Wrap in \`useMemo\`."`,
+
+	ultra: `\
+Abbreviate (DB/auth/config/req/res/fn/impl), strip conjunctions, arrows for causality (X → Y).
+Example: "Inline obj prop → new ref → re-render. \`useMemo\`."`,
+};
+
+const SAFETY = `\
+Auto-clarity: drop caveman for security warnings, irreversible action confirmations, \
+or when user is confused. Resume after.
+Boundaries: write normal code. Only compress explanations. "stop caveman" or "normal mode" reverts.`;
+
+/**
+ * Build the system prompt injection for a given level.
+ * Returns empty string when level is "off".
+ */
+export function buildPrompt(level: Level): string {
+	if (level === "off") return "";
+	if (level === "micro") return MICRO_PROMPT;
+	return [BASE, "", `Intensity: ${INTENSITY[level]}`, "", SAFETY].join("\n");
+}
+
+// ── Level resolution ──────────────────────────────────────────────────────────
+
+/**
+ * Resolve a raw command arg to a Level, or return null if unrecognised.
+ * Handles stop aliases (stop/quit → "off") and valid level names.
+ */
+export function resolveLevel(arg: string): Level | null {
+	return resolveLevelGeneric(arg, LEVELS, LEVEL_NUMBERS, STOP_ALIASES);
+}
+
+/**
+ * Help text shown when /caveman is run with no argument.
+ */
+export function buildHelp(current: Level): string {
+	const statusLine = current === "off" ? "off" : `${STATUS_LABELS[current]} (${current})`;
+	return [
+		`Caveman mode: ${statusLine}`,
+		"",
+		"Usage: /caveman <level>",
+		"  1  lite   - professional, no fluff",
+		"  2  full   - classic caveman",
+		"  3  ultra  - maximum compression",
+		"  0  off    - disable (aliases: off, stop, quit)",
+		"",
+		"Other levels: micro",
+		"  config    - open settings dialog",
+	].join("\n");
+}
+
+/**
+ * Toggle: off → full, anything else → off.
+ */
+export function toggleLevel(current: Level): Level {
+	return toggleLevelGeneric(current);
+}
+
+// ── Pi extension ────────────────────────────────────────────────────────────
+
+export function caveman(pi: ExtensionAPI, status: OptimizerStatus): OptimizerHandle {
+	return createMode(pi, status, {
+		name: "caveman",
+		help: "caveman — terse output",
+		levels: LEVELS,
+		buildPrompt,
+		resolve: resolveLevel,
+		notify: (level) => (level === "off" ? "Caveman mode off." : `Caveman: ${STATUS_LABELS[level]}`),
+	});
+}

package/src/edit-guard.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "bun:test";
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { OptimizerStatus } from "./status.ts";
+import { editGuard, hasMalformedHashlineInput, hasStreamingApplyPatchCommand } from "./edit-guard.ts";
+
+const historicalMalformedPayload = `[packages/hepi/omp-optimizer/src/index.ts#C557]\nPUT 2.=12:\n+const value = true;\n@@\nPUT 20.=20:\n+const next = false;`;
+
+function callUpdate(
+	handler: (event: unknown, context: { abort(): void }) => void,
+	name: string,
+	arguments_: Record<string, string>,
+	abort: () => void,
+): void {
+	handler(
+		{
+			assistantMessageEvent: {
+				type: "toolcall_delta",
+				contentIndex: 0,
+				partial: {
+					content: [{ type: "toolCall", name, arguments: arguments_ }],
+				},
+			},
+		},
+		{ abort },
+	);
+}
+
+function makeGuard(activeTools: readonly string[] = ["edit"]) {
+	const handlers = new Map<string, (event: unknown, context?: { abort(): void }) => unknown>();
+	const messages: unknown[] = [];
+	const pi = {
+		events: {},
+		on(event: string, handler: (event: unknown, context?: { abort(): void }) => unknown) {
+			handlers.set(event, handler);
+		},
+		getActiveTools: () => [...activeTools],
+		sendMessage(message: unknown) {
+			messages.push(message);
+		},
+	};
+	editGuard(pi as unknown as ExtensionAPI, { set: () => {} } as unknown as OptimizerStatus);
+	return { handlers, messages };
+}
+
+describe("edit guard detection", () => {
+	it("matches historical bare @@ hashline failures", () => {
+		expect(hasMalformedHashlineInput(historicalMalformedPayload)).toBe(true);
+	});
+
+	it("matches shell apply_patch commands but not plain mentions", () => {
+		expect(hasStreamingApplyPatchCommand("apply_patch <<'PATCH'\n...")).toBe(true);
+		expect(hasStreamingApplyPatchCommand("please do not use apply_patch")).toBe(false);
+	});
+
+	it("ignores valid hashline bodies and other edit formats", () => {
+		expect(hasMalformedHashlineInput("[src/a.ts#ABCD]\nPUT 1.=1:\n+const marker = '@@';")).toBe(false);
+		expect(hasMalformedHashlineInput("[src/a.ts#ABCD]\nPUT 1.=1:\n+@@")).toBe(false);
+		expect(hasMalformedHashlineInput("*** Begin Patch\n*** Update File: src/a.ts\n@@ -1 +1 @@")).toBe(false);
+		expect(hasMalformedHashlineInput("please avoid @@ when editing")).toBe(false);
+	});
+});
+
+describe("edit guard runtime", () => {
+	it("aborts malformed hashline once, then sends retry guidance", () => {
+		const { handlers, messages } = makeGuard();
+		const update = handlers.get("message_update") as (event: unknown, context: { abort(): void }) => void;
+		const settled = handlers.get("agent_end") as (event: { willContinue?: boolean }, context: unknown) => void;
+		let aborts = 0;
+
+		callUpdate(update, "edit", { input: historicalMalformedPayload }, () => {
+			aborts += 1;
+		});
+		callUpdate(update, "edit", { input: `${historicalMalformedPayload}\n@@` }, () => {
+			aborts += 1;
+		});
+		expect(aborts).toBe(1);
+
+		settled({ willContinue: false }, {});
+		expect(messages).toHaveLength(1);
+		expect(messages[0]).toEqual({
+			customType: "edit-guard",
+			content: expect.stringContaining("Do not retry the same payload"),
+			display: true,
+		});
+	});
+
+	it("aborts unavailable shell apply_patch and names active edit alternative", () => {
+		const { handlers, messages } = makeGuard(["edit"]);
+		const update = handlers.get("message_update") as (event: unknown, context: { abort(): void }) => void;
+		const settled = handlers.get("agent_end") as (event: { willContinue?: boolean }, context: unknown) => void;
+		let aborts = 0;
+
+		callUpdate(update, "bash", { command: "apply_patch <<'PATCH'\n..." }, () => {
+			aborts += 1;
+		});
+		expect(aborts).toBe(1);
+		settled({ willContinue: false }, {});
+		expect(messages[0]).toEqual({
+			customType: "edit-guard",
+			content: expect.stringContaining("Continue with `edit`"),
+			display: true,
+		});
+	});
+
+	it("does not block apply_patch when tool is active", () => {
+		const { handlers } = makeGuard(["apply_patch", "edit"]);
+		const update = handlers.get("message_update") as (event: unknown, context: { abort(): void }) => void;
+		let aborts = 0;
+		callUpdate(update, "bash", { command: "apply_patch <<'PATCH'\n..." }, () => {
+			aborts += 1;
+		});
+		expect(aborts).toBe(0);
+	});
+});