@oh-my-pi/pi-agent-core 18.2.10 → 18.2.11

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [18.2.11] - 2026-09-23
+
+### Fixed
+
+- Fixed background job completions interrupting foreground Bash and eval calls, which could cause those calls to be repeatedly moved into the background.
+
 ## [18.2.9] - 2026-09-22
 
 ### Fixed

package/dist/types/types.d.ts

@@ -243,7 +243,10 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * Same rules as {@link hasIrcInterrupts}: non-consuming, only cuts
      * *interruptible* waits short, ignored when interruptMode is "wait". Without
      * it a completion notice sits behind an hour-long `hub wait` that the agent
-     * would have abandoned had it seen the notice.
+     * would have abandoned had it seen the notice. Unlike a peer IRC it never
+     * raises {@link ToolCallContext.steeringSignal}: a queued completion must
+     * not push ordinary foreground work (auto-background bash/eval) into the
+     * background.
      */
     hasBackgroundCompletions?: () => boolean | Promise<boolean>;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-agent-core",
-	"version": "18.2.10",
+	"version": "18.2.11",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,16 +35,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.2.10",
-		"@oh-my-pi/pi-catalog": "18.2.10",
-		"@oh-my-pi/pi-natives": "18.2.10",
-		"@oh-my-pi/pi-utils": "18.2.10",
-		"@oh-my-pi/pi-wire": "18.2.10",
-		"@oh-my-pi/snapcompact": "18.2.10",
+		"@oh-my-pi/pi-ai": "18.2.11",
+		"@oh-my-pi/pi-catalog": "18.2.11",
+		"@oh-my-pi/pi-natives": "18.2.11",
+		"@oh-my-pi/pi-utils": "18.2.11",
+		"@oh-my-pi/pi-wire": "18.2.11",
+		"@oh-my-pi/snapcompact": "18.2.11",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@oh-my-pi/omptype": "18.2.10",
+		"@oh-my-pi/omptype": "18.2.11",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "^1.3.14"

package/src/agent-loop.ts

@@ -2938,19 +2938,32 @@ async function executeToolCalls(
 	const checkAsideInterrupts = async (): Promise<void> => {
 		// Asides only fire once: an interrupt already recorded on interruptState
 		// must not re-abort, and (unlike steering) never re-consumes a queue.
-		if (!shouldInterruptImmediately || signal?.aborted || interruptState.triggered) return;
+		// A completion-triggered record is the exception — it leaves the
+		// cooperative signal down, so keep polling until a peer IRC escalates.
+		if (!shouldInterruptImmediately || signal?.aborted) return;
+		if (interruptState.triggered && steeringSoftController.signal.aborted) return;
 		// Peer IRC and background completions (finished jobs, exited supervised
 		// processes) hard-abort interruptible waits only; foreground tools keep
-		// running (no partial side effects) but get the cooperative soft signal
-		// so backgroundable work can step aside for the queued notice.
+		// running (no partial side effects).
 		let source: AsideInterruptSource | undefined;
 		if (hasIrcInterrupts && (await hasIrcInterrupts())) source = "irc";
-		else if (hasBackgroundCompletions && (await hasBackgroundCompletions())) source = "background";
-		if (!source || interruptState.triggered) return;
-		interruptState.triggered = true;
-		interruptState.source = source;
-		ircAbortController.abort();
-		steeringSoftController.abort();
+		else if (!interruptState.triggered && hasBackgroundCompletions && (await hasBackgroundCompletions()))
+			source = "background";
+		if (!source) return;
+		if (!interruptState.triggered) {
+			interruptState.triggered = true;
+			interruptState.source = source;
+			ircAbortController.abort();
+		}
+		// Only an urgent aside raises the cooperative signal that makes
+		// backgroundable foreground work (auto-background bash/eval) detach
+		// itself. A peer waiting on an IRC is blocked on this batch; a finished
+		// background job is not — its notice is an aside that injects at the
+		// batch boundary either way. Detaching ordinary foreground work for it
+		// also cascades: the freshly detached job's own completion re-triggers
+		// this check for the next command, so millisecond-long commands chain
+		// into separate background deliveries (#12869).
+		if (source !== "background") steeringSoftController.abort();
 	};
 
 	const checkSteering = async (): Promise<void> => {
@@ -3296,10 +3309,11 @@ async function executeToolCalls(
 
 	// While tool calls are in flight, queued steering or interrupting IRC would
 	// otherwise wait out the tools' own window. Poll only non-consuming queues:
-	// detection hard-aborts interruptible waits (running or not yet started)
-	// and soft-signals cooperative tools (auto-background bash), so the boundary
-	// dequeue below injects the message promptly. Gated on immediate-interrupt
-	// mode; checkSteering is idempotent (no-op once triggered).
+	// detection hard-aborts interruptible waits (running or not yet started),
+	// and steering/IRC additionally soft-signal cooperative tools
+	// (auto-background bash), so the boundary dequeue below injects the message
+	// promptly. Gated on immediate-interrupt mode; checkSteering is idempotent
+	// (no-op once triggered).
 	const hasAsidePeek = hasIrcInterrupts !== undefined || hasBackgroundCompletions !== undefined;
 	const watchSteeringWhileRunning = shouldInterruptImmediately && (hasSteeringMessages !== undefined || hasAsidePeek);
 	const eventDrivenSteeringWatch =
@@ -3335,7 +3349,11 @@ async function executeToolCalls(
 						() => false,
 					);
 					if (!(await Promise.race([steeringChecked, watchAbortedFalse]))) return;
-					if (steeringWatchSignal.aborted || interruptState.triggered) return;
+					// Stop once the cooperative signal is up — steering and IRC
+					// have nothing left to escalate. A completion-only trigger
+					// leaves it down, so keep watching: a genuine steer arriving
+					// afterwards must still reach foreground tools.
+					if (steeringWatchSignal.aborted || steeringSoftController.signal.aborted) return;
 					if (!(await Promise.race([steeringQueued, watchAbortedFalse]))) return;
 				}
 			})()

package/src/types.ts

@@ -300,7 +300,10 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	 * Same rules as {@link hasIrcInterrupts}: non-consuming, only cuts
 	 * *interruptible* waits short, ignored when interruptMode is "wait". Without
 	 * it a completion notice sits behind an hour-long `hub wait` that the agent
-	 * would have abandoned had it seen the notice.
+	 * would have abandoned had it seen the notice. Unlike a peer IRC it never
+	 * raises {@link ToolCallContext.steeringSignal}: a queued completion must
+	 * not push ordinary foreground work (auto-background bash/eval) into the
+	 * background.
 	 */
 	hasBackgroundCompletions?: () => boolean | Promise<boolean>;