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

package/src/presentation.ts

@@ -1,32 +1,23 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readPlanFile } from "./plan-file.js";
 import type { PlanModeState } from "./state.js";
 
 const STATUS_KEY = "plan-mode";
 const PLAN_WIDGET_KEY = "plan-mode-plan";
 
-export function updatePlanModeUi(
-	ctx: ExtensionContext,
-	state: PlanModeState,
-	toolSummary: () => string,
-) {
+export function updatePlanModeUi(ctx: ExtensionContext, state: PlanModeState) {
 	ctx.ui.setStatus(STATUS_KEY, formatStatus(state));
-	if (state.enabled && state.latestPlan) {
+	if (state.enabled && state.awaitingAction) {
 		ctx.ui.setWidget(PLAN_WIDGET_KEY, [
 			"Proposed plan ready",
-			"Use /plan to implement, save, revise, or exit Plan mode.",
+			"Use /plan to implement, export, revise, or exit Plan mode.",
 		]);
 	} else if (state.enabled) {
 		ctx.ui.setWidget(PLAN_WIDGET_KEY, [
 			"Plan mode: planning",
-			toolSummary(),
 			"Finish with plan_mode_complete when decision-ready.",
 		]);
-	} else if (state.savedPlan) {
-		ctx.ui.setWidget(PLAN_WIDGET_KEY, [
-			"Plan saved for later",
-			"Use /plan to show, implement, or clear it.",
-		]);
-	} else if (state.activeImplementation) {
+	} else if (state.planPath) {
 		ctx.ui.setWidget(PLAN_WIDGET_KEY, [
 			"Implementation plan active",
 			"Use /plan to show, replace, or clear it.",
@@ -41,14 +32,15 @@ export function clearPlanModeUi(ctx: ExtensionContext) {
 	ctx.ui.setWidget(PLAN_WIDGET_KEY, undefined);
 }
 
-export function showStoredPlan(pi: ExtensionAPI, ctx: ExtensionContext, state: PlanModeState) {
-	const readyPlan = state.enabled ? state.latestPlan?.trim() : undefined;
-	const savedPlan = state.savedPlan?.plan.trim();
-	if (savedPlan && (ctx.mode === "print" || ctx.mode === "json")) {
-		throw new Error("Saved plan display is unavailable in print/JSON mode. Use TUI or RPC.");
-	}
-	const activePlan = state.activeImplementation?.plan.trim();
-	const plan = readyPlan ?? savedPlan ?? activePlan;
+/**
+ * Always reads the file so a hand-edited plan is what the user sees.
+ */
+export async function showStoredPlan(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	state: PlanModeState,
+) {
+	const plan = state.planPath ? await readPlanFile(state.planPath) : undefined;
 	if (!plan) {
 		ctx.ui.notify(
 			"No completed plan is available. Use /plan finalize when planning is complete.",
@@ -56,11 +48,7 @@ export function showStoredPlan(pi: ExtensionAPI, ctx: ExtensionContext, state: P
 		);
 		return;
 	}
-	const title = readyPlan
-		? "Proposed Plan"
-		: savedPlan
-			? "Saved Plan"
-			: "Active Implementation Plan";
+	const title = state.enabled ? "Proposed Plan" : "Active Implementation Plan";
 	showPlanModePlan(pi, ctx, title, plan);
 }
 
@@ -85,24 +73,17 @@ export function showPlanModePlan(
 	}
 }
 
-export function planModeStatusText(state: PlanModeState, toolSummary: () => string) {
+export function planModeStatusText(state: PlanModeState) {
 	if (state.enabled) {
-		if (state.latestPlan) {
-			return `Plan mode is active and a proposed plan is ready. ${toolSummary()}`;
-		}
-		return `Plan mode is active. ${toolSummary()} Explore, ask, and finish with plan_mode_complete when decision-ready.`;
+		if (state.awaitingAction) return "Plan mode is active and a proposed plan is ready.";
+		return "Plan mode is active. Explore, ask, and finish with plan_mode_complete when decision-ready.";
 	}
-	if (state.savedPlan) return "A plan is saved for later.";
-	if (state.activeImplementation) return "An implementation plan is active.";
+	if (state.planPath) return "An implementation plan is active.";
 	return "Plan mode is off.";
 }
 
 function formatStatus(state: PlanModeState) {
-	if (state.enabled) {
-		if (state.awaitingAction || state.latestPlan) return "plan ready";
-		return "plan active";
-	}
-	if (state.savedPlan) return "plan saved";
-	if (state.activeImplementation) return "plan implementing";
+	if (state.enabled) return state.awaitingAction ? "plan ready" : "plan active";
+	if (state.planPath) return "plan implementing";
 	return undefined;
 }

package/src/prompt.ts

@@ -1,26 +1,18 @@
-import type { PlanModeBashPolicy } from "./settings.js";
+const PLAN_CONTEXT_MARKER = "[PLAN MODE ACTIVE]";
 
-const PLAN_CONTEXT_MARKER = "[CODEX-LIKE PLAN MODE ACTIVE]";
-
-export function buildPlanModePrompt(options: { bashPolicy?: PlanModeBashPolicy } = {}) {
-	const bashPolicy = options.bashPolicy ?? "limited";
-	const bashRule =
-		bashPolicy === "auto-permissions"
-			? "- Bash calls outside Plan Mode's inspection allowlist may be delegated to Auto Permissions when a matching guarded rule is active. Its approval permits information gathering, not implementation: keep every Bash action non-mutating and within the planning request."
-			: "- Bash is limited by Plan Mode's reviewed inspection policy. Use only accepted non-mutating inspection commands.";
+export function buildPlanModePrompt() {
 	return `${PLAN_CONTEXT_MARKER}
 # Plan Mode (Conversational)
 
-You are in Plan Mode, a Codex-like collaboration mode for producing a decision-complete implementation plan. Chat your way to the plan before finalizing it. A final plan must leave no implementation decisions unresolved.
+You are in Plan Mode, a collaboration mode for producing a decision-complete implementation plan. Chat your way to the plan before finalizing it. A final plan must leave no implementation decisions unresolved.
 
 ## Mode rules
 
 - Stay in Plan Mode until a developer or extension explicitly exits it.
 - Treat requests to implement as requests to plan the implementation; do not edit files or carry out the plan.
 - Do not use update_plan/TODO tooling in Plan Mode; Plan Mode is conversational planning, not execution progress tracking.
-- Plan Mode manages built-in tool safety only. Non-built-in tools are disabled by default and may be enabled by the user at their own risk.
-${bashRule}
 - Do not perform mutating actions: no edit/write tools, no patching, no formatting that rewrites files, no dependency installation, no commits, no migrations.
+- Gather information freely: read files, search, inspect configuration, and run read-only commands.
 
 ## Phase 1 — Ground in the environment
 
@@ -63,5 +55,16 @@ Only call plan_mode_complete when the plan leaves no implementation decisions un
 
 Keep the plan concise, human and agent digestible, and free of open decisions. Prefer grouped behavior-level changes over file-by-file or symbol-by-symbol inventories. Do not ask "should I proceed?"; plan_mode_complete opens the Plan-mode ready flow.
 
+The plan is saved to a durable file, so it survives compaction and can be re-read at any time.
+
 If the user requests revisions after a completed plan, the next plan_mode_complete call must contain a complete replacement, not a delta. If there is not enough information for a complete replacement, continue planning with plan_mode_question instead of calling plan_mode_complete.`;
 }
+
+/**
+ * The plan is never injected into context as a payload. While a plan is active
+ * the model gets only this pointer and reads the file on demand, which keeps
+ * compaction survival to a single line regardless of plan size.
+ */
+export function buildActivePlanPointer(planPath: string) {
+	return `[PLAN MODE] An approved implementation plan for this session is stored at ${planPath}. Read that file before implementing, and re-read it if you need the plan again after compaction. The file is the source of truth and the user may have edited it.`;
+}

package/src/settings-menu.ts

@@ -1,17 +1,9 @@
-import type { ExtensionContext, ToolInfo } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, type RunMenuResult, runMenu } from "@narumitw/pi-tui-kit";
-import { PLAN_MODE_COMPLETE_TOOL_NAME } from "./completion-tool.js";
-import { retentionLabel } from "./implementation-retention.js";
 import { planExportDestination } from "./plan-export.js";
-import { PLAN_MODE_QUESTION_TOOL_NAME } from "./question-tool.js";
 import {
-	configuredBashPolicy,
-	configuredImplementationPlanRetention,
 	configuredPlanExportPath,
-	IMPLEMENTATION_PLAN_RETENTIONS,
-	PLAN_MODE_BASH_POLICIES,
 	PLAN_MODE_THINKING_LEVELS,
-	type PlanModeBashPolicy,
 	type PlanModeSettings,
 	type PlanModeSettingsLoadResult,
 	type PlanModeSettingsPatch,
@@ -20,8 +12,6 @@ import {
 	type UpdatePlanModeSettingsOptions,
 	updatePlanModeSettings,
 } from "./settings.js";
-import { canSelectToolInPlanMode } from "./tool-policy.js";
-import { defaultPlanModeToolNames, toolPolicyLabel } from "./tool-selection.js";
 
 interface SettingsMenuState {
 	kind: "valid" | "invalid";
@@ -31,7 +21,6 @@ interface SettingsMenuState {
 }
 
 export interface PlanModeSettingsMenuOptions {
-	tools: readonly ToolInfo[];
 	signal: AbortSignal;
 	isCurrent(): boolean;
 	settingsPath?: string;
@@ -44,16 +33,8 @@ export interface PlanModeSettingsMenuOptions {
 	onSaved(settings: PlanModeSettings): void;
 }
 
-type Screen = "settings" | "tools" | "export";
-type Action =
-	| "set-thinking"
-	| "open-tools"
-	| "toggle-tool"
-	| "reset-tools"
-	| "set-bash-policy"
-	| "set-retention"
-	| "open-export"
-	| "set-export";
+type Screen = "settings" | "export";
+type Action = "set-thinking" | "open-export" | "set-export";
 
 export async function showPlanModeSettings(
 	ctx: ExtensionContext,
@@ -62,10 +43,6 @@ export async function showPlanModeSettings(
 	const settingsPath = options.settingsPath ?? planModeSettingsPath();
 	const readSettings = options.readSettings ?? readPlanModeSettings;
 	const updateSettings = options.updateSettings ?? updatePlanModeSettings;
-	const tools = options.tools.filter(
-		(tool) =>
-			tool.name !== PLAN_MODE_QUESTION_TOOL_NAME && tool.name !== PLAN_MODE_COMPLETE_TOOL_NAME,
-	);
 
 	const loadState = async (): Promise<SettingsMenuState> => {
 		const loaded = await readSettings(options.settingsPath);
@@ -103,33 +80,6 @@ export async function showPlanModeSettings(
 									values: PLAN_MODE_THINKING_LEVELS,
 									action: "set-thinking",
 								},
-								{
-									id: "defaultPlanTools",
-									label: "Plan tools",
-									description:
-										"Choose persistent defaults; a launch-time selection still overrides them for that session.",
-									currentValue: defaultToolsValue(state.settings.defaultPlanTools),
-									action: "open-tools",
-								},
-								{
-									id: "bashPolicy",
-									label: "Bash policy",
-									description:
-										"Use Plan mode's allowlist or selectively defer matching guarded commands to Auto Permissions.",
-									currentValue: bashPolicyLabel(configuredBashPolicy(state.settings)),
-									values: PLAN_MODE_BASH_POLICIES.map(bashPolicyLabel),
-									action: "set-bash-policy",
-								},
-								{
-									id: "implementationPlanRetention",
-									label: "After Implement",
-									description: "Choose how long the accepted plan keeps guiding implementation.",
-									currentValue: retentionLabel(
-										configuredImplementationPlanRetention(state.settings),
-									),
-									values: IMPLEMENTATION_PLAN_RETENTIONS.map(retentionLabel),
-									action: "set-retention",
-								},
 								{
 									id: "defaultPlanExportPath",
 									label: "Export destination",
@@ -139,26 +89,6 @@ export async function showPlanModeSettings(
 								},
 							],
 						},
-			tools: ({ state }) => ({
-				kind: "multiSelect",
-				title: "Default Plan-mode tools",
-				lines: [
-					"Changes apply when a later Plan workflow starts; required Plan tools stay enabled.",
-					"Non-built-in tools run at user risk.",
-				],
-				enableSearch: true,
-				viewportSize: 10,
-				items: defaultToolItems(tools, state.settings.defaultPlanTools),
-				action: "toggle-tool",
-				actions: [
-					{
-						id: "reset-tools",
-						label: "Use automatic safe built-ins",
-						action: "reset-tools",
-					},
-				],
-				hint: "back",
-			}),
 			export: ({ state }) => {
 				const configured = configuredPlanExportPath(state.settings);
 				const destination = planExportDestination(configured, ctx.cwd);
@@ -190,29 +120,6 @@ export async function showPlanModeSettings(
 					`Plan mode thinking level: ${value}. Applies to the next Plan workflow.`,
 				);
 			},
-			"open-tools": async () => ({ kind: "to", screen: "tools" }),
-			"set-bash-policy": async ({ ctx: actionCtx, value, signal }) => {
-				const bashPolicy = bashPolicyFromLabel(value);
-				if (!bashPolicy) return { kind: "rejected" };
-				return savePatch(
-					actionCtx,
-					{ bashPolicy },
-					signal,
-					bashPolicy === "auto-permissions"
-						? "Bash policy: selectively delegated to Auto Permissions guarded rules."
-						: "Bash policy: Plan-mode inspection allowlist.",
-				);
-			},
-			"set-retention": async ({ ctx: actionCtx, value, signal }) => {
-				const implementationPlanRetention = retentionFromLabel(value);
-				if (!implementationPlanRetention) return { kind: "rejected" };
-				return savePatch(
-					actionCtx,
-					{ implementationPlanRetention },
-					signal,
-					`After Implement: ${retentionLabel(implementationPlanRetention)}. Applies to the next Implement action.`,
-				);
-			},
 			"open-export": async () => ({ kind: "to", screen: "export" }),
 			"set-export": async ({ ctx: actionCtx, value, signal }) => {
 				const defaultPlanExportPath = value?.trim() || null;
@@ -226,29 +133,6 @@ export async function showPlanModeSettings(
 				);
 				return result.kind === "stay" ? { kind: "to", screen: "settings" } : result;
 			},
-			"toggle-tool": async ({ ctx: actionCtx, state, itemId, selected, signal }) => {
-				const tool = tools.find((candidate) => candidate.name === itemId);
-				if (!tool || !canSelectToolInPlanMode(tool)) return { kind: "rejected" };
-				const names = explicitToolNames(tools, state.settings.defaultPlanTools);
-				const next = selected
-					? Array.from(new Set([...names, tool.name]))
-					: names.filter((name) => name !== tool.name);
-				return savePatch(
-					actionCtx,
-					{ defaultPlanTools: next },
-					signal,
-					`Default Plan-mode tools: ${next.length === 0 ? "required tools only" : `${next.length} selected`}.`,
-				);
-			},
-			"reset-tools": async ({ ctx: actionCtx, state, signal }) => {
-				if (state.settings.defaultPlanTools === undefined) return { kind: "stay" };
-				return savePatch(
-					actionCtx,
-					{ defaultPlanTools: null },
-					signal,
-					"Default Plan-mode tools: automatic safe built-ins.",
-				);
-			},
 		},
 	});
 
@@ -290,7 +174,7 @@ export async function showPlanModeSettings(
 function settingsLines(settingsPath: string, notice: string | undefined) {
 	return [
 		`User settings · ${safeTerminalText(settingsPath)}`,
-		"Plan defaults apply to the next workflow; handoff and export choices apply to their next action.",
+		"Plan thinking applies to the next workflow; the export destination applies to its next action.",
 		...(notice ? [safeTerminalText(notice)] : []),
 	];
 }
@@ -308,67 +192,6 @@ function invalidScreen(settingsPath: string, state: SettingsMenuState) {
 	};
 }
 
-const BASH_POLICY_LABELS: Record<PlanModeBashPolicy, string> = {
-	limited: "Plan-mode allowlist",
-	"auto-permissions": "Auto Permissions guarded rules",
-};
-
-function bashPolicyLabel(policy: PlanModeBashPolicy) {
-	return BASH_POLICY_LABELS[policy];
-}
-
-function bashPolicyFromLabel(value: string | undefined) {
-	return PLAN_MODE_BASH_POLICIES.find((policy) => bashPolicyLabel(policy) === value);
-}
-
-function retentionFromLabel(value: string | undefined) {
-	return IMPLEMENTATION_PLAN_RETENTIONS.find((retention) => retentionLabel(retention) === value);
-}
-
-function defaultToolsValue(configured: string[] | undefined) {
-	if (configured === undefined) return "Automatic safe built-ins";
-	if (configured.length === 0) return "Required tools only";
-	return `${configured.length} selected`;
-}
-
-function defaultToolItems(tools: readonly ToolInfo[], configured: string[] | undefined) {
-	const selected = new Set(explicitToolNames(tools, configured));
-	const availableNames = new Set(tools.map((tool) => tool.name));
-	const items = tools.map((tool) => {
-		const selectable = canSelectToolInPlanMode(tool);
-		const policy = toolPolicyLabel(tool);
-		const description = tool.description ?? "No description available";
-		return {
-			id: tool.name,
-			label: tool.name,
-			description: `${policy} · ${description}`,
-			searchText: `${policy} ${description}`,
-			selected: selected.has(tool.name),
-			disabled: !selectable,
-			disabledReason: selectable ? undefined : "Blocked by Plan-mode policy",
-		};
-	});
-	for (const name of configured ?? []) {
-		if (availableNames.has(name)) continue;
-		items.push({
-			id: name,
-			label: name,
-			description: "unavailable · Retained in settings but unavailable in this session",
-			searchText: "unavailable retained settings",
-			selected: true,
-			disabled: true,
-			disabledReason: "Unavailable in this session; reset defaults to remove unavailable names",
-		});
-	}
-	return items;
-}
-
-function explicitToolNames(tools: readonly ToolInfo[], configured: string[] | undefined) {
-	return configured === undefined
-		? defaultPlanModeToolNames([...tools], undefined)
-		: [...configured];
-}
-
 function safeTerminalText(value: string) {
 	return [...value]
 		.map((character) => {

package/src/settings.ts

@@ -3,13 +3,6 @@ import { constants } from "node:fs";
 import { mkdir, open, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import {
-	SAFE_GH_SUBCOMMAND_PATHS,
-	SAFE_GIT_SUBCOMMANDS,
-	type SafeGhSubcommandPath,
-	type SafeGitSubcommand,
-	type SafeSubcommands,
-} from "./tool-policy.js";
 
 export const PLAN_MODE_SETTINGS_FILE = "pi-plan-mode.json";
 const LEGACY_PLAN_MODE_SETTINGS_FILE = "plan-mode.json";
@@ -24,33 +17,18 @@ export const PLAN_MODE_THINKING_LEVELS = [
 	"xhigh",
 	"max",
 ] as const;
-export const IMPLEMENTATION_PLAN_RETENTIONS = [
-	"keep",
-	"clear-on-start",
-	"clear-after-first-run",
-] as const;
-export const PLAN_MODE_BASH_POLICIES = ["limited", "auto-permissions"] as const;
 export const DEFAULT_PLAN_EXPORT_PATH = "PLAN.md";
 const MAX_PLAN_EXPORT_PATH_LENGTH = 4096;
 
 export type PlanModeThinkingLevel = (typeof PLAN_MODE_THINKING_LEVELS)[number];
-export type ImplementationPlanRetention = (typeof IMPLEMENTATION_PLAN_RETENTIONS)[number];
-export type PlanModeBashPolicy = (typeof PLAN_MODE_BASH_POLICIES)[number];
 export type PlanModeFixedThinkingLevel = Exclude<PlanModeThinkingLevel, "inherit">;
 export interface PlanModeSettings {
 	thinkingLevel: PlanModeThinkingLevel;
-	defaultPlanTools?: string[];
-	implementationPlanRetention?: ImplementationPlanRetention;
 	defaultPlanExportPath?: string;
-	bashPolicy?: PlanModeBashPolicy;
-	safeSubcommands?: SafeSubcommands;
 }
 export interface PlanModeSettingsPatch {
 	thinkingLevel?: PlanModeThinkingLevel;
-	defaultPlanTools?: readonly string[] | null;
-	implementationPlanRetention?: ImplementationPlanRetention;
 	defaultPlanExportPath?: string | null;
-	bashPolicy?: PlanModeBashPolicy;
 }
 export interface UpdatePlanModeSettingsOptions {
 	settingsPath?: string;
@@ -79,6 +57,12 @@ function legacyPlanModeSettingsPath() {
 	return join(getAgentDir(), LEGACY_PLAN_MODE_SETTINGS_FILE);
 }
 
+/**
+ * Unknown top-level keys are tolerated and preserved on save. Settings removed
+ * in the plan-file rewrite (defaultPlanTools, bashPolicy, safeSubcommands,
+ * implementationPlanRetention) therefore keep an existing file valid instead of
+ * failing it closed on upgrade.
+ */
 export function normalizePlanModeSettings(value: unknown): PlanModeSettings | undefined {
 	if (!isSettingsDocument(value)) return undefined;
 	const thinkingLevel = Object.hasOwn(value, "thinkingLevel")
@@ -90,23 +74,6 @@ export function normalizePlanModeSettings(value: unknown): PlanModeSettings | un
 	const settings: PlanModeSettings = {
 		thinkingLevel: thinkingLevel as PlanModeThinkingLevel,
 	};
-	if (Object.hasOwn(value, "defaultPlanTools")) {
-		const defaultPlanTools = normalizeToolNames(Reflect.get(value, "defaultPlanTools"));
-		if (!defaultPlanTools) return undefined;
-		settings.defaultPlanTools = defaultPlanTools;
-	}
-	if (Object.hasOwn(value, "implementationPlanRetention")) {
-		const implementationPlanRetention = Reflect.get(value, "implementationPlanRetention");
-		if (
-			!IMPLEMENTATION_PLAN_RETENTIONS.includes(
-				implementationPlanRetention as ImplementationPlanRetention,
-			)
-		) {
-			return undefined;
-		}
-		settings.implementationPlanRetention =
-			implementationPlanRetention as ImplementationPlanRetention;
-	}
 	if (Object.hasOwn(value, "defaultPlanExportPath")) {
 		const defaultPlanExportPath = normalizePlanExportPath(
 			Reflect.get(value, "defaultPlanExportPath"),
@@ -114,29 +81,9 @@ export function normalizePlanModeSettings(value: unknown): PlanModeSettings | un
 		if (!defaultPlanExportPath) return undefined;
 		settings.defaultPlanExportPath = defaultPlanExportPath;
 	}
-	if (Object.hasOwn(value, "bashPolicy")) {
-		const bashPolicy = Reflect.get(value, "bashPolicy");
-		if (!PLAN_MODE_BASH_POLICIES.includes(bashPolicy as PlanModeBashPolicy)) return undefined;
-		settings.bashPolicy = bashPolicy as PlanModeBashPolicy;
-	}
-	if (Object.hasOwn(value, "safeSubcommands")) {
-		const safeSubcommands = normalizeSafeSubcommands(Reflect.get(value, "safeSubcommands"));
-		if (!safeSubcommands) return undefined;
-		settings.safeSubcommands = safeSubcommands;
-	}
 	return settings;
 }
 
-function normalizeToolNames(value: unknown) {
-	if (
-		!Array.isArray(value) ||
-		!value.every((item): item is string => typeof item === "string" && item.trim().length > 0)
-	) {
-		return undefined;
-	}
-	return Array.from(new Set(value));
-}
-
 function normalizePlanExportPath(value: unknown) {
 	if (typeof value !== "string") return undefined;
 	const normalized = value.trim();
@@ -154,34 +101,6 @@ function normalizePlanExportPath(value: unknown) {
 	return normalized;
 }
 
-function normalizeSafeSubcommands(value: unknown): SafeSubcommands | undefined {
-	if (!isSettingsDocument(value)) return undefined;
-	if (Object.keys(value).some((key) => key !== "git" && key !== "gh")) return undefined;
-
-	const safeSubcommands: SafeSubcommands = {};
-	if (Object.hasOwn(value, "git")) {
-		const git = normalizeKnownValues(Reflect.get(value, "git"), SAFE_GIT_SUBCOMMANDS);
-		if (!git) return undefined;
-		safeSubcommands.git = git as SafeGitSubcommand[];
-	}
-	if (Object.hasOwn(value, "gh")) {
-		const gh = normalizeKnownValues(Reflect.get(value, "gh"), SAFE_GH_SUBCOMMAND_PATHS);
-		if (!gh) return undefined;
-		safeSubcommands.gh = gh as SafeGhSubcommandPath[];
-	}
-	return safeSubcommands;
-}
-
-function normalizeKnownValues(value: unknown, supported: readonly string[]) {
-	if (
-		!Array.isArray(value) ||
-		!value.every((item): item is string => typeof item === "string" && supported.includes(item))
-	) {
-		return undefined;
-	}
-	return Array.from(new Set(value));
-}
-
 export async function readPlanModeSettings(
 	settingsPath?: string,
 ): Promise<PlanModeSettingsLoadResult> {
@@ -225,18 +144,10 @@ export function updatePlanModeSettings(
 		const current = await readSettingsDocumentForUpdate(settingsPath, legacySettingsPath);
 		const updated: SettingsDocument = { ...current };
 		if (patch.thinkingLevel !== undefined) updated.thinkingLevel = patch.thinkingLevel;
-		if (patch.defaultPlanTools === null) delete updated.defaultPlanTools;
-		else if (patch.defaultPlanTools !== undefined) {
-			updated.defaultPlanTools = [...patch.defaultPlanTools];
-		}
-		if (patch.implementationPlanRetention !== undefined) {
-			updated.implementationPlanRetention = patch.implementationPlanRetention;
-		}
 		if (patch.defaultPlanExportPath === null) delete updated.defaultPlanExportPath;
 		else if (patch.defaultPlanExportPath !== undefined) {
 			updated.defaultPlanExportPath = patch.defaultPlanExportPath;
 		}
-		if (patch.bashPolicy !== undefined) updated.bashPolicy = patch.bashPolicy;
 		const settings = normalizePlanModeSettings(updated);
 		if (!settings) throw invalidSettingsError(settingsPath, "invalid settings shape");
 		await publishSettings(settingsPath, updated, options.signal, options.beforeRename);
@@ -405,16 +316,6 @@ export function configuredThinkingLevel(
 	return settings.thinkingLevel === "inherit" ? undefined : settings.thinkingLevel;
 }
 
-export function configuredImplementationPlanRetention(
-	settings: PlanModeSettings,
-): ImplementationPlanRetention {
-	return settings.implementationPlanRetention ?? "keep";
-}
-
 export function configuredPlanExportPath(settings: PlanModeSettings) {
 	return settings.defaultPlanExportPath ?? DEFAULT_PLAN_EXPORT_PATH;
 }
-
-export function configuredBashPolicy(settings: PlanModeSettings): PlanModeBashPolicy {
-	return settings.bashPolicy ?? "limited";
-}