pi-crew 0.11.11 → 0.11.13

package/src/runtime/dispatch-batch.ts

@@ -21,6 +21,8 @@ import type { TaskAttemptState, TeamRunManifest, TeamTaskState } from "../state/
 import { logInternalError } from "../utils/internal-error.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import { isDelegateShadowTask } from "./broker/delegate/shadow-lifecycle.ts";
+import { classifyAmbientNoiseGate } from "./classifier/ambient-noise-gate.ts";
+import { resolveClassifierEnabled, resolveClassifierModel } from "./classifier/classifier-service.ts";
 import { readCrewAgents, recordFromTask, saveCrewAgents } from "./crew-agent-records.ts";
 import { appendDeadletter } from "./deadletter.ts";
 import { classifyHeartbeat, DEFAULT_GRADIENT_THRESHOLDS } from "./heartbeat/heartbeat-gradient.ts";
@@ -764,6 +766,17 @@ export async function dispatchBatch(ctx: SchedulerContext, decision: DispatchBat
 		// so the counter accumulates across retry attempts × model fallbacks.
 		const policy = retryPolicyFromConfig(input.reliability);
 		const spawnBudget: SpawnBudget = { count: 0, max: policy.maxTotalSpawns ?? 0 };
+		// U6A (spec 2026-10-09 §U6 Phase A): ambient-noise vs real-failure
+		// classifier gate on the retry loop. Dormant unless
+		// runtime.classifierEnabled (default FALSE — same flag as child-executor's
+		// retry-triage; env PI_CREW_CLASSIFIER_ENABLED beats config). Disabled
+		// path passes NO hook at all: zero behavior change, zero registry touch.
+		// Every classifier failure mode (opencode unconfigured, classify throw,
+		// stopReason error) falls back inside classifyAmbientNoiseGate to
+		// proceed-with-retry — the gate can only SKIP a queued retry, never fail
+		// the task with a new error.
+		const noiseGateEnabled = resolveClassifierEnabled(input.runtimeConfig?.classifierEnabled);
+		const noiseGateModel = resolveClassifierModel(input.runtimeConfig?.classifierModel);
 		const baseInput = {
 			manifest: ctx.manifest,
 			tasks: ctx.tasks,
@@ -890,6 +903,25 @@ export async function dispatchBatch(ctx: SchedulerContext, decision: DispatchBat
 				policy,
 				{
 					signal: runController.signal,
+					// U6A: only consulted between attempts (never on attempt 1) and only
+					// when the gate is enabled — see noiseGateEnabled note above. The
+					// gate never rejects (soft-fail inside classifyAmbientNoiseGate and
+					// inside executeWithRetry's shouldRetry guard).
+					shouldRetry: noiseGateEnabled
+						? (attempt, error) =>
+								classifyAmbientNoiseGate({
+									enabled: true,
+									modelRegistry: input.modelRegistry,
+									classifierModel: noiseGateModel,
+									failureSummary: error.message,
+									attempt,
+									maxAttempts: policy.maxAttempts,
+									eventsPath: ctx.manifest.eventsPath,
+									runId: ctx.manifest.runId,
+									taskId: task.id,
+									metricRegistry: input.metricRegistry,
+								}).then((gate) => gate.proceedWithRetry)
+						: undefined,
 					attemptId: (attempt) => `${ctx.manifest.runId}:${task.id}:attempt-${attempt}`,
 					onAttemptFailed: (attempt, error, delayMs, info) => {
 						lastAttemptId = info.attemptId;

package/src/runtime/live-session/live-agent-control.ts

@@ -101,11 +101,13 @@ export async function applyLiveAgentControlRequest(input: {
 		await session.prompt?.(request.message ?? "Please continue with the follow-up request.", {
 			source: "api",
 			expandPromptTemplates: false,
+			streamingBehavior: "followUp",
 		});
 	else if (request.operation === "resume")
 		await session.prompt?.(request.message ?? "Please resume and report final status.", {
 			source: "api",
 			expandPromptTemplates: false,
+			streamingBehavior: "followUp",
 		});
 	else if (request.operation === "stop") await session.abort?.();
 	return true;

package/src/runtime/live-session/live-agent-manager.ts

@@ -62,6 +62,14 @@ export interface LiveAgentHandle {
 	status: CrewAgentRecord["status"];
 	pendingSteers: string[];
 	pendingFollowUps: string[];
+	/**
+	 * U4 dispose normalization: once the underlying session has been disposed
+	 * (task finished / hung-tool escape / terminate), the handle is TERMINAL —
+	 * steer/followUp/resume are rejected clearly instead of silently queueing
+	 * messages into a dead session (the old asymmetric-dispose bug) or letting
+	 * registerLiveAgent replay pending queues into it.
+	 */
+	terminated?: boolean;
 	/** Phase 7: Pending IRC messages for this agent. */
 	pendingMessages: IrcMessage[];
 	/** G1-G6: Real-time activity tracking (in-memory only). */
@@ -100,6 +108,11 @@ export function registerLiveAgent(
 		pendingSteers: existing?.pendingSteers ?? [],
 		pendingFollowUps: existing?.pendingFollowUps ?? [],
 		pendingMessages: existing?.pendingMessages ?? [],
+		// U4: a re-register with a FRESH session revives the agentId (e.g. the
+		// D4 planning→execute handoff: a mock/placeholder handle registered first,
+		// the real session later). Any pending steer/followUp queued against the
+		// earlier handle below is routed to the NEW session on replay.
+		terminated: false,
 		activity: existing?.activity ?? {
 			activeTools: new Map(),
 			toolUses: 0,
@@ -161,9 +174,13 @@ export function registerLiveAgent(
 		handle.pendingFollowUps.length = 0;
 		for (const message of pending)
 			void handle.session
+				// U4: streamingBehavior is MANDATORY on every prompt() — without it a
+				// prompt that lands while the session is already streaming throws
+				// "Agent is already processing" (pi agent-session.js:1548).
 				.prompt(message, {
 					source: "api",
 					expandPromptTemplates: false,
+					streamingBehavior: "followUp",
 				})
 				.catch((error) => logInternalError("live-agent-manager.prompt", error, `agentId=${handle.agentId}`));
 	}
@@ -217,10 +234,49 @@ async function killLiveSessionProcessIfAlive(handle: LiveAgentHandle): Promise<v
 	}
 }
 
+/**
+ * U4 dispose normalization: dispose the underlying session AND make the
+ * handle terminal — drain any queued pendingSteers/pendingFollowUps (they can
+ * never be delivered to a disposed session) and set `terminated` so later
+ * steer/followUp calls are rejected clearly instead of queueing into a dead
+ * session. The handle itself stays in the registry for status/health/UI.
+ */
 export function disposeLiveAgentSession(agentIdOrTaskId: string): void {
 	const handle = getLiveAgent(agentIdOrTaskId);
 	if (!handle) return;
+	markLiveAgentHandleTerminated(handle);
+	safeDisposeLiveSession(handle);
+}
+
+/** Drain pending queues and mark a handle terminal (idempotent). */
+function markLiveAgentHandleTerminated(handle: LiveAgentHandle): void {
+	// Drain: queued messages must not replay into the disposed session later
+	// (registerLiveAgent preserves pending* across re-registrations).
+	handle.pendingSteers.length = 0;
+	handle.pendingFollowUps.length = 0;
+	handle.terminated = true;
+	handle.updatedAt = new Date().toISOString();
+	invalidateSortedLiveAgents();
+}
+
+/**
+ * U4 hung-tool escape hatch — drop-reference.
+ *
+ * Synchronous last resort for a session whose prompt() will never settle
+ * (tool/provider holds the turn and ignores AbortSignal): terminate the
+ * handle and REMOVE it from the registry WITHOUT awaiting abort().
+ * terminateLiveAgent's `await session.abort()` would itself hang on such a
+ * session; here only synchronous cleanup runs (drain → mark → dispose →
+ * unregister). Any background abort that eventually settles is harmless.
+ */
+export function dropLiveAgentReference(agentIdOrTaskId: string): LiveAgentHandle | undefined {
+	const handle = getLiveAgent(agentIdOrTaskId);
+	if (!handle) return undefined;
+	markLiveAgentHandleTerminated(handle);
 	safeDisposeLiveSession(handle);
+	liveAgents.delete(handle.agentId);
+	invalidateSortedLiveAgents();
+	return handle;
 }
 
 export async function terminateLiveAgent(
@@ -254,6 +310,7 @@ export async function terminateLiveAgent(
 	try {
 		await handle.session.abort?.();
 	} finally {
+		markLiveAgentHandleTerminated(handle);
 		safeDisposeLiveSession(handle);
 		liveAgents.delete(handle.agentId); // Move AFTER abort completes to prevent race
 		invalidateSortedLiveAgents();
@@ -377,6 +434,10 @@ export function getLiveAgentContextPercent(agentIdOrTaskId: string): number | nu
 export async function steerLiveAgent(agentIdOrTaskId: string, message: string): Promise<LiveAgentHandle> {
 	const handle = getLiveAgent(agentIdOrTaskId);
 	if (!handle) throw new Error(`Live agent '${agentIdOrTaskId}' is not registered in this process.`);
+	// U4 dispose normalization: explicit rejection — never silently queue into
+	// (or double-deliver via replay of) a disposed session.
+	if (handle.terminated)
+		throw new Error(`Live agent '${agentIdOrTaskId}' session was disposed (terminated); steer is no longer accepted.`);
 	if (typeof handle.session.steer !== "function") {
 		handle.pendingSteers.push(message);
 		return handle;
@@ -390,6 +451,8 @@ export async function steerLiveAgent(agentIdOrTaskId: string, message: string):
 export async function followUpLiveAgent(agentIdOrTaskId: string, prompt: string): Promise<LiveAgentHandle> {
 	const handle = getLiveAgent(agentIdOrTaskId);
 	if (!handle) throw new Error(`Live agent '${agentIdOrTaskId}' is not registered in this process.`);
+	if (handle.terminated)
+		throw new Error(`Live agent '${agentIdOrTaskId}' session was disposed (terminated); follow-up is no longer accepted.`);
 	if (typeof handle.session.prompt !== "function") {
 		handle.pendingFollowUps.push(prompt);
 		return handle;
@@ -397,6 +460,8 @@ export async function followUpLiveAgent(agentIdOrTaskId: string, prompt: string)
 	await handle.session.prompt(prompt, {
 		source: "api",
 		expandPromptTemplates: false,
+		// U4: mandatory streamingBehavior — see registerLiveAgent replay note.
+		streamingBehavior: "followUp",
 	});
 	handle.updatedAt = new Date().toISOString();
 	invalidateSortedLiveAgents();
@@ -412,11 +477,15 @@ export async function stopLiveAgent(agentIdOrTaskId: string): Promise<LiveAgentH
 export async function resumeLiveAgent(agentIdOrTaskId: string, prompt: string): Promise<LiveAgentHandle> {
 	const handle = getLiveAgent(agentIdOrTaskId);
 	if (!handle) throw new Error(`Live agent '${agentIdOrTaskId}' is not registered in this process.`);
+	if (handle.terminated)
+		throw new Error(`Live agent '${agentIdOrTaskId}' session was disposed (terminated); resume requires a fresh session.`);
 	if (typeof handle.session.prompt !== "function") throw new Error(`Live agent '${agentIdOrTaskId}' does not expose prompt().`);
 	handle.status = "running";
 	await handle.session.prompt(prompt, {
 		source: "api",
 		expandPromptTemplates: false,
+		// U4: mandatory streamingBehavior — see registerLiveAgent replay note.
+		streamingBehavior: "followUp",
 	});
 	handle.status = "completed";
 	handle.updatedAt = new Date().toISOString();
@@ -514,7 +583,7 @@ export function sendIrcMessage(targetAgentId: string, message: IrcMessage): void
 	if (typeof handle.session.prompt === "function") {
 		const ircPrompt = `[Message from ${message.from}] ${message.content}`;
 		void handle.session
-			.prompt(ircPrompt, { source: "api", expandPromptTemplates: false })
+			.prompt(ircPrompt, { source: "api", expandPromptTemplates: false, streamingBehavior: "followUp" })
 			.catch((error) => logInternalError("live-agent-manager.irc-deliver", error, `agentId=${handle.agentId}`));
 	}
 }
@@ -559,6 +628,7 @@ export function broadcastIrcMessage(fromAgentId: string, message: IrcMessage): s
 				.prompt(ircPrompt, {
 					source: "api",
 					expandPromptTemplates: false,
+					streamingBehavior: "followUp",
 				})
 				.catch((error) => logInternalError("live-agent-manager.irc-broadcast", error, `agentId=${handle.agentId}`));
 		}
@@ -657,7 +727,7 @@ export async function respondAsBackground(
 	if (!delivered && typeof handle.session.prompt === "function") {
 		const promptText = `${deliveredTag}${awaitReply ? ` (reply correlation: ${corrId})` : ""}`;
 		void handle.session
-			.prompt(promptText, { source: "api", expandPromptTemplates: false })
+			.prompt(promptText, { source: "api", expandPromptTemplates: false, streamingBehavior: "followUp" })
 			.catch((error) => logInternalError("live-agent-manager.respondAsBackground", error, `agentId=${handle.agentId}`));
 		delivered = true;
 	}