@hank-warren/pi-plan-mode 0.1.0 → 1.0.0

package/src/state.ts

@@ -1,39 +1,15 @@
-import {
-	normalizePlanModeCompletion,
-	PLAN_MODE_COMPLETE_TOOL_NAME,
-	planFromCompletionDetails,
-} from "./completion-tool.js";
-import {
-	IMPLEMENTATION_PLAN_RETENTIONS,
-	type ImplementationPlanRetention,
-	PLAN_MODE_THINKING_LEVELS,
-	type PlanModeFixedThinkingLevel,
-} from "./settings.js";
-
-export type PlanCompletionSource = typeof PLAN_MODE_COMPLETE_TOOL_NAME | "legacy_proposed_plan";
-
-export interface ActiveImplementationPlan {
-	id: string;
-	plan: string;
-	source: PlanCompletionSource;
-	startedAt: number;
-	retention?: ImplementationPlanRetention;
-}
-
-export interface SavedPlan {
-	plan: string;
-	source: PlanCompletionSource;
-}
+import { PLAN_MODE_THINKING_LEVELS, type PlanModeFixedThinkingLevel } from "./settings.js";
 
+/**
+ * The plan lives on disk, so session state carries only a pointer to it plus
+ * the thinking-level bookkeeping needed to restore the user's level on exit.
+ */
 export interface PlanModeState {
 	enabled: boolean;
-	latestPlan?: string;
-	latestPlanSource?: PlanCompletionSource;
+	/** Absolute path to the durable plan file, once a plan has been written. */
+	planPath?: string;
+	/** A completed plan is waiting for the user to choose how to proceed. */
 	awaitingAction: boolean;
-	savedPlan?: SavedPlan;
-	activeImplementation?: ActiveImplementationPlan;
-	selectedToolNames?: string[];
-	selectedToolKeys?: string[];
 	previousThinkingLevel?: PlanModeFixedThinkingLevel;
 	appliedThinkingLevel?: PlanModeFixedThinkingLevel;
 	manualThinkingLevel?: PlanModeFixedThinkingLevel;
@@ -43,49 +19,26 @@ type SessionEntry = {
 	type?: string;
 	customType?: string;
 	data?: unknown;
-	message?: {
-		role?: string;
-		toolName?: string;
-		details?: unknown;
-	};
 };
 
 export function restorePlanModeState(entries: unknown[], stateEntryType: string): PlanModeState {
 	const branch = entries as SessionEntry[];
-	let stateEntryIndex = -1;
+	let entry: SessionEntry | undefined;
 	for (let index = branch.length - 1; index >= 0; index -= 1) {
 		const candidate = branch[index];
 		if (candidate?.type === "custom" && candidate.customType === stateEntryType) {
-			stateEntryIndex = index;
+			entry = candidate;
 			break;
 		}
 	}
-	const entry = branch[stateEntryIndex];
 	if (!isRecord(entry?.data)) return { enabled: false, awaitingAction: false };
 
 	const enabled = entry.data.enabled === true;
-	const persistedSource = enabled ? planCompletionSource(entry.data.latestPlanSource) : undefined;
-	const persistedPlan = enabled ? normalizePersistedPlan(entry.data.latestPlan) : undefined;
-	const recoveredPlan =
-		enabled && !persistedPlan ? latestCompletionPlan(branch.slice(stateEntryIndex + 1)) : undefined;
-	const latestPlan = persistedPlan ?? recoveredPlan;
-	const activeImplementation = enabled
-		? undefined
-		: normalizeActiveImplementation(entry.data.activeImplementation);
-	const savedPlan =
-		enabled || activeImplementation ? undefined : normalizeSavedPlan(entry.data.savedPlan);
+	const planPath = absolutePath(entry.data.planPath);
 	return {
 		enabled,
-		latestPlan,
-		latestPlanSource: enabled
-			? ((persistedPlan ? persistedSource : undefined) ??
-				(recoveredPlan ? PLAN_MODE_COMPLETE_TOOL_NAME : undefined))
-			: undefined,
-		awaitingAction: enabled && latestPlan !== undefined,
-		savedPlan,
-		activeImplementation,
-		selectedToolNames: stringArray(entry.data.selectedToolNames),
-		selectedToolKeys: stringArray(entry.data.selectedToolKeys),
+		planPath,
+		awaitingAction: enabled && entry.data.awaitingAction === true && planPath !== undefined,
 		previousThinkingLevel: enabled
 			? fixedThinkingLevel(entry.data.previousThinkingLevel)
 			: undefined,
@@ -94,58 +47,15 @@ export function restorePlanModeState(entries: unknown[], stateEntryType: string)
 	};
 }
 
-function normalizeSavedPlan(value: unknown): SavedPlan | undefined {
-	if (!isRecord(value)) return undefined;
-	const source = planCompletionSource(value.source);
-	const normalized = normalizePlanModeCompletion({ plan: value.plan });
-	if (!source || !normalized.ok) return undefined;
-	return { plan: normalized.plan, source };
-}
-
-function normalizeActiveImplementation(value: unknown): ActiveImplementationPlan | undefined {
-	if (!isRecord(value)) return undefined;
-	const id =
-		typeof value.id === "string" && /^[A-Za-z0-9._:-]{1,128}$/u.test(value.id)
-			? value.id
-			: undefined;
-	const source = planCompletionSource(value.source);
-	const normalized = normalizePlanModeCompletion({ plan: value.plan });
-	const startedAt =
-		typeof value.startedAt === "number" &&
-		Number.isSafeInteger(value.startedAt) &&
-		value.startedAt >= 0
-			? value.startedAt
-			: undefined;
-	if (!id || !source || !normalized.ok || startedAt === undefined) return undefined;
-	const retention = IMPLEMENTATION_PLAN_RETENTIONS.includes(
-		value.retention as ImplementationPlanRetention,
-	)
-		? (value.retention as ImplementationPlanRetention)
-		: "keep";
-	return { id, plan: normalized.plan, source, startedAt, retention };
-}
-
-function normalizePersistedPlan(value: unknown) {
-	const normalized = normalizePlanModeCompletion({ plan: value });
-	return normalized.ok ? normalized.plan : undefined;
-}
-
-function latestCompletionPlan(entries: SessionEntry[]) {
-	for (let index = entries.length - 1; index >= 0; index -= 1) {
-		const message = entries[index]?.message;
-		if (message?.role !== "toolResult" || message.toolName !== PLAN_MODE_COMPLETE_TOOL_NAME) {
-			continue;
-		}
-		const plan = planFromCompletionDetails(message.details);
-		if (plan) return plan;
-	}
-	return undefined;
-}
-
-function planCompletionSource(value: unknown): PlanCompletionSource | undefined {
-	return value === PLAN_MODE_COMPLETE_TOOL_NAME || value === "legacy_proposed_plan"
-		? value
-		: undefined;
+/**
+ * Persisted paths are only trusted when they are absolute and free of NUL, so
+ * malformed state can never redirect a read or a delete to a relative target.
+ */
+function absolutePath(value: unknown) {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim();
+	if (!normalized || normalized.includes("\0") || !normalized.startsWith("/")) return undefined;
+	return normalized;
 }
 
 function fixedThinkingLevel(value: unknown): PlanModeFixedThinkingLevel | undefined {
@@ -156,12 +66,6 @@ function fixedThinkingLevel(value: unknown): PlanModeFixedThinkingLevel | undefi
 		: undefined;
 }
 
-function stringArray(value: unknown) {
-	return Array.isArray(value) && value.every((item): item is string => typeof item === "string")
-		? Array.from(new Set(value))
-		: undefined;
-}
-
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/auto-permissions-delegation.ts

@@ -1,122 +0,0 @@
-import { CONFIG_DIR_NAME, getAgentDir, type ToolInfo } from "@earendil-works/pi-coding-agent";
-import { readFileSync } from "node:fs";
-import { resolve, join } from "node:path";
-
-const AUTO_PERMISSIONS_CONFIG = "pi-auto-permissions/config.json";
-const AUTO_PERMISSIONS_TOOL = "request_override";
-const AUTO_PERMISSIONS_SOURCE_MARKERS = [
-	"/@ogulcancelik/pi-auto-permissions/",
-	"/@hank-warren/pi-auto-permissions/",
-	"/packages/pi-auto-permissions/",
-];
-
-interface DelegationContext {
-	tools: readonly ToolInfo[];
-	trustedGroups: ReadonlySet<string>;
-	configPath?: string;
-}
-
-interface GuardedRule {
-	pattern: RegExp;
-	group: string;
-	level: "guarded" | "convention";
-}
-
-/**
- * Fail-closed compatibility check for @ogulcancelik/pi-auto-permissions 0.1.x
- * and compatible forks (@hank-warren/pi-auto-permissions). Plan mode stands
- * down only when that extension is loaded and its current configuration will
- * guard this exact command.
- */
-export function shouldDelegateBashToAutoPermissions(
-	command: string,
-	context: DelegationContext,
-): boolean {
-	if (!autoPermissionsIsLoaded(context.tools)) return false;
-
-	try {
-		const config = readConfig(context.configPath);
-		if (!config.enabled) return false;
-		return config.rules.some((rule) => {
-			if (rule.level !== "guarded" || context.trustedGroups.has(rule.group)) return false;
-			rule.pattern.lastIndex = 0;
-			return rule.pattern.test(command);
-		});
-	} catch {
-		return false;
-	}
-}
-
-export function autoPermissionsIsLoaded(tools: readonly ToolInfo[]): boolean {
-	const tool = tools.find((candidate) => candidate.name === AUTO_PERMISSIONS_TOOL);
-	const path = tool?.sourceInfo?.path?.replaceAll("\\", "/");
-	if (!path) return false;
-	return AUTO_PERMISSIONS_SOURCE_MARKERS.some((marker) => path.includes(marker));
-}
-
-function readConfig(configPath?: string) {
-	const path = configPath
-		? resolve(configPath)
-		: process.env.PI_AUTO_PERMISSIONS_CONFIG
-			? resolve(process.env.PI_AUTO_PERMISSIONS_CONFIG)
-			: join(getAgentDir(), AUTO_PERMISSIONS_CONFIG);
-	const raw = JSON.parse(readFileSync(path, "utf8")) as unknown;
-	if (!isRecord(raw)) throw new Error("Auto Permissions config must be an object");
-	if (raw.enabled !== undefined && typeof raw.enabled !== "boolean") {
-		throw new Error("Auto Permissions enabled must be boolean");
-	}
-	if (raw.rules !== undefined && !Array.isArray(raw.rules)) {
-		throw new Error("Auto Permissions rules must be an array");
-	}
-	return {
-		enabled: raw.enabled !== false,
-		rules: (raw.rules ?? []).map(compileRule),
-	};
-}
-
-function compileRule(value: unknown, index: number): GuardedRule {
-	if (!isRecord(value)) throw new Error(`Auto Permissions rules[${index}] must be an object`);
-	const pattern = nonEmptyString(value.pattern);
-	const group = nonEmptyString(value.group);
-	const label = nonEmptyString(value.label);
-	if (!pattern || !group || !label) {
-		throw new Error(`Auto Permissions rules[${index}] is incomplete`);
-	}
-	const flags = value.flags ?? "i";
-	if (typeof flags !== "string") throw new Error(`Auto Permissions rules[${index}] flags invalid`);
-	const level = value.level ?? "guarded";
-	if (level !== "guarded" && level !== "convention") {
-		throw new Error(`Auto Permissions rules[${index}] level invalid`);
-	}
-	const message = nonEmptyString(value.message);
-	if (value.message !== undefined && !message) {
-		throw new Error(`Auto Permissions rules[${index}] message invalid`);
-	}
-	if (level === "convention" && !message) {
-		throw new Error(`Auto Permissions rules[${index}] convention message required`);
-	}
-	return { pattern: new RegExp(pattern, flags), group, level };
-}
-
-export function snapshotAutoPermissionsTrustedGroups(cwd: string, projectTrusted: boolean) {
-	const groups = new Set<string>();
-	if (!projectTrusted) return groups;
-	try {
-		const content = readFileSync(join(cwd, CONFIG_DIR_NAME, "trusted-ops"), "utf8");
-		for (const line of content.split("\n")) {
-			const value = line.trim();
-			if (value && !value.startsWith("#")) groups.add(value);
-		}
-	} catch {
-		// Match Auto Permissions: missing or unreadable means no trusted groups.
-	}
-	return groups;
-}
-
-function nonEmptyString(value: unknown) {
-	return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/implementation-retention.ts

@@ -1,122 +0,0 @@
-import {
-	injectActiveImplementationContext,
-	isEmptyAssistantMessage,
-	messageContainsExactPlanModeImplementationHandoff,
-	messageContainsInactivePlanModeArtifact,
-	messageContainsLegacyPlanModeContextArtifact,
-	messageContainsPlanModeImplementationContextArtifact,
-	messageContainsPlanModeImplementationHandoff,
-	stripPlanModeCompletionCallsFromMessage,
-	stripProposedPlanBlocksFromMessage,
-} from "./message-transform.js";
-import type { ImplementationPlanRetention } from "./settings.js";
-import type { ActiveImplementationPlan, PlanModeState } from "./state.js";
-
-export function retentionLabel(retention: ImplementationPlanRetention) {
-	return {
-		keep: "Keep plan active",
-		"clear-on-start": "Use plan for handoff only",
-		"clear-after-first-run": "Clear after first implementation run",
-	}[retention];
-}
-
-export function implementationRetentionPreview(retention: ImplementationPlanRetention) {
-	return {
-		keep: "After Implement: Keep plan active until /plan exit.",
-		"clear-on-start":
-			"After Implement: Use the plan for the implementation handoff only, then clear it.",
-		"clear-after-first-run": "After Implement: Clear after the first implementation run settles.",
-	}[retention];
-}
-
-export interface ImplementationContextResult {
-	messages: unknown[];
-	clearActiveImplementationId?: string;
-}
-
-export interface ImplementationRetentionCoordinator {
-	restore(activeImplementation: ActiveImplementationPlan | undefined): void;
-	transformContext(messages: unknown[], state: PlanModeState): ImplementationContextResult;
-	implementationSettled(
-		activeImplementation: ActiveImplementationPlan | undefined,
-	): string | undefined;
-	reset(): void;
-}
-
-export function createImplementationRetentionCoordinator(): ImplementationRetentionCoordinator {
-	let implementationWithDeliveredContext: string | undefined;
-	let restoredImplementationAwaitingContext: string | undefined;
-
-	return {
-		restore(activeImplementation) {
-			restoredImplementationAwaitingContext =
-				activeImplementation && activeImplementation.retention !== "keep"
-					? activeImplementation.id
-					: undefined;
-		},
-		transformContext(messages, state) {
-			const messagesWithoutPlanContext = messages.filter(
-				(message) =>
-					!messageContainsLegacyPlanModeContextArtifact(message) &&
-					!messageContainsPlanModeImplementationContextArtifact(message),
-			);
-			if (state.enabled) {
-				return {
-					messages: messagesWithoutPlanContext.filter(
-						(message) => !messageContainsPlanModeImplementationHandoff(message),
-					),
-				};
-			}
-
-			const activeImplementation = state.activeImplementation;
-			const inactiveMessages = activeImplementation
-				? messagesWithoutPlanContext
-				: messagesWithoutPlanContext.filter(
-						(message) => !messageContainsPlanModeImplementationHandoff(message),
-					);
-			const filteredMessages = inactiveMessages
-				.filter((message) => !messageContainsInactivePlanModeArtifact(message))
-				.map(stripProposedPlanBlocksFromMessage)
-				.map(stripPlanModeCompletionCallsFromMessage)
-				.filter((message) => !isEmptyAssistantMessage(message));
-			if (!activeImplementation) return { messages: filteredMessages };
-
-			const contextualMessages = injectActiveImplementationContext(
-				filteredMessages,
-				activeImplementation,
-			);
-			// A busy /plan implement queues its handoff behind an older run. Do not arm cleanup
-			// until that exact handoff reaches context; a restored session has no older run to drain.
-			const deliveredCurrentHandoff =
-				restoredImplementationAwaitingContext === activeImplementation.id ||
-				filteredMessages.some((message) =>
-					messageContainsExactPlanModeImplementationHandoff(message, activeImplementation.plan),
-				);
-			if (!deliveredCurrentHandoff) return { messages: contextualMessages };
-			restoredImplementationAwaitingContext = undefined;
-
-			if (activeImplementation.retention === "clear-after-first-run") {
-				implementationWithDeliveredContext = activeImplementation.id;
-			}
-			return {
-				messages: contextualMessages,
-				clearActiveImplementationId:
-					activeImplementation.retention === "clear-on-start" ? activeImplementation.id : undefined,
-			};
-		},
-		implementationSettled(activeImplementation) {
-			if (
-				activeImplementation?.retention !== "clear-after-first-run" ||
-				implementationWithDeliveredContext !== activeImplementation.id
-			) {
-				return undefined;
-			}
-			implementationWithDeliveredContext = undefined;
-			return activeImplementation.id;
-		},
-		reset() {
-			implementationWithDeliveredContext = undefined;
-			restoredImplementationAwaitingContext = undefined;
-		},
-	};
-}

package/src/message-transform.ts

@@ -1,232 +0,0 @@
-import { PLAN_MODE_COMPLETE_TOOL_NAME } from "./completion-tool.js";
-import type { ActiveImplementationPlan } from "./state.js";
-
-const PLAN_CONTEXT_MESSAGE_TYPE = "plan-mode-context";
-export const PLAN_IMPLEMENTATION_CONTEXT_MESSAGE_TYPE = "plan-mode-implementation-context";
-const PROPOSED_PLAN_MESSAGE_TYPE = "proposed-plan";
-const PLAN_IMPLEMENTATION_HANDOFF_PREFIX =
-	"Plan mode is now disabled. Full tool access is restored. Implement this proposed plan now:";
-const PROPOSED_PLAN_PATTERN =
-	/^<proposed_plan>[\t ]*\r?\n([\s\S]*?)\r?\n<\/proposed_plan>[\t ]*$/gm;
-const PROPOSED_PLAN_BLOCK_PATTERN =
-	/^<proposed_plan>[\t ]*\r?\n[\s\S]*?\r?\n<\/proposed_plan>[\t ]*$/gm;
-
-export type ProposedPlanParseResult =
-	| { kind: "absent" }
-	| { kind: "valid"; plan: string }
-	| { kind: "empty" }
-	| { kind: "multiple" }
-	| { kind: "malformed" }
-	| { kind: "unclosed" };
-
-type SessionMessage = {
-	role?: string;
-	content?: unknown;
-};
-
-type TextBlock = {
-	type?: string;
-	text?: string;
-};
-
-export function parseProposedPlan(text: string): ProposedPlanParseResult {
-	const openingCount = text.match(/<proposed_plan>/gi)?.length ?? 0;
-	const closingCount = text.match(/<\/proposed_plan>/gi)?.length ?? 0;
-	if (openingCount === 0 && closingCount === 0) return { kind: "absent" };
-	if (openingCount > 1 || closingCount > 1) return { kind: "multiple" };
-	if (openingCount === 1 && closingCount === 0) return { kind: "unclosed" };
-	if (openingCount !== 1 || closingCount !== 1) return { kind: "malformed" };
-
-	const matches = Array.from(text.matchAll(PROPOSED_PLAN_PATTERN));
-	if (matches.length !== 1) return { kind: "malformed" };
-	const plan = matches[0]?.[1]?.trim() ?? "";
-	return plan ? { kind: "valid", plan } : { kind: "empty" };
-}
-
-export function extractProposedPlan(text: string) {
-	const result = parseProposedPlan(text);
-	return result.kind === "valid" ? result.plan : undefined;
-}
-
-export function invalidPlanMessage(kind: "empty" | "multiple" | "malformed" | "unclosed") {
-	const detail = {
-		empty: "the block is empty",
-		multiple: "more than one plan block was produced",
-		malformed: "the tags must be on their own lines",
-		unclosed: "the closing tag is missing",
-	}[kind];
-	return `Proposed plan is not ready: ${detail}. Continue Plan mode and produce one complete non-empty <proposed_plan> block.`;
-}
-
-export function latestAssistantText(messages: unknown) {
-	if (!Array.isArray(messages)) return "";
-	for (const entry of [...messages].reverse()) {
-		const message = (entry as { message?: SessionMessage })?.message ?? (entry as SessionMessage);
-		if (message?.role !== "assistant") continue;
-		const text = messageText(message);
-		if (text) return text;
-	}
-	return "";
-}
-
-export function messageContainsLegacyPlanModeContextArtifact(message: unknown) {
-	return unwrapSessionMessage(message).customType === PLAN_CONTEXT_MESSAGE_TYPE;
-}
-
-export function messageContainsPlanModeImplementationContextArtifact(message: unknown) {
-	return unwrapSessionMessage(message).customType === PLAN_IMPLEMENTATION_CONTEXT_MESSAGE_TYPE;
-}
-
-export function injectActiveImplementationContext(
-	messages: unknown[],
-	activeImplementation: ActiveImplementationPlan,
-) {
-	let foundCurrentHandoff = false;
-	const messagesWithoutStaleContext = messages.filter((message) => {
-		if (messageContainsPlanModeImplementationContextArtifact(message)) return false;
-		if (!messageContainsPlanModeImplementationHandoff(message)) return true;
-		if (
-			!foundCurrentHandoff &&
-			messageContainsExactPlanModeImplementationHandoff(message, activeImplementation.plan)
-		) {
-			foundCurrentHandoff = true;
-			return true;
-		}
-		return false;
-	});
-	if (foundCurrentHandoff) return messagesWithoutStaleContext;
-
-	let insertionIndex = 0;
-	while (isSummaryMessage(messagesWithoutStaleContext[insertionIndex])) insertionIndex += 1;
-	const contextMessage = {
-		role: "custom" as const,
-		customType: PLAN_IMPLEMENTATION_CONTEXT_MESSAGE_TYPE,
-		content: `[ACTIVE IMPLEMENTATION PLAN]\n\nThe user approved the exact implementation plan below. Continue following it until the user explicitly clears or supersedes it. The exact plan is the remainder of this message:\n\n${activeImplementation.plan}`,
-		display: false,
-		timestamp: activeImplementation.startedAt,
-	};
-	return [
-		...messagesWithoutStaleContext.slice(0, insertionIndex),
-		contextMessage,
-		...messagesWithoutStaleContext.slice(insertionIndex),
-	];
-}
-
-export function messageContainsInactivePlanModeArtifact(message: unknown) {
-	const candidate = unwrapSessionMessage(message);
-	return (
-		candidate.customType === PROPOSED_PLAN_MESSAGE_TYPE ||
-		(candidate.role === "toolResult" && candidate.toolName === PLAN_MODE_COMPLETE_TOOL_NAME)
-	);
-}
-
-export function messageContainsPlanModeImplementationHandoff(message: unknown) {
-	const candidate = unwrapSessionMessage(message);
-	return (
-		candidate.role === "user" &&
-		contentText(candidate.content).trimStart().startsWith(PLAN_IMPLEMENTATION_HANDOFF_PREFIX)
-	);
-}
-
-export function messageContainsExactPlanModeImplementationHandoff(message: unknown, plan: string) {
-	const candidate = unwrapSessionMessage(message);
-	if (candidate.role !== "user") return false;
-	return (
-		contentText(candidate.content).trim() ===
-		`${PLAN_IMPLEMENTATION_HANDOFF_PREFIX}\n\n${plan}`.trim()
-	);
-}
-
-function isSummaryMessage(message: unknown) {
-	const role = unwrapSessionMessage(message)?.role;
-	return role === "compactionSummary" || role === "branchSummary";
-}
-
-export function stripProposedPlanBlocksFromMessage<T>(message: T): T {
-	return replaceAssistantContent(message, stripProposedPlanBlocksFromContent);
-}
-
-export function stripPlanModeCompletionCallsFromMessage<T>(message: T): T {
-	return replaceAssistantContent(message, (content) => {
-		if (!Array.isArray(content)) return content;
-		const nextContent = content.filter((block) => {
-			const candidate = block as { type?: string; name?: string };
-			return !(candidate.type === "toolCall" && candidate.name === PLAN_MODE_COMPLETE_TOOL_NAME);
-		});
-		return nextContent.length === content.length ? content : nextContent;
-	});
-}
-
-export function isEmptyAssistantMessage(message: unknown) {
-	const candidate = unwrapSessionMessage(message);
-	return (
-		candidate.role === "assistant" &&
-		Array.isArray(candidate.content) &&
-		candidate.content.length === 0
-	);
-}
-
-function replaceAssistantContent<T>(message: T, transform: (content: unknown) => unknown): T {
-	const candidate = unwrapSessionMessage(message);
-	if (candidate.role !== "assistant") return message;
-
-	const content = transform(candidate.content);
-	if (content === candidate.content) return message;
-
-	if (isSessionMessageEntry(message)) {
-		return { ...message, message: { ...candidate, content } };
-	}
-	return { ...candidate, content } as T;
-}
-
-function unwrapSessionMessage(message: unknown) {
-	const entry = message as { message?: unknown } | null | undefined;
-	return (entry?.message ?? message ?? {}) as {
-		role?: string;
-		customType?: string;
-		toolName?: string;
-		content?: unknown;
-	};
-}
-
-function isSessionMessageEntry<T>(message: T): message is T & { message: SessionMessage } {
-	return typeof message === "object" && message !== null && "message" in message;
-}
-
-function stripProposedPlanBlocksFromContent(content: unknown) {
-	if (typeof content === "string") return stripProposedPlanBlocks(content);
-	if (!Array.isArray(content)) return content;
-
-	let changed = false;
-	const nextContent = content.map((block) => {
-		const textBlock = block as TextBlock;
-		if (textBlock.type !== "text" || typeof textBlock.text !== "string") return block;
-
-		const text = stripProposedPlanBlocks(textBlock.text);
-		if (text === textBlock.text) return block;
-
-		changed = true;
-		return { ...textBlock, text };
-	});
-	return changed ? nextContent : content;
-}
-
-export function stripProposedPlanBlocks(text: string) {
-	return text.replace(PROPOSED_PLAN_BLOCK_PATTERN, "");
-}
-
-function messageText(message: SessionMessage) {
-	return contentText(message.content);
-}
-
-function contentText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return "";
-	return content
-		.map((block) => {
-			const textBlock = block as TextBlock;
-			return textBlock.type === "text" && typeof textBlock.text === "string" ? textBlock.text : "";
-		})
-		.filter(Boolean)
-		.join("\n");
-}

package/src/required-tools.ts

@@ -1,22 +0,0 @@
-import { PLAN_MODE_COMPLETE_TOOL_NAME } from "./completion-tool.js";
-import { PLAN_MODE_QUESTION_TOOL_NAME } from "./question-tool.js";
-import { unique } from "./tool-selection.js";
-
-export function withRequiredPlanModeTools(toolNames: string[]) {
-	return unique([
-		...withoutRequiredPlanModeTools(toolNames),
-		PLAN_MODE_QUESTION_TOOL_NAME,
-		PLAN_MODE_COMPLETE_TOOL_NAME,
-	]);
-}
-
-export function withoutPlanModeQuestionTool(toolNames: string[]) {
-	return toolNames.filter((toolName) => toolName !== PLAN_MODE_QUESTION_TOOL_NAME);
-}
-
-export function withoutRequiredPlanModeTools(toolNames: string[]) {
-	return toolNames.filter(
-		(toolName) =>
-			toolName !== PLAN_MODE_QUESTION_TOOL_NAME && toolName !== PLAN_MODE_COMPLETE_TOOL_NAME,
-	);
-}