pi-crew 0.11.11 → 0.11.13

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-crew",
-	"version": "0.11.11",
+	"version": "0.11.13",
 	"description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
 	"author": "baphuongna",
 	"license": "MIT",

package/src/config/config-validation.ts

@@ -381,6 +381,15 @@ function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
 			};
 			return Object.values(parsed).some((v) => v !== undefined) ? parsed : undefined;
 		})(),
+		liveSession: (() => {
+			const l = asRecord(obj.liveSession);
+			if (!l) return undefined;
+			const parsed: NonNullable<CrewRuntimeConfig["liveSession"]> = {
+				responseTimeoutMs: parsePositiveInteger(l.responseTimeoutMs, LIMIT_CEILINGS.runtimeTaskTimeoutMs),
+				hungToolGraceMs: parsePositiveInteger(l.hungToolGraceMs, LIMIT_CEILINGS.runtimeTaskTimeoutMs),
+			};
+			return Object.values(parsed).some((v) => v !== undefined) ? parsed : undefined;
+		})(),
 		excludeContextBash: parseWithSchema(Type.Boolean(), obj.excludeContextBash),
 		handoffBudgetTokens: parseHandoffBudgetTokens(obj.handoffBudgetTokens),
 		agentExtensions: parseStringList(obj.agentExtensions),

package/src/config/defaults.ts

@@ -46,6 +46,13 @@ export const DEFAULT_LIVE_SESSION = {
 	yieldPollIntervalMs: 500,
 	/** Maximum time to wait for session idle after prompt (ms). */
 	idleWaitTimeoutMs: 60_000,
+	/**
+	 * U4 hung-tool escape hatch: after the response timeout fires and the
+	 * cooperative abort() has been issued, how long to keep waiting for the
+	 * prompt() promise to settle before declaring the session hung (tool kept
+	 * the event loop / ignored the AbortSignal) and dropping the reference.
+	 */
+	hungToolGraceMs: 10_000,
 };
 
 export const DEFAULT_LOCKS = {

package/src/config/env-vars.ts

@@ -455,6 +455,19 @@ export const CREW_ENV_VARS: Record<string, CrewEnvVarSpec> = {
 		parser: "boolean",
 		doc: "R3-19/D5 hermetic worker spawn override: '1' forces --no-extensions on worker argv, '0' restores the old ambient-stack parity (discovered/configured/built-in extensions load); beats BuildPiWorkerArgsInput.hermeticWorkers / runtime.hermeticWorkers; default ON (pi-args.ts:resolveHermeticWorkers). Explicit -e prompt-runtime + agent extensions + --skill flags are unaffected (cli.md:186-191)",
 	},
+	PI_CREW_STATE_BACKEND: {
+		name: "PI_CREW_STATE_BACKEND",
+		doc: "U8 (upgrade-spec 2026-10-09) run-state store backend select: 'sqlite' stores manifest+tasks+worker-status in <runId>/state.sqlite via node:sqlite with ONE transaction per batch write (all-or-nothing; manifest.json/tasks.json stay written as read-side mirrors for legacy consumers — loads read the db); unset or any other value keeps the default JSON file backend. events.jsonl audit spine unchanged in both modes (state-store.ts / sqlite-run-state.ts isSqliteStateBackend)",
+	},
+	PI_CREW_CHILD_PI_MODE: {
+		name: "PI_CREW_CHILD_PI_MODE",
+		doc: "U14 (upgrade-spec 2026-10-09) child-pi protocol v2 transport select: 'rpc' spawns task workers over pi --mode rpc (SDK RpcClient wire — steer receipts, clear_queue hygiene, multi-prompt reuse; child-pi-rpc.ts), 'json' / unset keeps the --mode json -p stdio path (phase-1 default; both modes fully regression-tested). Surface TUI panes are unaffected",
+	},
+	PI_CREW_CHILD_PI_POOL: {
+		name: "PI_CREW_CHILD_PI_POOL",
+		parser: "boolean",
+		doc: "U14 rpc worker process pool (phase 1, default OFF): '1' lets consecutive tasks of the SAME agent reuse one live idle rpc process (warm context — 1 process = 1 session, many prompts). Phase-1 limitation: per-run env control vars (broker token, steering file, scratchpad gates) and argv flags apply only to the FIRST task on the process; entries evict on exit/abort (child-pi-rpc.ts)",
+	},
 	PI_CREW_WORKER_TRANSPORT: {
 		name: "PI_CREW_WORKER_TRANSPORT",
 		doc: "W7 EXPERIMENTAL worker transport override: 'rpc' selects the prototype RPC frame-client (src/runtime/rpc/) at the run-worker seam (wired e2728f68; D1/DR2 also plumbs config runtime.workerTransport to the same seam — env WINS over config when set, invalid env fails safe to stdio); anything else/unset → config value, default stdio child-pi path (rpc-worker.ts resolveWorkerTransport)",
@@ -468,6 +481,17 @@ export const CREW_ENV_VARS: Record<string, CrewEnvVarSpec> = {
 		name: "PI_CREW_CLASSIFIER_MODEL",
 		doc: "P2-1 classifier model id override ('provider/id', catalog ids only — availability depends on provider credentials at runtime): beats runtime.classifierModel; unset/blank → config value, default 'opencode/jev-1.13-free' (classifier-service.ts:resolveClassifierModel)",
 	},
+	PI_CREW_VERIFY_GATE: {
+		name: "PI_CREW_VERIFY_GATE",
+		parser: "boolean",
+		doc: "U13 deterministic verifier pre-gate override: '0' disables running the deterministic verify_gate checks (typecheck / test:critical via package.json scripts) before a verifier-role worker spawn — the LLM verifier then always spawns exactly as pre-U13; '1' forces it on. Default ON (gate PASS skips the LLM verifier spawn; FAILED/INCONCLUSIVE spawns it with the gate results in the prompt) (runtime/verification/verify-gate.ts resolveVerifyGateEnabled)",
+	},
+	PI_CREW_VERIFY_GATE_TIMEOUT_MS: {
+		name: "PI_CREW_VERIFY_GATE_TIMEOUT_MS",
+		parser: "int",
+		default: "120000",
+		doc: "U13 per-check timeout in ms for the deterministic verify_gate pre-gate commands. Invalid/≤0 → 120000, mirroring runPhaseGates (runtime/verification/verify-gate.ts resolveVerifyGateTimeoutMs)",
+	},
 	PI_CREW_RPC_DIALOG_ANSWER: {
 		name: "PI_CREW_RPC_DIALOG_ANSWER",
 		doc: "W7 EXPERIMENTAL dialog auto-answer policy for RPC-mode extension_ui_request dialogs (select/confirm/input/editor): 'cancel' (default) answers {cancelled:true} — universal safe answer; 'block' leaves the server promise pending (debug). Auto-confirm deliberately NOT implemented (security); invalid → 'cancel' (rpc-worker.ts resolveDialogAnswerPolicy)",

package/src/config/types.ts

@@ -123,6 +123,17 @@ export interface CrewRuntimeConfig {
 		maxReminders?: number;
 		reminderPrompt?: string;
 	};
+	/**
+	 * U4 (live-session v2): tunables for the in-process live-session worker.
+	 * `responseTimeoutMs` bounds one prompt() wall-clock (default
+	 * DEFAULT_LIVE_SESSION.responseTimeoutMs); `hungToolGraceMs` is how long
+	 * the escape hatch waits for the cooperatively-aborted prompt to settle
+	 * before dropping the session reference and failing the task.
+	 */
+	liveSession?: {
+		responseTimeoutMs?: number;
+		hungToolGraceMs?: number;
+	};
 	/** Policy for per-role runtime selection. Not sensitive — safe to keep in project config. */
 	isolationPolicy?: {
 		/** Roles that should use child-process for crash isolation. Default: no roles. */

package/src/extension/registration/tool-registration.ts

@@ -15,6 +15,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { RegistrationContext } from "./registration-types.ts";
 import { registerSubagentTools } from "./subagent-tools.ts";
 import { registerTeamTool } from "./team-tool.ts";
+import { registerVerifyGateTool } from "./verify-gate-tool.ts";
 
 /**
  * Register all pi-crew tools on the ExtensionAPI.
@@ -47,4 +48,10 @@ export function registerPiTools(pi: ExtensionAPI, ctx: RegistrationContext): voi
 			ctx.startForegroundRun(subCtx as Parameters<typeof ctx.startForegroundRun>[0], runner, runId),
 		batchBarrier: ctx.batchBarrier,
 	});
+	// U13 (upgrade spec 2026-10-09): deterministic verifier pre-gate tool —
+	// codemode exposure (hidden from the model, callable via ctx.executeTool
+	// by other tools); the verifier spawn site consumes the same engine.
+	registerVerifyGateTool(pi, {
+		getMetricRegistry: () => ctx.observabilityState.metricRegistry,
+	});
 }

package/src/extension/registration/verify-gate-tool.ts

@@ -0,0 +1,263 @@
+/**
+ * U13 (upgrade spec 2026-10-09 §U13): the `verify_gate` TOOL — the
+ * extension-layer entry point of the deterministic verifier pre-gate.
+ *
+ * Runs the configured check commands (typecheck / test:critical / grep
+ * evidence lines) via `ctx.executeTool("bash", ...)` — the FIFTH parameter of
+ * ToolDefinition.execute. The round-10 probe (/tmp/pi-crew-verify10-xtool/,
+ * 13/13 checks PASS) proved this path: nested calls get id `<parent>/1` +
+ * parentToolCallId on events, errors arrive as isError VALUES (never throws),
+ * exit codes are readable in result.structuredContent.exit_code, calls go
+ * through the FULL pipeline (validation + tool_call/tool_result hooks +
+ * permissions), and the host enforces nested limits (256 calls / 8KB per
+ * call / 32KB total args) — the caps below stay far inside them.
+ *
+ * EXPOSURE — "codemode", not "model-only" (spec says "cân nhắc
+ * exposure:'model-only' (giấu khỏi model, chỉ tool khác gọi được — codemode
+ * pattern)"; the parenthetical is the INTENT, and per the SDK
+ * (core/extensions/types.d.ts ToolExposure) the literal names mean the
+ * opposite of the intent: `model-only` = "declared to the model while
+ * active, NEVER callable" — executeTool calls to it fail — while `codemode`
+ * = "callable whenever registered, not declared to the model unless
+ * explicitly activated". `codemode` IS the "hidden from the model, callable
+ * by other tools" pattern the spec wants (it is exactly what the codemode
+ * tool itself does), so that is what we register.
+ *
+ * The verifier SPAWN SITE (task-runner.ts) consumes the same pure engine via
+ * the subprocess executor; this tool is the in-host, zero-subprocess variant
+ * other tools (or codemode scripts) can call to get a structured gate
+ * verdict without any LLM involvement.
+ */
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "@sinclair/typebox";
+import type { MetricRegistry } from "../../observability/metric-registry.ts";
+import {
+	DEFAULT_VERIFY_GATE_TIMEOUT_MS,
+	defaultVerifyGateChecks,
+	renderVerifyGateContext,
+	runVerifyGate,
+	type VerifyGateCheck,
+	type VerifyGateOutcome,
+} from "../../runtime/verification/verify-gate.ts";
+
+/** Nested-limit guards (host caps are 256 calls / 8KB call / 32KB args —
+ *  these stay an order of magnitude under). */
+export const VERIFY_GATE_TOOL_MAX_CHECKS = 8;
+export const VERIFY_GATE_TOOL_MAX_COMMAND_CHARS = 2_000;
+export const VERIFY_GATE_TOOL_MAX_TOTAL_COMMAND_CHARS = 8_000;
+/** Bash tool timeout is in SECONDS. */
+const BASH_TIMEOUT_MAX_SECONDS = 600;
+
+const VerifyGateToolParams = Type.Object({
+	cwd: Type.Optional(Type.String({ description: "Working directory the checks run in. Defaults to the session cwd." })),
+	checks: Type.Optional(
+		Type.Array(
+			Type.Object({
+				name: Type.String({ description: "Short check name, e.g. 'typecheck'." }),
+				command: Type.String({ description: "Shell command; exit code 0 = pass, e.g. 'npm run --silent typecheck'." }),
+				critical: Type.Optional(Type.Boolean({ description: "Stop the gate on this check's failure (default true)." })),
+			}),
+			{
+				description:
+					"Explicit checks. Defaults to the repo preset: package.json scripts 'typecheck' + 'test:critical' when present. Add grep evidence lines here (e.g. `grep -c \"<marker>\" dist/index.mjs`).",
+			},
+		),
+	),
+	timeoutMs: Type.Optional(
+		Type.Number({
+			minimum: 1_000,
+			maximum: 600_000,
+			description: `Per-check timeout in ms (default ${DEFAULT_VERIFY_GATE_TIMEOUT_MS}).`,
+		}),
+	),
+});
+
+export interface VerifyGateToolDeps {
+	/** Host metric registry (lazily resolved per call, same as team-tool). */
+	getMetricRegistry?: () => MetricRegistry | undefined;
+}
+
+/** Quote a path for shell interpolation (single quotes; embedded quotes escaped). */
+function shellQuote(value: string): string {
+	return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+/** Read the bash exit code from a nested executeTool outcome. The bash tool
+ *  reports { exit_code, output, truncated, wall_time_seconds } in
+ *  structuredContent; a NON-ZERO exit is an isError VALUE (no throw) per the
+ *  probe, so the code stays readable on failure paths. */
+function readNestedBashResult(outcome: { isError: boolean; result: { structuredContent?: unknown; content?: unknown } }): {
+	exitCode: number | null;
+	output: string;
+} {
+	const structured = outcome.result.structuredContent;
+	let exitCode: number | null = null;
+	let output = "";
+	if (structured && typeof structured === "object" && !Array.isArray(structured)) {
+		const record = structured as Record<string, unknown>;
+		if (typeof record.exit_code === "number") exitCode = record.exit_code;
+		if (typeof record.output === "string") output = record.output;
+	}
+	if (!output) {
+		// Fallback: join text content parts (isError results keep content).
+		const content = outcome.result.content;
+		if (typeof content === "string") output = content;
+		else if (Array.isArray(content)) {
+			output = content
+				.map((part) =>
+					part && typeof part === "object" && typeof (part as { text?: unknown }).text === "string"
+						? (part as { text: string }).text
+						: "",
+				)
+				.filter(Boolean)
+				.join("\n");
+		}
+	}
+	// isError without a structured exit code (blocked/thrown) → treat as a
+	// failed check with an unknown code; the verdict stays deterministic.
+	if (outcome.isError && exitCode === null) exitCode = -1;
+	return { exitCode, output };
+}
+
+export function registerVerifyGateTool(pi: ExtensionAPI, deps: VerifyGateToolDeps): void {
+	const tool: ToolDefinition = {
+		name: "verify_gate",
+		label: "Verify Gate",
+		description: [
+			"Deterministic verification gate (U13): runs check commands (typecheck / test:critical / grep evidence lines) and returns a structured verdict {verdict: PASS|FAILED|INCONCLUSIVE, checks, evidenceLines} — exit codes only, no LLM judgment.",
+			"Registered codemode-style: callable by other tools via ctx.executeTool('verify_gate', {...}); not part of the model-facing active tool set.",
+			"A PASS verdict is positive deterministic evidence that an LLM verifier spawn can be skipped; FAILED/INCONCLUSIVE escalate with these results attached.",
+		].join("\n"),
+		// codemode = hidden from the model, callable via ctx.executeTool — the
+		// spec's "giấu khỏi model, chỉ tool khác gọi" pattern (see header note
+		// for why the literal 'model-only' value would defeat that intent).
+		exposure: "codemode",
+		defaultActive: false,
+		parameters: VerifyGateToolParams,
+		outputSchema: Type.Object({
+			verdict: Type.Union([Type.Literal("PASS"), Type.Literal("FAILED"), Type.Literal("INCONCLUSIVE")]),
+			evidenceLines: Type.Array(Type.String()),
+			allPassed: Type.Boolean(),
+			totalDurationMs: Type.Number(),
+			checks: Type.Array(
+				Type.Object({
+					name: Type.String(),
+					command: Type.String(),
+					exitCode: Type.Union([Type.Number(), Type.Null()]),
+					passed: Type.Boolean(),
+					durationMs: Type.Number(),
+					skipped: Type.Optional(Type.Boolean()),
+				}),
+			),
+		}),
+		async execute(_id, params: Static<typeof VerifyGateToolParams>, signal, _onUpdate, ctx) {
+			const cwd = params.cwd && params.cwd.trim().length > 0 ? params.cwd : ctx.cwd;
+			const checks: VerifyGateCheck[] = params.checks ?? defaultVerifyGateChecks(cwd);
+			// Nested-limit guards — validate BEFORE any executeTool call.
+			if (checks.length > VERIFY_GATE_TOOL_MAX_CHECKS) {
+				return {
+					content: [{ type: "text", text: `verify_gate: too many checks (${checks.length} > ${VERIFY_GATE_TOOL_MAX_CHECKS})` }],
+					details: undefined,
+					isError: true,
+				};
+			}
+			let totalChars = 0;
+			for (const check of checks) {
+				if (check.command.length > VERIFY_GATE_TOOL_MAX_COMMAND_CHARS) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: `verify_gate: check '${check.name}' command exceeds ${VERIFY_GATE_TOOL_MAX_COMMAND_CHARS} chars`,
+							},
+						],
+						details: undefined,
+						isError: true,
+					};
+				}
+				totalChars += check.command.length;
+			}
+			if (totalChars > VERIFY_GATE_TOOL_MAX_TOTAL_COMMAND_CHARS) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: `verify_gate: total command chars ${totalChars} > ${VERIFY_GATE_TOOL_MAX_TOTAL_COMMAND_CHARS}`,
+						},
+					],
+					details: undefined,
+					isError: true,
+				};
+			}
+			const timeoutMs = params.timeoutMs ?? DEFAULT_VERIFY_GATE_TIMEOUT_MS;
+			// The probe-proven 5th parameter: ctx.executeTool runs the built-in
+			// bash tool through the full pipeline in the host process.
+			if (typeof ctx.executeTool !== "function") {
+				const outcome = inconclusiveOutcome(
+					"verify_gate: ctx.executeTool unavailable in this context (no tool-call context factory) — gate not run",
+				);
+				return gateResult(outcome, false);
+			}
+			const executeTool = ctx.executeTool;
+			const outcome = await runVerifyGate(
+				checks,
+				async (command, opts) => {
+					const bashCommand = `cd ${shellQuote(opts.cwd)} && ${command}`;
+					// executeTool never rejects for tool failures (probe): blocked
+					// calls and non-zero exits come back as isError values.
+					const nested = await executeTool(
+						"bash",
+						{ command: bashCommand, timeout: Math.min(Math.ceil(opts.timeoutMs / 1000), BASH_TIMEOUT_MAX_SECONDS) },
+						{ signal },
+					);
+					return readNestedBashResult(nested);
+				},
+				{ cwd, signal, timeoutMs },
+			);
+			try {
+				deps.getMetricRegistry?.()
+					?.counter("crew.verification.verify_gate_runs_total", "Deterministic verify_gate executions by verdict")
+					.inc({ verdict: outcome.verdict, entry: "tool" });
+			} catch {
+				/* metrics are best-effort */
+			}
+			return gateResult(outcome, false);
+		},
+	};
+	pi.registerTool(tool);
+}
+
+function inconclusiveOutcome(note: string): VerifyGateOutcome {
+	return {
+		verdict: "INCONCLUSIVE",
+		checks: [],
+		evidenceLines: [note],
+		allPassed: false,
+		totalDurationMs: 0,
+	};
+}
+
+function gateResult(outcome: VerifyGateOutcome, isError: boolean) {
+	const text = [renderVerifyGateContext(outcome).replace(/\n+$/, "")].join("\n");
+	return {
+		content: [{ type: "text" as const, text }],
+		// Gate verdicts (FAILED/INCONCLUSIVE) are legitimate OUTCOMES, not tool
+		// errors — callers (tools/codemode scripts) branch on structuredContent.
+		details: outcome,
+		structuredContent: {
+			verdict: outcome.verdict,
+			evidenceLines: outcome.evidenceLines,
+			allPassed: outcome.allPassed,
+			totalDurationMs: outcome.totalDurationMs,
+			checks: outcome.checks.map((check) => ({
+				name: check.name,
+				command: check.command,
+				exitCode: check.exitCode,
+				passed: check.passed,
+				durationMs: check.durationMs,
+				...(check.skipped ? { skipped: check.skipped } : {}),
+			})),
+		},
+		isError,
+	};
+}

package/src/extension/team-tool/run-deadline.ts

@@ -22,6 +22,24 @@ export interface RunDeadline {
 /** Fallback deadline when no config or param override is available: 1 hour. */
 export const DEFAULT_RUN_DEADLINE_MS = 3_600_000;
 
+/** Options for resolveRunDeadline. */
+export interface RunDeadlineOptions {
+	/** "abort" (default): arm the deadline timer that ABORTS the controller —
+	 *  deadline expiry cancels the run (direct-await paths: DWF, goal-loop,
+	 *  inline scaffold — the deadline IS the execution bound).
+	 *
+	 *  "watch-only": do NOT arm the abort timer. The deadline bounds only the
+	 *  caller's WATCH (waitForRun timeoutMs). Genuine caller cancels
+	 *  (ctx.signal abort outside a session switch, startForegroundRun callback
+	 *  abort) STILL abort the controller and cancel the run — deadline expiry
+	 *  alone never does. RELIABILITY FIX 2026-10-10 (wave-2 chain incident, run
+	 *  team_20261010045718): the foreground lane's armed timer was aborting
+	 *  executeTeamRun's signal at the 60-minute watch boundary — chain steps
+	 *  reported "partial" AND the still-healthy child run was cancelled. The
+	 *  watch is a timer; the cancel must be a caller decision. */
+	timer?: "abort" | "watch-only";
+}
+
 /**
  * Resolve a unified run deadline with a shared AbortController.
  *
@@ -49,6 +67,7 @@ export function resolveRunDeadline<T extends object>(
 	ctx: Pick<TeamContext, "cwd" | "signal">,
 	params: T,
 	config?: PiTeamsConfig,
+	options?: RunDeadlineOptions,
 ): RunDeadline {
 	const timeoutMs = (params as { timeoutMs?: number }).timeoutMs;
 	const effectiveConfig = config ?? loadConfig(ctx.cwd).config;
@@ -94,8 +113,10 @@ export function resolveRunDeadline<T extends object>(
 	// otherwise every run leaves a dangling 1h timer retaining ctx/params in closure.
 	// Same abort-after-exit guard as above: the timer may fire after workers
 	// already exited and their spawn-signal listeners are gone — Node can throw.
+	// "watch-only" (bug #2 fix): the timer is NOT armed — the deadline bounds the
+	// watch only, so the controller can only be aborted by a real caller cancel.
 	let timer: NodeJS.Timeout | undefined;
-	if (deadlineMs > 0) {
+	if (deadlineMs > 0 && options?.timer !== "watch-only") {
 		timer = setTimeout(() => safeAbort(controller, "run-deadline.timer"), deadlineMs);
 		timer.unref?.();
 	}

package/src/extension/team-tool/run.ts

@@ -71,7 +71,7 @@ import * as path from "node:path";
 import { t } from "../../i18n.ts";
 import { hasAsyncStartMarker } from "../../runtime/async-marker.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
-import { registerRunPromise, waitForRun } from "../../runtime/run-tracker.ts";
+import { isWaitForRunTimeoutError, registerRunPromise, waitForRun } from "../../runtime/run-tracker.ts";
 import { collectRunMetrics } from "../../state/stores/run-metrics.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { effectiveRunConfig } from "./config-patch.ts";
@@ -709,7 +709,14 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const executeWorkers = runtime.kind !== "scaffold";
 	if (executeWorkers && ctx.startForegroundRun) {
 		// CORE-8: unified deadline — resolves params > config > 1h default.
-		const fgDeadline = resolveRunDeadline(ctx, params, executedConfig);
+		// RELIABILITY FIX 2026-10-10 (bug #2, wave-2 chain incident run
+		// team_20261010045718): the foreground deadline is WATCH-ONLY. The armed
+		// abort timer used to cancel executeTeamRun's signal at the watch
+		// boundary (60m default) — chain steps reported "partial" AND the
+		// still-healthy child run was cancelled. waitForRun's own timeout still
+		// bounds the watch (partial-watch result below); real caller cancels
+		// (ctx.signal / foreground-run callback abort) still cancel the run.
+		const fgDeadline = resolveRunDeadline(ctx, params, executedConfig, { timer: "watch-only" });
 		// F1 register/await race fix (2026-09-12): the waitForRun below runs
 		// immediately after startForegroundRun returns (void), while
 		// executeTeamRunCore registers its promise only after several awaits —
@@ -842,6 +849,35 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			});
 		} catch (waitError: unknown) {
 			const waitErrMsg = errorMessage(waitError);
+			// RELIABILITY FIX 2026-10-10 (bug #2): a waitForRun WATCH expiry is NOT a
+			// run failure — with the watch-only deadline the run keeps executing in
+			// the foreground lane (exactly like the detached case) and the async
+			// notifier reports completion later. Report a partial-watch instead of an
+			// error so chain wrappers map the still-running step to "partial"
+			// without anyone reading this as "the run was cancelled/failed".
+			if (isWaitForRunTimeoutError(waitError)) {
+				return result(
+					[
+						`pi-crew run still running (watch window expired): ${updatedManifest.runId}`,
+						`Team: ${team.name}`,
+						`Workflow: ${workflow.name}`,
+						`Watch: ${waitErrMsg} — the run was NOT cancelled and keeps executing.`,
+						"",
+						"You will be notified when the run finishes.",
+						`Check status with: team action=status runId=${updatedManifest.runId}`,
+						`Wait again with: team action=wait runId=${updatedManifest.runId}`,
+						`State: ${updatedManifest.stateRoot}`,
+					].join("\n"),
+					{
+						action: "run",
+						status: "ok",
+						runId: updatedManifest.runId,
+						artifactsRoot: updatedManifest.artifactsRoot,
+						partialWatch: true,
+					},
+					false,
+				);
+			}
 			return result(
 				[
 					`pi-crew run timed out or failed: ${updatedManifest.runId}`,

package/src/extension/team-tool-types.ts

@@ -29,6 +29,10 @@ export interface TeamToolDetails {
 	taskId?: string;
 	questionId?: string;
 	waiting?: boolean;
+	/** RELIABILITY FIX 2026-10-10 (bug #2): set when the foreground run's WATCH
+	 * window expired (waitForRun timeout) — the run itself was NOT cancelled
+	 * and keeps executing; the async notifier reports completion later. */
+	partialWatch?: boolean;
 	/** Structured data for programmatic consumption (e.g. TUI widgets). */
 	data?: Record<string, unknown>;
 }

package/src/extension/team-tool.ts

@@ -493,7 +493,7 @@ async function resumeDynamicWorkflowRun(
 		return result(
 			[
 				`Resumed dynamic-workflow run ${dwfResult.manifest.runId}.`,
-				`Status: ${dwfResult.manifest.status}`,
+				`Status: ${dwfResult.manifest.status} — resumed execution returned`,
 				dwfResult.manifest.summary ? `Result: ${dwfResult.manifest.summary}` : undefined,
 			]
 				.filter((line): line is string => line !== undefined)
@@ -819,6 +819,13 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 					}
 				: task,
 		);
+		// RELIABILITY FIX 2026-10-10 (bug #3): count the tasks actually re-queued at
+		// resume so the result message can report what happened (work re-dispatched
+		// vs "run was already terminal, nothing to resume") instead of a bare
+		// "Status: completed" that reads as "everything finished instantly".
+		const requeuedCount = recovered.tasks.filter(
+			(task) => task.status === "failed" || task.status === "cancelled" || task.status === "skipped" || task.status === "running",
+		).length;
 		saveRunTasks(runtimeManifest, resetTasks);
 		const replay = replayPendingMailboxMessages(runtimeManifest);
 		await appendEventAsync(runtimeManifest.eventsPath, {
@@ -874,6 +881,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 			kind: "execute" as const,
 			runtimeManifest: executingManifest,
 			resetTasks,
+			requeuedCount,
 			executeWorkers,
 			resumeSkillOverride,
 			runtime,
@@ -909,12 +917,32 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		// Finding 8: resume is the legitimate terminal-exit flow.
 		isResume: true,
 	});
+	// RELIABILITY FIX 2026-10-10 (bug #3, wave-2/wave-3 observations): the old
+	// message printed a bare "Status: completed" which read as "the whole run
+	// just finished" even when the resume had re-queued real work that kept
+	// executing. Report the truth: what the resumed execution returned, how
+	// much work was re-queued at resume, and the per-status task breakdown.
+	const statusLine =
+		executed.manifest.status === "completed"
+			? "completed — resumed execution finished (all tasks terminal)"
+			: executed.manifest.status === "running"
+				? "running — resumed dispatch is still executing"
+				: `${executed.manifest.status} — resumed execution ended in this state`;
+	const taskCounts = executed.tasks.reduce<Record<string, number>>((acc, task) => {
+		acc[task.status] = (acc[task.status] ?? 0) + 1;
+		return acc;
+	}, {});
+	const countsText = Object.entries(taskCounts)
+		.map(([status, count]) => `${count} ${status}`)
+		.join(", ");
 	return result(
 		[
 			`Resumed run ${executed.manifest.runId}.`,
-			`Status: ${executed.manifest.status}`,
-			`Tasks: ${executed.tasks.length}`,
+			`Status: ${statusLine}`,
+			`Resumed work: ${decision.requeuedCount} task(s) re-queued${decision.requeuedCount === 0 ? " (run was already terminal — nothing to resume)" : ""}`,
+			`Tasks: ${executed.tasks.length} (${countsText})`,
 			`Artifacts: ${executed.manifest.artifactsRoot}`,
+			`Check live status with: team action=status runId=${executed.manifest.runId}`,
 		].join("\n"),
 		{
 			action: "resume",