@davidorex/pi-behavior-monitors 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable changes to this project will be documented in this file.
 
+## v0.1.4
+
+[compare changes](https://github.com/davidorex/pi-behavior-monitors/compare/v0.1.3...v0.1.4)
+
+### 🚀 Enhancements
+
+- Add ui.select menus to /monitors command for TUI discoverability ([4391ca3](https://github.com/davidorex/pi-behavior-monitors/commit/4391ca3))
+
+### 📖 Documentation
+
+- Update SKILL.md with buffered steer delivery and TUI autocomplete ([94aee6e](https://github.com/davidorex/pi-behavior-monitors/commit/94aee6e))
+
+### ❤️ Contributors
+
+- David Ryan <davidryan@gmail.com>
+
+## v0.1.3
+
+[compare changes](https://github.com/davidorex/pi-behavior-monitors/compare/v0.1.2...v0.1.3)
+
+### 🩹 Fixes
+
+- Buffer steer delivery at agent_end to work around pi async event queue ([c899fa5](https://github.com/davidorex/pi-behavior-monitors/commit/c899fa5))
+
+### 📖 Documentation
+
+- Add npm publish commands to CLAUDE.md ([91dbe87](https://github.com/davidorex/pi-behavior-monitors/commit/91dbe87))
+
+### 🏡 Chore
+
+- Scope package name to @davidorex/pi-behavior-monitors ([e9a9882](https://github.com/davidorex/pi-behavior-monitors/commit/e9a9882))
+
+### ❤️ Contributors
+
+- David Ryan <davidryan@gmail.com>
+
 ## v0.1.2
 
 [compare changes](https://github.com/davidorex/pi-behavior-monitors/compare/v0.1.1...v0.1.2)

package/index.ts

@@ -121,6 +121,12 @@ export interface MonitorMessageDetails {
 	ceiling: number;
 }
 
+interface BufferedSteer {
+	monitor: Monitor;
+	details: MonitorMessageDetails;
+	content: string;
+}
+
 type MonitorEvent = "message_end" | "turn_end" | "agent_end" | "command";
 
 const VALID_EVENTS = new Set<string>(["message_end", "turn_end", "agent_end", "command"]);
@@ -896,15 +902,21 @@ async function activate(
 			whileCount: monitor.whileCount + 1,
 			ceiling: monitor.ceiling,
 		};
-		pi.sendMessage<MonitorMessageDetails>(
-			{
-				customType: "monitor-steer",
-				content: `[${monitor.name}] ${description}${annotation}. ${action.steer}`,
-				display: true,
-				details,
-			},
-			{ deliverAs: "steer", triggerTurn: true },
-		);
+		const content = `[${monitor.name}] ${description}${annotation}. ${action.steer}`;
+
+		if (monitor.event === "agent_end" || monitor.event === "command") {
+			// Already post-loop or command context: deliver immediately
+			pi.sendMessage<MonitorMessageDetails>(
+				{ customType: "monitor-steer", content, display: true, details },
+				{ deliverAs: "steer", triggerTurn: true },
+			);
+		} else {
+			// message_end / turn_end: buffer for drain at agent_end
+			// (pi's async event queue means these handlers run after the agent loop
+			// has already checked getSteeringMessages — direct sendMessage misses
+			// the window and the steer arrives one response late)
+			pendingAgentEndSteers.push({ monitor, details, content });
+		}
 	}
 
 	monitor.whileCount++;
@@ -1002,6 +1014,7 @@ export default function (pi: ExtensionAPI) {
 			m.activationCount = 0;
 		}
 		monitorsEnabled = true;
+		pendingAgentEndSteers = [];
 		updateStatus();
 	});
 
@@ -1036,11 +1049,31 @@ export default function (pi: ExtensionAPI) {
 		return box;
 	});
 
-	// --- abort support ---
+	// --- abort support + buffered steer drain ---
 	pi.on("agent_end", async () => {
 		pi.events.emit("monitors:abort", undefined);
+
+		// Drain buffered steers from message_end/turn_end monitors.
+		// The _agentEventQueue guarantees this runs AFTER all turn_end/message_end
+		// handlers complete (sequential promise chain), so the buffer is populated.
+		// Deliver only the first — the corrected response will re-trigger monitors
+		// if additional issues remain.
+		if (pendingAgentEndSteers.length > 0) {
+			const first = pendingAgentEndSteers[0];
+			pendingAgentEndSteers = [];
+			pi.sendMessage<MonitorMessageDetails>(
+				{ customType: "monitor-steer", content: first.content, display: true, details: first.details },
+				{ deliverAs: "steer", triggerTurn: true },
+			);
+		}
 	});
 
+	// --- buffered steers for message_end/turn_end monitors ---
+	// These monitors classify during the agent loop but can't inject steers in time
+	// (pi's async event queue means extension handlers run after the agent loop checks
+	// getSteeringMessages). Buffer steers here, drain at agent_end.
+	let pendingAgentEndSteers: BufferedSteer[] = [];
+
 	// --- per-turn exclusion tracking ---
 	let steeredThisTurn = new Set<string>();
 	pi.on("turn_start", () => { steeredThisTurn = new Set(); });
@@ -1094,8 +1127,43 @@ export default function (pi: ExtensionAPI) {
 	const monitorNames = new Set(monitors.map((m) => m.name));
 	const monitorsByName = new Map(monitors.map((m) => [m.name, m]));
 
+	const monitorVerbs = ["rules", "patterns", "dismiss", "reset"];
+	const rulesActions = ["add", "remove", "replace"];
+
 	pi.registerCommand("monitors", {
 		description: "Manage behavior monitors",
+		getArgumentCompletions(argumentPrefix: string) {
+			const tokens = argumentPrefix.split(/\s+/);
+			const last = tokens[tokens.length - 1];
+
+			// Level 0: no complete token yet — show global commands + monitor names
+			if (tokens.length <= 1) {
+				const items = [
+					{ value: "on", label: "on", description: "Enable all monitoring" },
+					{ value: "off", label: "off", description: "Pause all monitoring" },
+					...Array.from(monitorNames).map((n) => ({ value: n, label: n, description: `${monitorsByName.get(n)?.description ?? ""} → rules|patterns|dismiss|reset` })),
+				];
+				return items.filter((i) => i.value.startsWith(last));
+			}
+
+			const name = tokens[0];
+
+			// Level 1: monitor name entered — show verbs
+			if (monitorNames.has(name) && tokens.length === 2) {
+				return monitorVerbs
+					.map((v) => ({ value: `${name} ${v}`, label: v, description: "" }))
+					.filter((i) => i.label.startsWith(last));
+			}
+
+			// Level 2: monitor name + "rules" — show actions
+			if (monitorNames.has(name) && tokens[1] === "rules" && tokens.length === 3) {
+				return rulesActions
+					.map((a) => ({ value: `${name} rules ${a}`, label: a, description: "" }))
+					.filter((i) => i.label.startsWith(last));
+			}
+
+			return null;
+		},
 		handler: async (args: string, ctx: ExtensionContext) => {
 			const cmd = parseMonitorsArgs(args, monitorNames);
 
@@ -1105,7 +1173,57 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			if (cmd.type === "list") {
-				handleList(monitors, ctx, monitorsEnabled);
+				if (!ctx.hasUI) {
+					handleList(monitors, ctx, monitorsEnabled);
+					return;
+				}
+				const options = [
+					`on — Enable all monitoring`,
+					`off — Pause all monitoring`,
+					...monitors.map((m) => {
+						const state = m.dismissed ? "dismissed" : m.whileCount > 0 ? `engaged (${m.whileCount}/${m.ceiling})` : "idle";
+						return `${m.name} — ${m.description} [${state}]`;
+					}),
+				];
+				const selected = await ctx.ui.select("Monitors", options);
+				if (!selected) return;
+				const selectedName = selected.split(" ")[0];
+				if (selectedName === "on") {
+					monitorsEnabled = true;
+					updateStatus();
+					ctx.ui.notify("Monitors enabled", "info");
+				} else if (selectedName === "off") {
+					monitorsEnabled = false;
+					updateStatus();
+					ctx.ui.notify("All monitors paused for this session", "info");
+				} else {
+					const monitor = monitorsByName.get(selectedName);
+					if (!monitor) return;
+					const verbOptions = [
+						`inspect — Show monitor state and config`,
+						`rules — List and manage rules`,
+						`patterns — List known patterns`,
+						`dismiss — Silence for this session`,
+						`reset — Reset state and un-dismiss`,
+					];
+					const verb = await ctx.ui.select(`[${monitor.name}]`, verbOptions);
+					if (!verb) return;
+					const verbName = verb.split(" ")[0];
+					if (verbName === "inspect") handleInspect(monitor, ctx);
+					else if (verbName === "rules") handleRulesList(monitor, ctx);
+					else if (verbName === "patterns") handlePatternsList(monitor, ctx);
+					else if (verbName === "dismiss") {
+						monitor.dismissed = true;
+						monitor.whileCount = 0;
+						updateStatus();
+						ctx.ui.notify(`[${monitor.name}] Dismissed for this session`, "info");
+					} else if (verbName === "reset") {
+						monitor.dismissed = false;
+						monitor.whileCount = 0;
+						updateStatus();
+						ctx.ui.notify(`[${monitor.name}] Reset`, "info");
+					}
+				}
 				return;
 			}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidorex/pi-behavior-monitors",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Behavior monitors for pi that watch agent activity and steer corrections",
   "type": "module",
   "keywords": [

package/skills/pi-behavior-monitors/SKILL.md

@@ -270,6 +270,13 @@ the session. A `CLEAN` verdict resets the consecutive steer counter.
 a turn, and monitor B has `"excludes": ["A"]`, monitor B skips that turn. Exclusion tracking
 resets at `turn_start`.
 
+**Buffered steer delivery**: Monitors on `message_end` or `turn_end` buffer their steer
+messages and deliver them at `agent_end`. This is because pi's async event queue processes
+extension handlers after the agent loop has already checked for steering messages. The
+buffer is drained at `agent_end` — only the first buffered steer fires per agent run; the
+corrected response re-triggers monitors naturally for any remaining issues. Monitors on
+`agent_end` or `command` events deliver steers immediately (they already run post-loop).
+
 **Abort**: Classification calls are aborted when the agent ends (via `agent_end` event).
 Aborted classifications produce no verdict and no action.
 
@@ -280,7 +287,9 @@ the `id` field of array entries.
 </runtime_behavior>
 
 <commands>
-All monitor management is through the `/monitors` command:
+All monitor management is through the `/monitors` command. Subcommands are
+discoverable via pi's TUI autocomplete — typing `/monitors ` shows available
+monitor names and global commands; selecting a monitor shows its verbs.
 
 | Command | Description |
 |---------|-------------|