guardian-framework 0.1.0

package/templates/pi/extensions/plan-mode.ts

@@ -0,0 +1,209 @@
+/**
+ * Plan Mode Extension for pi
+ *
+ * Intercepts mutating tool calls (edit, write_file, create_directory) and queues
+ * them for batch review instead of executing immediately. Shell commands are
+ * refused in plan mode. The user reviews all queued changes as a single diff,
+ * then accepts/rejects in batch.
+ *
+ * Usage: /plan (toggles on/off), /plan on, /plan off
+ */
+
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType } from "@mariozechner/pi-coding-agent";
+
+// ── State ──
+
+interface QueuedEdit {
+	id: string;
+	kind: "edit" | "multi_edit" | "write_file" | "create_directory";
+	filePath: string;
+	originalContent: string;
+	proposedContent: string;
+	isNewFile: boolean;
+	description?: string;
+}
+
+let planModeActive = false;
+const editQueue: QueuedEdit[] = [];
+
+function newEditId(): string {
+	const ts = Date.now().toString(36);
+	const rand = Math.random().toString(36).slice(2, 7);
+	return `qe-${ts}-${rand}`;
+}
+
+// ── Plan mode toggle via slash command interception ──
+
+function handleSlashCommand(input: string): string | null {
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("/plan") && trimmed !== "/plan") return null;
+
+	const args = trimmed.slice(5).trim().toLowerCase();
+	if (args === "off" || args === "exit") {
+		planModeActive = false;
+		editQueue.length = 0;
+		return "✅ Plan mode off. Queue cleared.";
+	}
+	planModeActive = true;
+	return "✅ Plan mode on. Mutations will be queued for review. Use `/plan off` to exit.";
+}
+
+// ── Helper: read file content safely ──
+
+function readFileContent(filePath: string): string {
+	if (!fs.existsSync(filePath)) return "";
+	return fs.readFileSync(filePath, "utf-8");
+}
+
+// ── Helper: hash for tracking ──
+
+function hashContent(content: string): string {
+	return crypto.createHash("sha256").update(content).digest("hex");
+}
+
+// ── Main extension ──
+
+export default function (pi: ExtensionAPI) {
+	pi.on("session_start", async () => {
+		planModeActive = false;
+		editQueue.length = 0;
+	});
+
+	// Intercept user input for slash commands
+	pi.on("input", async (event) => {
+		const input = (event as { input?: string }).input;
+		if (!input) return;
+		const result = handleSlashCommand(input);
+		if (result) {
+			// Inject the status message as a system note
+			event.input = result;
+		}
+	});
+
+	// Intercept tool calls when plan mode is active
+	pi.on("tool_call", async (event, ctx) => {
+		if (!planModeActive) return;
+		if (
+			!isToolCallEventType("bash", event) &&
+			!isToolCallEventType("write", event) &&
+			!isToolCallEventType("edit", event)
+		)
+			return;
+
+		const toolName = event.toolName;
+		const blockedTools = ["bash", "bash_background", "run_command"];
+		if (blockedTools.includes(toolName)) {
+			return {
+				block: true,
+				reason:
+					"Shell commands are not permitted in plan mode. Use /plan off to exit plan mode, or restrict yourself to read-only tools (read_file, grep, list_directory).",
+			};
+		}
+
+		// Intercept write and edit tools
+		if (toolName === "write" || toolName === "edit") {
+			const inputPath = event.input.file_path ?? event.input.path;
+			if (!inputPath) return;
+
+			const absPath = path.isAbsolute(inputPath) ? inputPath : path.join(ctx.cwd, inputPath);
+			const originalContent = readFileContent(absPath);
+			const isNew = !fs.existsSync(absPath);
+
+			// For edit tool, capture proposed content
+			let proposedContent = "";
+			if (toolName === "write") {
+				proposedContent = event.input.content ?? "";
+			} else if (toolName === "edit") {
+				// For edit, we'd need to apply the edit to get proposed content
+				// Store the edit params; actual content computed at review time
+				proposedContent = `[edit queued: ${event.input.old_string?.length ?? 0} chars → ${event.input.new_string?.length ?? 0} chars]`;
+			}
+
+			const queuedEdit: QueuedEdit = {
+				id: newEditId(),
+				kind: toolName as QueuedEdit["kind"],
+				filePath: absPath,
+				originalContent,
+				proposedContent,
+				isNewFile: isNew,
+				description: `${toolName} → ${path.basename(absPath)}`,
+			};
+
+			editQueue.push(queuedEdit);
+
+			// Notify the user via UI status
+			ctx.ui.setStatus("plan-mode", `📋 Plan: ${editQueue.length} edit(s) queued`);
+
+			// Block the tool from executing — it's queued instead
+			return {
+				block: true,
+				reason: `Queued for plan review: ${queuedEdit.description}. ${editQueue.length} edit(s) in queue. Use /plan off to review and apply.`,
+			};
+		}
+	});
+
+	// Register /plan command
+	pi.registerCommand("plan", {
+		description: "Toggle plan mode. Queues file mutations for batch review.",
+		handler: async (_args, ctx) => {
+			if (planModeActive) {
+				planModeActive = false;
+				const count = editQueue.length;
+				editQueue.length = 0;
+				ctx.ui.setStatus("plan-mode", null);
+				ctx.ui.notify(`Plan mode off. ${count} queued edit(s) discarded.`, "warn");
+			} else {
+				planModeActive = true;
+				ctx.ui.setStatus("plan-mode", "📋 Plan mode active");
+				ctx.ui.notify("Plan mode on. All file mutations will be queued for review.", "info");
+			}
+		},
+	});
+
+	// Register /plan-apply command (review and apply queued edits)
+	pi.registerCommand("plan-apply", {
+		description: "Review and apply queued plan mode edits.",
+		handler: async (_args, ctx) => {
+			if (!planModeActive || editQueue.length === 0) {
+				ctx.ui.notify("No queued edits to apply.", "info");
+				return;
+			}
+
+			const summary = editQueue
+				.map(
+					(e, i) =>
+						`${i + 1}. ${e.kind}: ${e.filePath} (${e.isNewFile ? "new" : hashContent(e.originalContent).slice(0, 8)} → ${hashContent(e.proposedContent).slice(0, 8)})`,
+				)
+				.join("\n");
+
+			const confirmed = await ctx.ui.confirm(`Apply ${editQueue.length} queued edit(s)?`, summary);
+
+			if (confirmed) {
+				let applied = 0;
+				for (const edit of editQueue) {
+					try {
+						const dir = path.dirname(edit.filePath);
+						if (!fs.existsSync(dir)) {
+							fs.mkdirSync(dir, { recursive: true });
+						}
+						fs.writeFileSync(edit.filePath, edit.proposedContent, "utf-8");
+						applied++;
+					} catch (err) {
+						ctx.ui.notify(`Failed to apply ${edit.filePath}: ${err}`, "error");
+					}
+				}
+				editQueue.length = 0;
+				ctx.ui.setStatus("plan-mode", null);
+				ctx.ui.notify(`Applied ${applied}/${editQueue.length} edits.`, "success");
+			} else {
+				editQueue.length = 0;
+				ctx.ui.setStatus("plan-mode", null);
+				ctx.ui.notify("All queued edits discarded.", "warn");
+			}
+		},
+	});
+}

package/templates/pi/extensions/project-scaffolder.ts

@@ -0,0 +1,284 @@
+/**
+ * Project Scaffolder Extension for pi
+ *
+ * Scaffolds greenfield project source directories, build configuration,
+ * and CI pipeline FROM architecture decisions.
+ *
+ * This is Epic 0: the first thing run after domain exploration and architecture
+ * decisions are made, before any implementation begins.
+ *
+ * Consistency:
+ *   /domain  → discovers bounded contexts (what to build)
+ *   /project → scaffolds project from architecture (how to structure it)
+ *   /architect → plans and orchestrates epics (how to build it)
+ *
+ * Commands:
+ *   /project create --lang java --buildTool maven --groupId com.mycompany
+ *   /project create --lang typescript --validators ci,tests,security --dryRun
+ *   /project create --lang java --buildTool gradle --force
+ *   /project status
+ */
+
+import { type ExecSyncOptions, execSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import * as path from "node:path";
+import { join } from "node:path";
+
+// ── Types ──
+
+type ExtensionContext = {
+	cwd: string;
+	ui: {
+		notify(message: string, level?: string): void;
+		setStatus(key: string, message: string | null): void;
+		confirm(title: string, message: string): Promise<boolean>;
+	};
+};
+
+type ExtensionAPI = {
+	registerCommand(
+		name: string,
+		options: {
+			description: string;
+			handler(args: string, ctx: ExtensionContext): unknown | Promise<unknown>;
+		},
+	): void;
+};
+
+// ── Helpers ──
+
+const SUPPORTED_LANGUAGES = ["typescript", "rust", "python", "go", "java"] as const;
+const BUILD_TOOLS: Record<string, string[]> = {
+	java: ["maven", "gradle"],
+};
+
+function detectGuardianCommand(ctx: ExtensionContext): string {
+	// Try npx first, then check if local bun project
+	if (existsSync(join(ctx.cwd, "node_modules", ".bin", "guardian-framework"))) {
+		return "npx guardian-framework";
+	}
+	if (existsSync(join(ctx.cwd, "src", "index.ts"))) {
+		return "bun run src/index.ts";
+	}
+	return "npx guardian-framework";
+}
+
+function cmd(
+	base: string,
+	args: Record<string, string | boolean | undefined>,
+): string {
+	const parts = [base];
+	for (const [key, value] of Object.entries(args)) {
+		if (value === undefined || value === false) continue;
+		const flag = key.length === 1 ? `-${key}` : `--${key}`;
+		if (value === true) {
+			parts.push(flag);
+		} else {
+			parts.push(`${flag} "${String(value)}"`);
+		}
+	}
+	return parts.join(" ");
+}
+
+// ── Extension ──
+
+export default function (pi: ExtensionAPI) {
+	pi.registerCommand("project", {
+		description:
+			"Scaffold a greenfield project from architecture decisions. " +
+			"Subcommands: create, status",
+		handler(args: string, ctx: ExtensionContext) {
+			const trimmed = args.trim();
+			const segments = trimmed.split(/\s+/);
+			const subcommand = segments[0];
+
+			// ── /project status ──
+			if (subcommand === "status") {
+				const archDir = join(ctx.cwd, ".pi", "architecture");
+				const modulesDir = join(archDir, "modules");
+				const decisionsDir = join(archDir, "decisions");
+				const srcDir = join(ctx.cwd, "src");
+
+				const lines: string[] = ["## Project Scaffolding Status", ""];
+
+				lines.push(`Architecture directory: ${existsSync(archDir) ? "✅" : "❌"} ${archDir}`);
+				const moduleCount = existsSync(modulesDir) ? readdirSync(modulesDir).filter((f: string) => f.endsWith(".md")).length : 0;
+				const decisionCount = existsSync(decisionsDir) ? readdirSync(decisionsDir).filter((f: string) => f.endsWith(".md")).length : 0;
+				lines.push(`  Modules: ${existsSync(modulesDir) ? `✅ ${moduleCount} module files` : "❌ not found"}`);
+				lines.push(`  Decisions: ${existsSync(decisionsDir) ? `✅ ${decisionCount} ADR files` : "❌ not found"}`);
+				lines.push(`Source directory: ${existsSync(srcDir) ? "✅ exists" : "⚠️  not yet scaffolded"}`);
+
+				lines.push("", "### Available Subcommands", "");
+				lines.push("  /project create --lang <language> [options]");
+				lines.push("    Scaffold project from architecture decisions");
+				lines.push("", "  /project status");
+				lines.push("    Show current scaffolding status");
+
+				ctx.ui.notify("Project scaffolding status", "info");
+				return lines.join("\n");
+			}
+
+			// ── /project create ──
+			if (subcommand === "create") {
+				// Parse flags from remaining args
+				const flagArgs = segments.slice(1);
+				const parsed: Record<string, string | boolean> = {};
+				let i = 0;
+				while (i < flagArgs.length) {
+					const arg = flagArgs[i];
+					if (arg.startsWith("--")) {
+						const key = arg.slice(2);
+						if (flagArgs[i + 1] && !flagArgs[i + 1].startsWith("--")) {
+							parsed[key] = flagArgs[i + 1];
+							i += 2;
+						} else {
+							parsed[key] = true;
+							i += 1;
+						}
+					} else if (arg.startsWith("-") && arg.length === 2) {
+						const key = arg.slice(1);
+						if (flagArgs[i + 1] && !flagArgs[i + 1].startsWith("-")) {
+							parsed[key] = flagArgs[i + 1];
+							i += 2;
+						} else {
+							parsed[key] = true;
+							i += 1;
+						}
+					} else {
+						i += 1;
+					}
+				}
+
+				const lang = String(parsed.lang || parsed.language || "").toLowerCase();
+				const buildTool = String(parsed.buildTool || "").toLowerCase() || undefined;
+
+				// Read groupId from manifest if not passed via CLI (matches guardian CLI behavior)
+				let groupId = String(parsed.groupId || parsed.group || "");
+				if (!groupId) {
+					try {
+						const manifestPath = path.join(ctx.cwd, "guardian-manifest.json");
+						if (fs.existsSync(manifestPath)) {
+							const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+							groupId = manifest.groupId || "";
+						}
+					} catch { /* ignore malformed manifest */ }
+				}
+				if (!groupId) groupId = "com.example";
+				const validators = String(parsed.validators || "ci,tests");
+				const dryRun = parsed.dryRun === true || parsed["dry-run"] === true || parsed.d === true;
+				const force = parsed.force === true || parsed.f === true;
+
+				// Validate language
+				if (!lang || !SUPPORTED_LANGUAGES.includes(lang as typeof SUPPORTED_LANGUAGES[number])) {
+					ctx.ui.notify(
+						`Unsupported language: "${lang || ""}". Supported: ${SUPPORTED_LANGUAGES.join(", ")}`,
+						"error",
+					);
+					return [
+						"Usage: /project create --lang <language> [options]",
+						"",
+						"Required:",
+						`  --lang <name>     Language: ${SUPPORTED_LANGUAGES.join(", ")}`,
+						"",
+						"Options:",
+						"  --buildTool <name>  Build tool (maven|gradle for Java)",
+						"  --groupId <name>    Package prefix (default: com.example)",
+						"  --validators <list> Comma-separated (default: ci,tests)",
+						"  --dryRun            Preview without writing files",
+						"  --force             Override existing project guard",
+					].join("\n");
+				}
+
+				// Validate build tool for language
+				if (lang === "java" && buildTool && !BUILD_TOOLS.java.includes(buildTool)) {
+					ctx.ui.notify(
+						`Unsupported build tool: "${buildTool}". Java supports: ${BUILD_TOOLS.java.join(", ")}`,
+						"error",
+					);
+					return "(project command handled)";
+				}
+
+				const guardianCmd = detectGuardianCommand(ctx);
+				const shellArgs: Record<string, string | boolean | undefined> = {
+					lang,
+					buildTool,
+					groupId,
+					validators,
+				};
+				if (dryRun) shellArgs.dryRun = true;
+				if (force) shellArgs.force = true;
+
+				const fullCmd = cmd(`${guardianCmd} project create`, shellArgs);
+
+				ctx.ui.setStatus("command", `/project create — scaffolding ${lang} project`);
+				ctx.ui.notify(
+					`Scaffolding ${lang} project${buildTool ? ` (${buildTool})` : ""}...`,
+					"info",
+				);
+
+				try {
+					const result = execSync(fullCmd, {
+						cwd: ctx.cwd,
+						encoding: "utf-8",
+						timeout: 60000,
+						stdio: ["pipe", "pipe", "pipe"],
+					} as ExecSyncOptions);
+
+					ctx.ui.setStatus("command", null);
+					ctx.ui.notify(
+						dryRun ? "Dry run complete" : "Project scaffolding complete",
+						"success",
+					);
+
+					return [
+						"## Project Scaffolding Result",
+						"",
+						`Language: ${lang}`,
+						buildTool ? `Build Tool: ${buildTool}` : null,
+						`Group ID: ${groupId}`,
+						`Validators: ${validators}`,
+						dryRun ? "Mode: **Dry Run** (no files written)" : "Mode: **Live**",
+						"",
+						"```",
+						result.trim(),
+						"```",
+						"",
+						dryRun
+							? "Run without --dryRun to create the project."
+							: "Project scaffolded. Next: create architecture module docs and use /architect to plan epics.",
+					]
+						.filter(Boolean)
+						.join("\n");
+				} catch (err) {
+					ctx.ui.setStatus("command", null);
+					const errorMsg = err instanceof Error ? err.message : String(err);
+					ctx.ui.notify(`Project scaffolding failed: ${errorMsg}`, "error");
+					return `Project scaffolding failed:\n\`\`\`\n${errorMsg}\n\`\`\``;
+				}
+			}
+
+			// ── Unknown subcommand ──
+			ctx.ui.notify(
+				[
+					"Usage:",
+					"  /project create --lang java --buildTool maven --groupId com.mycompany",
+					"  /project create --lang typescript --validators ci,tests,security --dryRun",
+					"  /project status",
+				].join("\n"),
+				"info",
+			);
+
+			return [
+				"Available /project subcommands:",
+				"",
+				"  /project create --lang <language> [options]",
+				"    Scaffold project from architecture decisions",
+				"    Required: --lang (typescript, rust, python, go, java)",
+				"    Options: --buildTool, --groupId, --validators, --dryRun, --force",
+				"",
+				"  /project status",
+				"    Show current scaffolding status",
+			].join("\n");
+		},
+	});
+}

package/templates/pi/extensions/read-only-mode.ts

@@ -0,0 +1,192 @@
+/**
+ * Read-Only Mode Extension for pi
+ *
+ * Hard-enforces a tiny tool allowlist: read, grep, find, ls.
+ * Blocks every other tool call while enabled.
+ *
+ * Usage:
+ *   /read-only        → toggle
+ *   /read-only on     → enable
+ *   /read-only off    → disable
+ *   /read-only status → show current state
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+} from "@mariozechner/pi-coding-agent";
+
+const COMMAND_NAME = "read-only";
+const STATUS_KEY = "read-only-mode";
+const WIDGET_KEY = "read-only-mode";
+const READ_ONLY_TOOL_NAMES = ["read", "grep", "find", "ls"] as const;
+
+function getReadOnlyToolNames(pi: ExtensionAPI): string[] {
+	const allToolNames = new Set(pi.getAllTools().map((tool) => tool.name));
+	return READ_ONLY_TOOL_NAMES.filter((name) => allToolNames.has(name));
+}
+
+function updateUi(pi: ExtensionAPI, ctx: ExtensionContext, enabled: boolean): void {
+	if (!enabled) {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		ctx.ui.setWidget(WIDGET_KEY, undefined);
+		return;
+	}
+
+	const tools = getReadOnlyToolNames(pi).join(", ");
+	const theme = ctx.ui.theme;
+	ctx.ui.setStatus(STATUS_KEY, theme.fg("accent", "🔒") + theme.fg("muted", " read-only"));
+	ctx.ui.setWidget(WIDGET_KEY, [theme.fg("muted", `🔒 ${tools || "(none)"}`)]);
+}
+
+function applyReadOnlyTools(pi: ExtensionAPI): void {
+	pi.setActiveTools(getReadOnlyToolNames(pi));
+}
+
+function restoreTools(pi: ExtensionAPI, toolsBefore?: string[]): void {
+	const allToolNames = new Set(pi.getAllTools().map((tool) => tool.name));
+	const toolNames = (toolsBefore ?? pi.getAllTools().map((tool) => tool.name)).filter((name) =>
+		allToolNames.has(name),
+	);
+	pi.setActiveTools(toolNames);
+}
+
+export default function (pi: ExtensionAPI) {
+	let enabled = false;
+	let toolsBeforeReadOnly: string[] | undefined;
+
+	// Register read-only variants of allowed tools (use session cwd)
+	const readTool = createReadTool(process.cwd());
+	pi.registerTool({
+		...readTool,
+		async execute(tc, params, signal, _up, ctx) {
+			return createReadTool(ctx.cwd).execute(tc, params, signal, _up);
+		},
+	});
+
+	const grepTool = createGrepTool(process.cwd());
+	pi.registerTool({
+		...grepTool,
+		async execute(tc, params, signal, _up, ctx) {
+			return createGrepTool(ctx.cwd).execute(tc, params, signal, _up);
+		},
+	});
+
+	const findTool = createFindTool(process.cwd());
+	pi.registerTool({
+		...findTool,
+		async execute(tc, params, signal, _up, ctx) {
+			return createFindTool(ctx.cwd).execute(tc, params, signal, _up);
+		},
+	});
+
+	const lsTool = createLsTool(process.cwd());
+	pi.registerTool({
+		...lsTool,
+		async execute(tc, params, signal, _up, ctx) {
+			return createLsTool(ctx.cwd).execute(tc, params, signal, _up);
+		},
+	});
+
+	function enable(ctx: ExtensionContext): void {
+		if (enabled) {
+			updateUi(pi, ctx, enabled);
+			ctx.ui.notify("Read-only mode is already enabled.", "info");
+			return;
+		}
+		enabled = true;
+		toolsBeforeReadOnly = pi.getActiveTools();
+		applyReadOnlyTools(pi);
+		updateUi(pi, ctx, enabled);
+		ctx.ui.notify(
+			`Read-only mode enabled. Tools: ${getReadOnlyToolNames(pi).join(", ") || "(none)"}.`,
+			"info",
+		);
+	}
+
+	function disable(ctx: ExtensionContext): void {
+		if (!enabled) {
+			updateUi(pi, ctx, enabled);
+			ctx.ui.notify("Read-only mode is already disabled.", "info");
+			return;
+		}
+		enabled = false;
+		restoreTools(pi, toolsBeforeReadOnly);
+		toolsBeforeReadOnly = undefined;
+		updateUi(pi, ctx, enabled);
+		ctx.ui.notify("Read-only mode disabled. Previous tool access restored.", "info");
+	}
+
+	pi.registerCommand(COMMAND_NAME, {
+		description: "Toggle hard-enforced read-only mode",
+		handler: async (args, ctx) => {
+			const action = args.trim().toLowerCase();
+			switch (action) {
+				case "":
+				case "toggle":
+					toggle(ctx);
+					return;
+				case "on":
+				case "enable":
+					enable(ctx);
+					return;
+				case "off":
+				case "disable":
+					disable(ctx);
+					return;
+				case "status":
+					updateUi(pi, ctx, enabled);
+					ctx.ui.notify(
+						enabled
+							? `Read-only mode is ON. Allowed: ${getReadOnlyToolNames(pi).join(", ") || "(none)"}.`
+							: "Read-only mode is OFF.",
+						"info",
+					);
+					return;
+				default:
+					ctx.ui.notify(`Usage: /${COMMAND_NAME} [on|off|toggle|status]`, "warning");
+			}
+		},
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		if (!enabled) {
+			updateUi(pi, ctx, enabled);
+			return;
+		}
+		applyReadOnlyTools(pi);
+		updateUi(pi, ctx, enabled);
+		const tools = getReadOnlyToolNames(pi).join(", ") || "(none)";
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n[Read-only mode is active]\n- You may only use these tools: ${tools}.\n- You must not attempt any action that changes local files, processes, git state, dependencies, databases, remote systems, or any other external state.\n- If the user asks for any write or side-effecting action, explain that read-only mode is enabled and tell them to run /${COMMAND_NAME} off first.`,
+		};
+	});
+
+	pi.on("tool_call", async (event) => {
+		if (!enabled) return;
+		const allowed = new Set(getReadOnlyToolNames(pi));
+		if (allowed.has(event.toolName)) return;
+		return {
+			block: true,
+			reason: `Read-only mode is active. Tool "${event.toolName}" is blocked. Allowed: ${Array.from(allowed).join(", ") || "(none)"}. Use /${COMMAND_NAME} off to restore full tool access.`,
+		};
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		if (enabled) applyReadOnlyTools(pi);
+		updateUi(pi, ctx, enabled);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		if (enabled) applyReadOnlyTools(pi);
+		updateUi(pi, ctx, enabled);
+	});
+
+	pi.on("session_fork", async (_event, ctx) => {
+		if (enabled) applyReadOnlyTools(pi);
+		updateUi(pi, ctx, enabled);
+	});
+}