@hank-warren/pi-plan-mode 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @hank-warren/pi-plan-mode
 
+## 1.2.0
+
+### Minor Changes
+
+- 358aa1f: re-read `pi-plan-mode.json` when it changes instead of only at session start
+
+  The settings file was read once per session, so a hand-edit — or a Settings save
+  from another session — did nothing until the next restart. That sat badly next to
+  the plan file, which has been hand-editable and read from disk since 1.0.
+
+  Plan mode now watches the settings file's directory (not the file: saves land
+  through a temp file and an atomic rename, which replaces the inode) and re-reads
+  on a 75 ms debounce, so one save costs one load.
+
+  An unparseable file is still reported and replaced by the defaults at session
+  start. Mid-session it is ignored and the last good settings stay in place: a
+  reload sees the file the moment an editor touches it, so an invalid read is
+  usually a partial write, and there is no context to report it through anyway.
+  Deleting the file mid-session does restore the defaults.
+
+  Session start now also honours the injected `settingsPath` dependency when
+  reading, which previously only the Settings menu used — the two could disagree
+  about which file they were looking at.
+
+## 1.1.1
+
+### Patch Changes
+
+- 7d96995: Make every declared dependency accurate.
+
+  `pi-permission-selector` no longer declares a `@earendil-works/pi-coding-agent` peer dependency. It imports nothing from it — the claim was left over from 1.0.0, which removed the extension and the selector monkey patch and turned the package into a pure library.
+
+  `pi-auto-permissions` floors `@hank-warren/pi-permission-selector` at `^1.1.0` and `pi-plan-mode` floors `@narumitw/pi-tui-kit` at `^0.49.3`, in both cases the lowest version the package is actually tested against. Neither uses a feature the old floor lacked, so nothing changes at install time under caret resolution; the ranges simply no longer claim support that nothing verifies.
+
+  `scripts/validate.py` now enforces that a package's Pi `peerDependencies` are exactly the Pi packages its shipped sources import, in both directions.
+
 ## 1.1.0
 
 ### Minor Changes

package/README.md

@@ -72,6 +72,8 @@ Writes are atomic (temp file plus rename), so a reader never sees a partial plan
 
 Open **Settings** from the `/plan` menu, or edit `$PI_CODING_AGENT_DIR/pi-plan-mode.json` (normally `~/.pi/agent/pi-plan-mode.json`). The file is optional.
 
+The file is read at session start and **re-read whenever it changes**, so a hand-edit — or a save from another session — applies without restarting. Like the plan file itself, it is edited on disk and read from disk.
+
 ```json
 {
   "thinkingLevel": "inherit",
@@ -89,6 +91,8 @@ Open **Settings** from the `/plan` menu, or edit `$PI_CODING_AGENT_DIR/pi-plan-m
 
 Unknown keys are preserved. Settings removed in 1.0 (`defaultPlanTools`, `bashPolicy`, `safeSubcommands`, `implementationPlanRetention`) are ignored rather than treated as errors, so an existing settings file keeps working.
 
+A settings file that does not parse is reported at session start and the defaults are used. Mid-session it is ignored instead, leaving the last good settings in place: an edit is seen the moment your editor touches the file, so an unreadable one is usually a half-finished save rather than what you meant.
+
 ## 🔐 What Plan mode does and does not enforce
 
 Plan mode blocks exactly three tools while planning: `edit`, `write`, and `update_plan`. That is the whole enforcement surface.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-plan-mode",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Plan mode for Pi: research and design with a durable plan file that survives compaction.",
   "type": "module",
   "keywords": [
@@ -42,6 +42,6 @@
     "@earendil-works/pi-tui": "*"
   },
   "dependencies": {
-    "@narumitw/pi-tui-kit": "^0.49.1"
+    "@narumitw/pi-tui-kit": "^0.49.3"
   }
 }

package/src/plan-mode.ts

@@ -1,3 +1,5 @@
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
@@ -46,6 +48,7 @@ import {
 	awaitPlanModeSettingsWrites,
 	configuredThinkingLevel,
 	type PlanModeSettings,
+	planModeSettingsPath,
 	readPlanModeSettings,
 } from "./settings.js";
 import { type PlanModeState, restorePlanModeState } from "./state.js";
@@ -58,6 +61,12 @@ const STATE_ENTRY_TYPE = "plan-mode-state";
  * mutates the active tool set and never fights other extensions for it.
  */
 const BLOCKED_TOOLS = new Set(["edit", "write", "update_plan"]);
+/**
+ * One hand-edit or menu save fans out into several filesystem events (temp file
+ * created, renamed into place). Collapsing them into one re-read keeps a save
+ * to a single load.
+ */
+const SETTINGS_RELOAD_DEBOUNCE_MS = 75;
 
 /**
  * Which question tool the prompt should name this turn.
@@ -124,6 +133,8 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 	let workflowGeneration = 0;
 	let refreshStateBeforeFirstAgentStart = false;
 	let menuController = new AbortController();
+	let settingsWatch: ReturnType<typeof watch> | undefined;
+	let settingsReloadTimer: ReturnType<typeof setTimeout> | undefined;
 	const persistState = () => pi.appendEntry<PlanModeState>(STATE_ENTRY_TYPE, state);
 	const planExports = createPlanExportController({
 		getState: () => state,
@@ -295,6 +306,73 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 		},
 	});
 
+	const readRuntimeSettings = () =>
+		dependencies.readSettings?.() ?? readPlanModeSettings(dependencies.settingsPath);
+
+	/**
+	 * `ctx` present means this is the session-start load: problems are reported
+	 * and anything unusable falls back to defaults.
+	 *
+	 * `ctx` absent means a watch-triggered reload, which keeps the last good
+	 * settings when the file no longer parses. A hand-edit is observed the moment
+	 * the editor touches the file, so an invalid read is usually a half-written
+	 * save rather than intent — discarding a working export path for it, with no
+	 * `ctx` to explain why, would be worse than waiting for the next write. A
+	 * genuinely broken file is still reported at the next session start.
+	 */
+	const loadPlanModeSettings = async (generation: number, ctx?: ExtensionContext) => {
+		const loaded = await readRuntimeSettings();
+		if (generation !== menuGeneration || menuController.signal.aborted) return;
+		if (loaded.kind === "invalid" && !ctx) return;
+		settings = loaded.kind === "loaded" ? loaded.settings : { thinkingLevel: "inherit" };
+		if (!ctx) return;
+		if (loaded.kind === "invalid") {
+			ctx.ui.notify(`pi-plan-mode settings ignored: ${loaded.reason}`, "warning");
+		}
+		if (loaded.notice) ctx.ui.notify(loaded.notice, "warning");
+	};
+
+	const stopPlanModeSettingsWatch = () => {
+		if (settingsReloadTimer) {
+			clearTimeout(settingsReloadTimer);
+			settingsReloadTimer = undefined;
+		}
+		settingsWatch?.close();
+		settingsWatch = undefined;
+	};
+
+	/**
+	 * Watches the settings file's directory rather than the file itself: saves go
+	 * through a temp file and an atomic rename, and a watch bound to the old inode
+	 * would go deaf after the first one.
+	 */
+	const startPlanModeSettingsWatch = (generation: number) => {
+		stopPlanModeSettingsWatch();
+		if (dependencies.readSettings) return;
+		const watchedPath = dependencies.settingsPath ?? planModeSettingsPath();
+		const watchedFile = basename(watchedPath);
+		try {
+			const watcher = watch(dirname(watchedPath), { persistent: false }, (event, changedFile) => {
+				if (event !== "rename" && event !== "change") return;
+				// A null filename means the platform could not name the entry; reload
+				// rather than miss the edit. The agent directory holds other churn, so
+				// a named entry that is not ours is ignored.
+				if (changedFile && changedFile.toString() !== watchedFile) return;
+				if (settingsReloadTimer) clearTimeout(settingsReloadTimer);
+				settingsReloadTimer = setTimeout(() => {
+					settingsReloadTimer = undefined;
+					void loadPlanModeSettings(generation);
+				}, SETTINGS_RELOAD_DEBOUNCE_MS);
+			});
+			watcher.on("error", stopPlanModeSettingsWatch);
+			settingsWatch = watcher;
+		} catch {
+			// An unwatchable directory only costs the live reload; settings still
+			// load at session start.
+			stopPlanModeSettingsWatch();
+		}
+	};
+
 	pi.on("session_start", async (event, ctx) => {
 		const generation = ++menuGeneration;
 		refreshStateBeforeFirstAgentStart = event.reason === "new";
@@ -305,13 +383,9 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 		settings = { thinkingLevel: "inherit" };
 		sessionPlanPath = resolveSessionPlanPath(ctx);
 		restoreState(ctx);
-		const loadedSettings = await (dependencies.readSettings?.() ?? readPlanModeSettings());
+		await loadPlanModeSettings(generation, ctx);
 		if (generation !== menuGeneration || menuController.signal.aborted) return;
-		if (loadedSettings.kind === "loaded") settings = loadedSettings.settings;
-		else if (loadedSettings.kind === "invalid") {
-			ctx.ui.notify(`pi-plan-mode settings ignored: ${loadedSettings.reason}`, "warning");
-		}
-		if (loadedSettings.notice) ctx.ui.notify(loadedSettings.notice, "warning");
+		startPlanModeSettingsWatch(generation);
 		const persistFlagActivation = pi.getFlag("plan") === true && !state.enabled;
 		if (persistFlagActivation) {
 			state = { ...state, enabled: true, awaitingAction: state.planPath !== undefined };
@@ -336,6 +410,7 @@ export default function planMode(pi: ExtensionAPI, dependencies: PlanModeDepende
 
 	pi.on("session_shutdown", async (_event, ctx) => {
 		menuGeneration += 1;
+		stopPlanModeSettingsWatch();
 		menuController.abort(new DOMException("Plan-mode session shut down", "AbortError"));
 		pendingReadyNonce = undefined;
 		latestCommandContext = undefined;