@skydiveai/pi-extensions 0.1.255-beta.6 → 0.1.255-beta.8

package/dist/index.mjs

@@ -4530,6 +4530,8 @@ const diskGuardExtension = (pi) => {
 //#endregion
 //#region src/extensions/noop-loop-guard.ts
 const log$8 = logger.child({ module: "noop-loop-guard" });
+/** Length of the rolling window that counts silence commands across streak resets. */
+const SILENCE_WINDOW_MS = 300 * 1e3;
 /** Bare shell no-op: `true` or `:` (case-insensitive). */
 const BARE_NOOP_RE = /^(true|:)\s*$/i;
 /**
@@ -4618,40 +4620,81 @@ function isSilenceCommand(command) {
 	if (trimmed.length === 0) return false;
 	return trimmed.split(/;|&&|\n/).every((s) => segmentIsNoop(s) || isSuppressReplyCall(s));
 }
-function noopBlockReason(streak, aborted) {
+function noopBlockReason({ streak, windowCount, aborted }) {
 	const stop = "No-op loop: a bare `true`/`:` or a pure `echo` does nothing, and `platform channel suppress-reply` only works once per response scope; repeating either just costs a model round trip. If you are holding silence (e.g. right after `platform channel suppress-reply`) or waiting on something, the right move is to END THE TURN: emitting nothing IS the silence, and it costs zero commands. If a real process needs the wait, use `bg_run` or schedule a wake (`platform automation create --at <time>`).";
-	const escalate = aborted ? ` This run has now fired ${streak} consecutive no-ops; the harness is aborting it.` : ` ${Math.max(25 - streak, 0)} more before the harness aborts the run.`;
+	const trigger = streak >= 3 ? `${streak} consecutive no-ops` : `${windowCount} no-ops within the last ${Math.round(SILENCE_WINDOW_MS / 6e4)} minutes`;
+	let escalate;
+	if (aborted) escalate = ` This run has now fired ${trigger}; the harness is aborting it.`;
+	else {
+		const remaining = Math.max(Math.min(25 - streak, 40 - windowCount), 0);
+		escalate = ` This run has fired ${trigger}; ${remaining} more no-op${remaining === 1 ? "" : "s"} before the harness aborts the run.`;
+	}
 	const bypass = ` If this specific command genuinely needs to run, append \` # ${BYPASS_HINT$1}\`.`;
 	return stop + escalate + bypass;
 }
-/** Count one bash command against the streak; returns the new streak. */
-function recordNoopCommand(state, command) {
-	if (!isSilenceCommand(command) || hasBypassMarker$1(command)) {
+/**
+* Count one bash command against the streak AND the rolling window; returns
+* the new streak. A bypass-marked silence command resets the streak (the
+* marker means "this one is intentional") but its timestamp still lands in
+* the window, so the marker cannot double as an unbounded loop escape
+* hatch. `now` is required so callsites cannot silently disagree on what
+* "now" means; tests pass a fixed clock to exercise window expiry.
+*/
+function recordNoopCommand(state, command, now) {
+	if (!isSilenceCommand(command)) {
+		state.streak = 0;
+		return 0;
+	}
+	if (hasBypassMarker$1(command)) {
 		state.streak = 0;
+		state.silenceTimestamps.push(now);
 		return 0;
 	}
 	state.streak += 1;
+	state.silenceTimestamps.push(now);
 	return state.streak;
 }
+/**
+* Count silence commands recorded within the last SILENCE_WINDOW_MS, pruning
+* older entries. Unlike the streak, this survives resets from real work.
+*/
+function countSilenceInWindow(state, now) {
+	const cutoff = now - SILENCE_WINDOW_MS;
+	const oldest = state.silenceTimestamps[0];
+	if (oldest !== void 0 && oldest < cutoff) state.silenceTimestamps = state.silenceTimestamps.filter((t) => t >= cutoff);
+	return state.silenceTimestamps.length;
+}
 const noopLoopGuardExtension = (pi) => {
-	const state = { streak: 0 };
+	const state = {
+		streak: 0,
+		silenceTimestamps: []
+	};
 	pi.on("tool_call", async (event, ctx) => {
 		if (event.toolName !== "bash") return;
 		if (guardDisabledByEnv$1()) return;
 		const command = event.input.command;
 		if (typeof command !== "string" || command.length === 0) return;
-		const streak = recordNoopCommand(state, command);
-		if (streak < 3) return;
-		const aborted = streak >= 25;
+		const now = Date.now();
+		const bypassed = isSilenceCommand(command) && hasBypassMarker$1(command);
+		const streak = recordNoopCommand(state, command, now);
+		const windowCount = countSilenceInWindow(state, now);
+		if (bypassed) return;
+		if (streak < 3 && windowCount < 8) return;
+		const aborted = streak >= 25 || windowCount >= 40;
 		log$8.warn({
 			streak,
+			windowCount,
 			aborted,
 			toolCallId: event.toolCallId
 		}, "no-op loop guard fired");
 		if (aborted) ctx.abort();
 		return {
 			block: true,
-			reason: noopBlockReason(streak, aborted)
+			reason: noopBlockReason({
+				streak,
+				windowCount,
+				aborted
+			})
 		};
 	});
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skydiveai/pi-extensions",
-  "version": "0.1.255-beta.6",
+  "version": "0.1.255-beta.8",
   "homepage": "https://skydive.com",
   "license": "MIT",
   "author": "Create, Inc.",