@oh-my-pi/pi-coding-agent 15.7.2 → 15.7.5

package/src/modes/components/user-message.ts

@@ -1,5 +1,6 @@
 import { Container, Markdown, Spacer } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
+import { highlightMagicKeywords } from "../magic-keywords";
 
 // OSC 133 shell integration: marks prompt zones for terminal multiplexers
 const OSC133_ZONE_START = "\x1b]133;A\x07";
@@ -13,9 +14,15 @@ export class UserMessageComponent extends Container {
 	constructor(text: string, synthetic = false) {
 		super();
 		const bgColor = (value: string) => theme.bg("userMessageBg", value);
+		// Paint the magic keywords ("ultrathink"/"orchestrate"/"workflow") inside the rendered
+		// bubble too — matching the live editor glow. The Markdown component routes code spans and
+		// fenced blocks through its own code styling (never `color`), so those are already excluded;
+		// `highlightMagicKeywords` additionally restores the bubble's own foreground after each
+		// painted keyword so the gradient never bleeds into the rest of the line.
+		const keywordReset = theme.getFgAnsi("userMessageText") || "\x1b[39m";
 		const color = synthetic
 			? (value: string) => theme.fg("dim", value)
-			: (value: string) => theme.fg("userMessageText", value);
+			: (value: string) => theme.fg("userMessageText", highlightMagicKeywords(value, keywordReset));
 		this.addChild(new Spacer(1));
 		this.addChild(
 			new Markdown(text, 1, 1, getMarkdownTheme(), {

package/src/modes/controllers/command-controller.ts

@@ -39,6 +39,7 @@ import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
 import type { NewSessionOptions } from "../../session/session-manager";
+import { formatShakeSummary, type ShakeMode, type ShakeResult } from "../../session/shake-types";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
@@ -1122,6 +1123,30 @@ export class CommandController {
 		return this.executeCompaction(customInstructions, false);
 	}
 
+	/**
+	 * TUI handler for `/shake`. `elide` drops heavy structural content and
+	 * `images` strips image blocks. Rebuilds the chat and reports counts.
+	 */
+	async handleShakeCommand(mode: ShakeMode): Promise<void> {
+		let result: ShakeResult;
+		try {
+			result = await this.ctx.session.shake(mode);
+		} catch (error) {
+			this.ctx.showError(`Shake failed: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+
+		const dropped = result.toolResultsDropped + result.blocksDropped + (result.imagesDropped ?? 0);
+		if (dropped === 0) {
+			this.ctx.showStatus("Nothing to shake.");
+			return;
+		}
+		this.ctx.rebuildChatFromMessages();
+		this.ctx.statusLine.invalidate();
+		this.ctx.updateEditorTopBorder();
+		this.ctx.showStatus(formatShakeSummary(result));
+	}
+
 	async handleSkillCommand(skillPath: string, args: string): Promise<void> {
 		try {
 			const content = await Bun.file(skillPath).text();

package/src/modes/controllers/event-controller.ts

@@ -25,6 +25,19 @@ type AgentSessionEventKind = AgentSessionEvent["type"];
 
 const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
 
+// Events that change foreground streaming state, or that reset a turn. The TUI
+// eager native-scrollback rebuild mode is recomputed only on these so unrelated
+// IRC/notices/status refreshes do not toggle scrollback replay policy.
+const STREAM_RENDER_MODE_EVENTS: Record<string, true> = {
+	agent_start: true,
+	agent_end: true,
+	message_start: true,
+	message_end: true,
+	tool_execution_start: true,
+	tool_execution_update: true,
+	tool_execution_end: true,
+};
+
 type AgentSessionEventHandlers = {
 	[E in AgentSessionEventKind]: (event: Extract<AgentSessionEvent, { type: E }>) => Promise<void>;
 };
@@ -35,6 +48,7 @@ export class EventController {
 	#renderedCustomMessages = new Set<string>();
 	#lastIntent: string | undefined = undefined;
 	#backgroundToolCallIds = new Set<string>();
+	#assistantMessageStreaming = false;
 	#readToolCallArgs = new Map<string, Record<string, unknown>>();
 	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
@@ -158,12 +172,37 @@ export class EventController {
 
 		const run = this.#handlers[event.type] as (e: AgentSessionEvent) => Promise<void>;
 		await run(event);
+		// While assistant text or a foreground tool is streaming, rows above the
+		// viewport can re-layout after they have already entered native scrollback
+		// (Markdown fences, wrapping, previews). Let the TUI rebuild history on
+		// those offscreen edits instead of deferring, which otherwise leaves stale
+		// tail rows duplicated above the live viewport.
+		// Background-running tools are excluded so late async updates outside the
+		// active foreground stream keep the no-yank deferral; agent_start resets
+		// the mode at every turn boundary.
+		if (STREAM_RENDER_MODE_EVENTS[event.type]) {
+			this.#refreshToolRenderMode();
+		}
+	}
+
+	#refreshToolRenderMode(): void {
+		let foregroundToolActive = this.#assistantMessageStreaming;
+		if (!foregroundToolActive) {
+			for (const toolCallId of this.ctx.pendingTools.keys()) {
+				if (!this.#backgroundToolCallIds.has(toolCallId)) {
+					foregroundToolActive = true;
+					break;
+				}
+			}
+		}
+		this.ctx.ui.setEagerNativeScrollbackRebuild(foregroundToolActive);
 	}
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
 		this.#lastIntent = undefined;
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
+		this.#assistantMessageStreaming = false;
 		this.#lastAssistantComponent = undefined;
 		if (this.ctx.retryEscapeHandler) {
 			this.ctx.editor.onEscape = this.ctx.retryEscapeHandler;
@@ -236,6 +275,7 @@ export class EventController {
 			this.ctx.ui.requestRender();
 		} else if (event.message.role === "assistant") {
 			this.#lastThinkingCount = 0;
+			this.#assistantMessageStreaming = true;
 			this.#resetReadGroup();
 			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock, () =>
 				this.ctx.ui.requestRender(),
@@ -382,6 +422,9 @@ export class EventController {
 
 	async #handleMessageEnd(event: Extract<AgentSessionEvent, { type: "message_end" }>): Promise<void> {
 		if (event.message.role === "user") return;
+		if (event.message.role === "assistant") {
+			this.#assistantMessageStreaming = false;
+		}
 		if (this.ctx.streamingComponent && event.message.role === "assistant") {
 			this.ctx.streamingMessage = event.message;
 			let errorMessage: string | undefined;
@@ -564,8 +607,8 @@ export class EventController {
 			}
 		}
 	}
-
 	async #handleAgentEnd(_event: Extract<AgentSessionEvent, { type: "agent_end" }>): Promise<void> {
+		this.#assistantMessageStreaming = false;
 		if (this.ctx.loadingAnimation) {
 			this.ctx.loadingAnimation.stop();
 			this.ctx.loadingAnimation = undefined;
@@ -610,7 +653,12 @@ export class EventController {
 					: event.reason === "idle"
 						? "Idle "
 						: "";
-		const actionLabel = event.action === "handoff" ? "Auto-handoff" : "Auto context-full maintenance";
+		const actionLabel =
+			event.action === "handoff"
+				? "Auto-handoff"
+				: event.action === "shake"
+					? "Auto-shake"
+					: "Auto context-full maintenance";
 		this.ctx.autoCompactionLoader = new Loader(
 			this.ctx.ui,
 			spinner => theme.fg("accent", spinner),
@@ -634,8 +682,25 @@ export class EventController {
 			this.ctx.statusContainer.clear();
 		}
 		const isHandoffAction = event.action === "handoff";
+		const isShakeAction = event.action === "shake";
 		if (event.aborted) {
-			this.ctx.showStatus(isHandoffAction ? "Auto-handoff cancelled" : "Auto context-full maintenance cancelled");
+			this.ctx.showStatus(
+				isHandoffAction
+					? "Auto-handoff cancelled"
+					: isShakeAction
+						? "Auto-shake cancelled"
+						: "Auto context-full maintenance cancelled",
+			);
+		} else if (isShakeAction) {
+			// Shake produces no CompactionResult; rebuild on success, suppress benign skips.
+			if (event.errorMessage) {
+				this.ctx.showWarning(event.errorMessage);
+			} else if (!event.skipped) {
+				this.ctx.rebuildChatFromMessages();
+				this.ctx.statusLine.invalidate();
+				this.ctx.updateEditorTopBorder();
+				this.ctx.showStatus("Auto-shake completed");
+			}
 		} else if (event.result) {
 			this.ctx.rebuildChatFromMessages();
 			this.ctx.statusLine.invalidate();

package/src/modes/controllers/input-controller.ts

@@ -8,7 +8,6 @@ import { renderSegmentTrack } from "../../modes/components/segment-track";
 import { TinyTitleDownloadProgressComponent } from "../../modes/components/tiny-title-download-progress";
 import { expandEmoticons } from "../../modes/emoji-autocomplete";
 import { createPromptActionAutocompleteProvider } from "../../modes/prompt-action-autocomplete";
-import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../session/messages";
@@ -91,6 +90,7 @@ export class InputController {
 			Boolean(
 				this.ctx.loadingAnimation ||
 					this.ctx.hasActiveBtw() ||
+					this.ctx.hasActiveOmfg() ||
 					this.ctx.session.isStreaming ||
 					this.ctx.session.isCompacting ||
 					this.ctx.session.isGeneratingHandoff ||
@@ -114,6 +114,9 @@ export class InputController {
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
 			}
+			if (this.ctx.hasActiveOmfg() && this.ctx.handleOmfgEscape()) {
+				return;
+			}
 			if (this.ctx.loadingAnimation) {
 				if (this.ctx.cancelPendingSubmission()) {
 					return;
@@ -161,9 +164,9 @@ export class InputController {
 		this.ctx.editor.setActionKeys("app.thinking.cycle", this.ctx.keybindings.getKeys("app.thinking.cycle"));
 		this.ctx.editor.onCycleThinkingLevel = () => this.cycleThinkingLevel();
 		this.ctx.editor.setActionKeys("app.model.cycleForward", this.ctx.keybindings.getKeys("app.model.cycleForward"));
-		this.ctx.editor.onCycleModelForward = () => this.cycleRoleModel();
+		this.ctx.editor.onCycleModelForward = () => this.cycleRoleModel("forward");
 		this.ctx.editor.setActionKeys("app.model.cycleBackward", this.ctx.keybindings.getKeys("app.model.cycleBackward"));
-		this.ctx.editor.onCycleModelBackward = () => this.cycleRoleModel({ temporary: true });
+		this.ctx.editor.onCycleModelBackward = () => this.cycleRoleModel("backward");
 		this.ctx.editor.setActionKeys(
 			"app.model.selectTemporary",
 			this.ctx.keybindings.getKeys("app.model.selectTemporary"),
@@ -180,7 +183,6 @@ export class InputController {
 		this.ctx.editor.onToggleThinking = () => this.ctx.toggleThinkingBlockVisibility();
 		this.ctx.editor.setActionKeys("app.editor.external", this.ctx.keybindings.getKeys("app.editor.external"));
 		this.ctx.editor.onExternalEditor = () => void this.openExternalEditor();
-		this.ctx.editor.onShowHotkeys = () => this.ctx.handleHotkeysCommand();
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.pasteImage",
 			this.ctx.keybindings.getKeys("app.clipboard.pasteImage"),
@@ -606,6 +608,9 @@ export class InputController {
 		if (this.ctx.hasActiveBtw()) {
 			this.ctx.handleBtwEscape();
 		}
+		if (this.ctx.hasActiveOmfg()) {
+			this.ctx.handleOmfgEscape();
+		}
 
 		this.ctx.isBackgrounded = true;
 		const backgroundUiContext = this.ctx.createBackgroundUiContext();
@@ -760,10 +765,10 @@ export class InputController {
 		}
 	}
 
-	async cycleRoleModel(options?: { temporary?: boolean }): Promise<void> {
+	async cycleRoleModel(direction: "forward" | "backward" = "forward"): Promise<void> {
 		try {
 			const cycleOrder = settings.get("cycleOrder");
-			const result = await this.ctx.session.cycleRoleModels(cycleOrder, options);
+			const result = await this.ctx.session.cycleRoleModels(cycleOrder, direction);
 			if (!result) {
 				this.ctx.showStatus("Only one role model available");
 				return;
@@ -773,14 +778,12 @@ export class InputController {
 			this.ctx.updateEditorBorderColor();
 			// The status line already reports the resolved model + thinking level, so
 			// the cycle status is just a status-line-style chip track (active role
-			// filled), matching the plan-approval model slider. A dim suffix flags a
-			// temporary switch since that isn't shown elsewhere.
+			// filled), matching the plan-approval model slider.
 			const track = renderSegmentTrack(
 				cycleOrder.map(role => ({ label: role, color: getRoleInfo(role, settings).color })),
 				cycleOrder.indexOf(result.role),
 			);
-			const tempLabel = options?.temporary ? theme.fg("dim", "  (temporary)") : "";
-			this.ctx.showStatus(`${track}${tempLabel}`, { dim: false });
+			this.ctx.showStatus(track, { dim: false });
 		} catch (error) {
 			this.ctx.showError(error instanceof Error ? error.message : String(error));
 		}
@@ -797,7 +800,7 @@ export class InputController {
 				child.setExpanded(expanded);
 			}
 		}
-		this.ctx.ui.requestRender();
+		this.ctx.ui.requestRender(false, { allowUnknownViewportMutation: true });
 	}
 
 	toggleThinkingBlockVisibility(): void {

package/src/modes/controllers/mcp-command-controller.ts

@@ -1425,7 +1425,7 @@ export class MCPCommandController {
 		this.#showMessage(["", theme.fg("muted", `Reconnecting to "${name}"...`), ""].join("\n"));
 
 		try {
-			const connection = await this.ctx.mcpManager.reconnectServer(name);
+			const connection = await this.ctx.mcpManager.reconnectServer(name, { manual: true });
 			if (connection) {
 				// refreshMCPTools re-registers tools and preserves the user's prior
 				// MCP tool selection. No need to call activateDiscoveredMCPTools —

package/src/modes/controllers/omfg-controller.ts

@@ -0,0 +1,283 @@
+import * as path from "node:path";
+import { CONFIG_DIR_NAME, prompt } from "@oh-my-pi/pi-utils";
+import type { Rule } from "../../capability/rule";
+import omfgUserPrompt from "../../prompts/system/omfg-user.md" with { type: "text" };
+import { shortenPath } from "../../tools/render-utils";
+import { OmfgPanelComponent } from "../components/omfg-panel";
+import type { InteractiveModeContext } from "../types";
+import {
+	buildOmfgRuleForPath,
+	extractGeneratedRuleJson,
+	type OmfgRuleSourceLevel,
+	type ParsedGeneratedRule,
+	parseGeneratedRule,
+	validateParsedRuleAgainstAssistantHistory,
+} from "./omfg-rule";
+
+interface OmfgRequest {
+	component: OmfgPanelComponent;
+	abortController: AbortController;
+	complaint: string;
+}
+
+interface OmfgCandidate extends ParsedGeneratedRule {
+	validated: boolean;
+}
+
+interface GenerateCandidateOptions {
+	initialFeedback?: string;
+	previousRule?: string;
+}
+
+type SaveCandidateResult = { kind: "saved" | "aborted" | "rejected" } | { kind: "amend"; feedback: string };
+
+const MAX_ATTEMPTS = 3;
+const PROJECT_OPTION = "This project (.omp/rules)";
+const GLOBAL_OPTION = "Global — all projects (~/.omp/agent/rules)";
+const AMEND_OPTION = "Amend with feedback…";
+
+export class OmfgController {
+	#activeRequest: OmfgRequest | undefined;
+
+	constructor(private readonly ctx: InteractiveModeContext) {}
+
+	hasActiveRequest(): boolean {
+		return this.#activeRequest !== undefined;
+	}
+
+	handleEscape(): boolean {
+		if (!this.#activeRequest) return false;
+		this.#closeActiveRequest({ abort: this.#activeRequest.abortController.signal.aborted === false });
+		return true;
+	}
+
+	dispose(): void {
+		this.#closeActiveRequest({ abort: true });
+	}
+
+	async start(complaint: string): Promise<void> {
+		const trimmedComplaint = complaint.trim();
+		if (!trimmedComplaint) {
+			this.ctx.showStatus("Usage: /omfg <complaint>");
+			return;
+		}
+
+		const model = this.ctx.session.model;
+		if (!model) {
+			this.ctx.showError("No active model available for /omfg.");
+			return;
+		}
+
+		this.#closeActiveRequest({ abort: true });
+
+		const request: OmfgRequest = {
+			component: new OmfgPanelComponent({ complaint: trimmedComplaint, tui: this.ctx.ui }),
+			abortController: new AbortController(),
+			complaint: trimmedComplaint,
+		};
+		this.ctx.omfgContainer.clear();
+		this.ctx.omfgContainer.addChild(request.component);
+		this.ctx.ui.requestRender();
+		this.#activeRequest = request;
+		void this.#runRequest(request);
+	}
+
+	async #runRequest(request: OmfgRequest): Promise<void> {
+		try {
+			let candidate = await this.#generateCandidate(request);
+			for (;;) {
+				if (!this.#isActiveRequest(request)) return;
+				if (!candidate) {
+					request.component.markError("The model did not return a valid TTSR rule.");
+					return;
+				}
+
+				if (!candidate.validated) {
+					request.component.setStatus("confirming", "Couldn't confirm a conversation match.");
+					const shouldSave = await this.ctx.showHookConfirm(
+						"Validation",
+						"Couldn't confirm this rule matches the conversation. Save anyway?",
+					);
+					if (!this.#isActiveRequest(request)) return;
+					if (!shouldSave) {
+						request.component.markRejected();
+						return;
+					}
+				}
+
+				const saveResult = await this.#saveCandidate(request, candidate);
+				if (!this.#isActiveRequest(request)) return;
+				if (saveResult.kind !== "amend") {
+					return;
+				}
+
+				candidate = await this.#generateCandidate(request, {
+					initialFeedback: `User requested this amendment before saving:\n${saveResult.feedback}`,
+					previousRule: candidate.fileContent,
+				});
+			}
+		} catch (error) {
+			if (!this.#isActiveRequest(request)) {
+				return;
+			}
+			if (request.abortController.signal.aborted) {
+				request.component.markAborted();
+				return;
+			}
+			request.component.markError(error instanceof Error ? error.message : String(error));
+		}
+	}
+
+	async #generateCandidate(
+		request: OmfgRequest,
+		options: GenerateCandidateOptions = {},
+	): Promise<OmfgCandidate | undefined> {
+		const failedAttempts = options.initialFeedback ? [options.initialFeedback] : [];
+		let previousRule = options.previousRule;
+		let lastCandidate: ParsedGeneratedRule | undefined;
+
+		for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+			if (this.#shouldStop(request)) return undefined;
+			request.component.setRule("");
+			request.component.setStatus("generating", `Attempt ${attempt}/${MAX_ATTEMPTS} · generating…`);
+			const promptText = prompt.render(omfgUserPrompt, {
+				complaint: request.complaint,
+				feedback: failedAttempts.length > 0 ? failedAttempts.join("\n\n") : undefined,
+				previousRule,
+			});
+			const { replyText } = await this.ctx.session.runEphemeralTurn({
+				promptText,
+				dedupeReply: false,
+				onTextDelta: delta => {
+					if (this.#isActiveRequest(request)) {
+						request.component.appendDraft(delta);
+					}
+				},
+				signal: request.abortController.signal,
+			});
+			if (this.#shouldStop(request)) return undefined;
+
+			const parsed = parseGeneratedRule(replyText);
+			if ("error" in parsed) {
+				const failedRule = extractGeneratedRuleJson(replyText) ?? replyText.trim();
+				failedAttempts.push(
+					`Attempt ${attempt} failed: invalid rule (${parsed.error}).\nFailed candidate:\n${failedRule}`,
+				);
+				previousRule = failedRule;
+				request.component.setStatus("validating", `Attempt ${attempt}/${MAX_ATTEMPTS} · ${parsed.error}`);
+				continue;
+			}
+
+			request.component.setRule(parsed.fileContent);
+			request.component.setStatus("validating", `Attempt ${attempt}/${MAX_ATTEMPTS} · validating…`);
+			const validated = validateParsedRuleAgainstAssistantHistory(parsed, this.ctx.session.messages);
+			if (validated.repairedCondition) {
+				request.component.setRule(validated.candidate.fileContent);
+			}
+			if (validated.validation.matched) {
+				return { ...validated.candidate, validated: true };
+			}
+
+			lastCandidate = validated.candidate;
+			const failure =
+				validated.validation.feedback ?? "The rule condition did not match any earlier assistant output.";
+			failedAttempts.push(
+				`Attempt ${attempt} failed validation:\n${failure}\nFailed candidate:\n${validated.candidate.fileContent}`,
+			);
+			previousRule = validated.candidate.fileContent;
+		}
+
+		return lastCandidate ? { ...lastCandidate, validated: false } : undefined;
+	}
+
+	async #saveCandidate(request: OmfgRequest, candidate: OmfgCandidate): Promise<SaveCandidateResult> {
+		if (this.#shouldStop(request)) return { kind: "aborted" };
+		request.component.setStatus("saving", "Choose where to save or amend the TTSR rule…");
+		const location = await this.ctx.showHookSelector("Save TTSR rule where?", [
+			PROJECT_OPTION,
+			GLOBAL_OPTION,
+			AMEND_OPTION,
+		]);
+		if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+		if (!location) {
+			request.component.markAborted();
+			this.#closeActiveRequest({ abort: false });
+			return { kind: "aborted" };
+		}
+
+		if (location === AMEND_OPTION) {
+			request.component.setStatus("confirming", "Describe how to amend the rule…");
+			const amendment = await this.ctx.showHookInput(
+				"Amend TTSR rule",
+				"e.g. Make it specific to Ruby string eval in tool:write(*.rb)",
+			);
+			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+			const feedback = amendment?.trim();
+			if (!feedback) {
+				request.component.markAborted();
+				this.#closeActiveRequest({ abort: false });
+				return { kind: "aborted" };
+			}
+			return { kind: "amend", feedback };
+		}
+
+		const target = this.#resolveTarget(location, candidate.rule.name);
+		if (await Bun.file(target.filePath).exists()) {
+			const shouldOverwrite = await this.ctx.showHookConfirm(
+				"Overwrite TTSR rule?",
+				`${shortenPath(target.filePath)} already exists. Overwrite it?`,
+			);
+			if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+			if (!shouldOverwrite) {
+				request.component.markRejected();
+				return { kind: "rejected" };
+			}
+		}
+
+		request.component.setStatus("saving", `Saving ${candidate.rule.name}…`);
+		await Bun.write(target.filePath, candidate.fileContent);
+		if (!this.#isActiveRequest(request)) return { kind: "aborted" };
+
+		const savedRule = buildOmfgRuleForPath(candidate.rule.name, candidate.fileContent, target.filePath, target.level);
+		this.#registerLive(savedRule);
+		request.component.markSaved(shortenPath(target.filePath));
+		return { kind: "saved" };
+	}
+
+	#resolveTarget(location: string, ruleName: string): { filePath: string; level: OmfgRuleSourceLevel } {
+		if (location === GLOBAL_OPTION) {
+			return {
+				filePath: path.join(this.ctx.settings.getAgentDir(), "rules", `${ruleName}.md`),
+				level: "user",
+			};
+		}
+		return {
+			filePath: path.join(this.ctx.sessionManager.getCwd(), CONFIG_DIR_NAME, "rules", `${ruleName}.md`),
+			level: "project",
+		};
+	}
+
+	#registerLive(rule: Rule): void {
+		this.ctx.session.ttsrManager?.addRule(rule);
+	}
+
+	#closeActiveRequest(options: { abort: boolean }): void {
+		const request = this.#activeRequest;
+		if (!request) return;
+		this.#activeRequest = undefined;
+		if (options.abort) {
+			request.abortController.abort();
+		}
+		request.component.close();
+		this.ctx.omfgContainer.clear();
+		this.ctx.ui.requestRender();
+	}
+
+	#isActiveRequest(request: OmfgRequest): boolean {
+		return this.#activeRequest === request;
+	}
+
+	#shouldStop(request: OmfgRequest): boolean {
+		return !this.#isActiveRequest(request) || request.abortController.signal.aborted;
+	}
+}