pi-crew 0.11.2 → 0.11.5

package/src/runtime/goal-workflow/goal-loop-runner.ts

@@ -29,6 +29,7 @@ import type { TeamConfig } from "../../teams/team-config.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
 import { resolveCrewRuntime } from "../model/runtime-resolver.ts";
+import { registryFromModelContext } from "../model/session-model.ts";
 import { executeTeamRun } from "../team-runner.ts";
 import { compareSnapshot, snapshotManifests } from "../verification/verification-integrity.ts";
 import { acquireWorkspaceLock, type WorkspaceLockHandle } from "../workspace-lock.ts";
@@ -65,6 +66,29 @@ export interface RunGoalLoopResult {
 	goalState: GoalLoopState;
 }
 
+/**
+ * Finding #1 (battery 2026-09-29): re-hydrate the model routing inputs the
+ * OUTER goal-loop manifest persisted at dispatch time (captureRunModelContext
+ * in goal.ts / goal-wrap.ts). The detached goal-loop runs in the background
+ * runner with no ExtensionContext — without this, every turn's executeTeamRun
+ * resolves the DEFAULT chain (live: minimax/MiniMax-M3 402 while the parent
+ * session ran zai/glm-5.3). Mirrors background-runner's restoredModelRouting().
+ */
+function restoredTurnModelRouting(manifest: TeamRunManifest): {
+	modelOverride?: string;
+	parentModel?: string;
+	modelRegistry?: { getAvailable: () => unknown[] };
+} {
+	const context = manifest.modelContext;
+	if (!context) return {};
+	const modelRegistry = registryFromModelContext(context);
+	return {
+		...(context.override ? { modelOverride: context.override } : {}),
+		...(context.parentModel ? { parentModel: context.parentModel } : {}),
+		...(modelRegistry ? { modelRegistry } : {}),
+	};
+}
+
 /**
  * The placeholder evaluator for P0: always returns {achieved:false}.
  * Kept for unit tests of the loop's max_turns exit path. The production loop
@@ -630,6 +654,10 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 				workspaceMode: "single",
 				ownerSessionId: goal.ownerSessionId,
 				runKind: "team-run", // §0a v2 note: turns are normal team-runs; the OUTER loop is goal-loop
+				// Finding #1: turns execute in the detached process — carry the outer
+				// manifest's model routing snapshot onto each turn manifest too, so
+				// status/resume paths see the same routing the turn was dispatched with.
+				...(manifest.modelContext ? { modelContext: manifest.modelContext } : {}),
 			});
 			goal =
 				store.patch(
@@ -689,6 +717,10 @@ export async function runGoalLoop(input: RunGoalLoopInput): Promise<RunGoalLoopR
 					limits: turnExecutedConfig.limits,
 					runtime: turnRuntime,
 					runtimeConfig: turnExecutedConfig.runtime,
+					// Finding #1: restore the dispatch-time model routing (see
+					// restoredTurnModelRouting) — executeTeamRun in THIS process has no
+					// ExtensionContext to inherit the session model from.
+					...restoredTurnModelRouting(manifest),
 					reliability: turnExecutedConfig.reliability,
 					workspaceId: goal.ownerSessionId ?? goal.cwd,
 					signal,

package/src/runtime/group-join.ts

@@ -59,9 +59,17 @@ export function deliverGroupJoin(input: {
 }): CrewGroupJoinDelivery | undefined {
 	if (!shouldGroupJoin(input.mode, input.batch)) return undefined;
 	const taskIds = input.batch.map((task) => task.id);
-	const latest = taskIds
-		.map((id) => input.allTasks.find((task) => task.id === id))
-		.filter((task): task is TeamTaskState => Boolean(task));
+	// RR-021 WI-4.3d: first-wins Map — the old taskIds.map(id => allTasks.find())
+	// was O(batch×allTasks). NOT a raw input.batch pass-through: callers may
+	// hold stale batch snapshots, and the only audited production caller
+	// (team-runner closeout) passes fresh references — but the Map keeps the
+	// exact `.find` first-match semantics for every caller (incl. tests) while
+	// staying O(n+m). Batch order is preserved (map follows taskIds).
+	const taskById = new Map<string, TeamTaskState>();
+	for (const task of input.allTasks) {
+		if (!taskById.has(task.id)) taskById.set(task.id, task);
+	}
+	const latest = taskIds.map((id) => taskById.get(id)).filter((task): task is TeamTaskState => Boolean(task));
 	const completed = statusList(latest, "completed");
 	const failed = statusList(latest, "failed");
 	const skipped = statusList(latest, "skipped");

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

@@ -96,7 +96,7 @@ let liveSessionModulePromise: Promise<LiveSessionModule> | undefined;
 let experimentalWarned = false;
 function loadLiveSessionModule(): Promise<LiveSessionModule> {
 	if (!liveSessionModulePromise) {
-		liveSessionModulePromise = import("@earendil-works/pi-coding-agent") as unknown as Promise<LiveSessionModule>;
+		liveSessionModulePromise = import("@earendil-works/pi-coding-agent") as unknown as Promise<LiveSessionModule>; // LAZY: defer pi-coding-agent live-session module until first use
 	}
 	return liveSessionModulePromise;
 }

package/src/runtime/model/runtime-warmup.ts

@@ -124,6 +124,7 @@ export function startRuntimeWarmup(): void {
 		for (const spec of HOT_MODULE_SPECIFIERS) {
 			imports.push(
 				import(new URL(spec, import.meta.url).href).catch(() => {
+					// LAZY: best-effort warmup import, failures tolerated
 					// swallow — never block registration on a warmup failure
 				}),
 			);
@@ -131,6 +132,7 @@ export function startRuntimeWarmup(): void {
 		for (const dep of HOT_PEER_DEPS) {
 			imports.push(
 				import(dep).catch(() => {
+					// LAZY: best-effort warmup import, failures tolerated
 					// peer dep may be absent (optional dep) — swallow
 				}),
 			);

package/src/runtime/output/output-validator.ts

@@ -123,10 +123,15 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
  *
  * A trimmed non-empty line counts as log noise ONLY if it matches one of:
  *  1. a bracket-tag extension log line: `[oc-go] ...`, `[pi-qwen-mm] ...`,
- *     `[pi-qwen-mm] [core] [stderr] ...` — the leading tag is a lowercase
- *     identifier (deliberately excludes capitalized bracketed prose like
- *     `[Note] ...`), optionally followed by known sub-tags
- *     (core/mcp/stderr/stdout/warn/info/error/debug);
+ *     `[pi-qwen-mm] [core] [stderr] ...`, and — Finding #2 (2026-09-29
+ *     battery) — colon-bearing extension tags like
+ *     `[pi-crew:crash-recovery.reconcileStaleRuns] ...` or
+ *     `[pi-crew:crew-vibes.publish-quota-status] ...`. The leading tag
+ *     starts with a lowercase char (deliberately excludes capitalized
+ *     bracketed prose like `[Note] ...` / `[Note: ...]`); the rest of the tag
+ *     may carry `:`, `-`, `_`, `.`, digits, and inner capitals (extension
+ *     subsystem names are camelCase, e.g. `reconcileStaleRuns`), optionally
+ *     followed by known sub-tags (core/mcp/stderr/stdout/warn/info/error/debug);
  *  2. a Python `warnings.warn(` line (deprecation-warning continuation);
  *  3. a timestamped logging line: `2026-08-15 21:49:02,986 WARNING ...`.
  *
@@ -137,7 +142,7 @@ export function validateWorkerOutput(role: string, output: string): OutputValida
  * (post-execution.ts) applies the two-gate rule (authoritative output
  * sources empty AND artifact log-noise-only) before failing a task.
  */
-const BRACKET_TAG_LOG_LINE = /^\[[a-z0-9][a-z0-9_.-]*\](?:\s*\[(?:core|mcp|stderr|stdout|warn|info|error|debug)\])*(?:\s.*)?$/;
+const BRACKET_TAG_LOG_LINE = /^\[[a-z0-9][a-zA-Z0-9_.:\-]*\](?:\s*\[(?:core|mcp|stderr|stdout|warn|info|error|debug)\])*(?:\s.*)?$/;
 const PYTHON_WARNING_LINE = /(?:^|\s)warnings\.warn\(/;
 const TIMESTAMPED_LOG_LINE = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:[.,]\d{1,6})?(?:Z|[+-]\d{2}:?\d{2})?\s+[A-Za-z]+\b/;
 

package/src/runtime/plan-approval.ts

@@ -70,7 +70,20 @@ export async function ensurePlanApprovalRequested(manifest: TeamRunManifest, tas
 	const assessTask = tasks.find((task) => task.stepId === "assess" && task.status === "completed");
 	// ROADMAP T1.2: for non-adaptive workflows, fall back to the most recent
 	// completed read-only (planning) task as the plan reference.
-	const planTask = assessTask ?? [...tasks].reverse().find((t) => t.status === "completed" && !isMutatingTask(t));
+	// RR-021 WI-4.3e: allocation-free reverse scan — the old
+	// [...tasks].reverse().find() copied the whole array per call.
+	// (findLast needs an ES2023 lib bump, which breaks tsgo's RequestInfo
+	// ambient resolution — see WI-4.3 evidence note.)
+	let planTask = assessTask;
+	if (!planTask) {
+		for (let i = tasks.length - 1; i >= 0; i--) {
+			const t = tasks[i];
+			if (t?.status === "completed" && !isMutatingTask(t)) {
+				planTask = t;
+				break;
+			}
+		}
+	}
 	const now = new Date().toISOString();
 
 	// T2/R4 (ADR-4 §6 producer 3 + §8 dual-write): make sure a PlanRecord

package/src/runtime/recovery/crash-recovery.ts

@@ -4,10 +4,16 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_PATHS } from "../../config/defaults.ts";
 import { appendHookEvent, executeHook } from "../../hooks/registry.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
-import { discoverRunLockFiles, sweepStaleLocks, withRunLockSync } from "../../state/coordination/locks.ts";
+import { discoverRunLockFiles, sweepStaleLocks, withRunLock, withRunLockSync } from "../../state/coordination/locks.ts";
 import { appendEvent, scanSequence } from "../../state/event-log/event-log.ts";
 import { readActiveRunRegistry, unregisterActiveRun } from "../../state/stores/active-run-registry.ts";
-import { loadRunManifestById, saveRunManifest, saveRunTasks, updateRunStatus } from "../../state/stores/state-store.ts";
+import {
+	loadRunManifestById,
+	loadRunManifestByIdAsync,
+	saveRunManifest,
+	saveRunTasks,
+	updateRunStatus,
+} from "../../state/stores/state-store.ts";
 import type { TeamTaskState } from "../../state/types.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
@@ -18,6 +24,7 @@ import { isWorkerHeartbeatStale } from "../heartbeat/worker-heartbeat.ts";
 import { terminateLiveAgentsForRun } from "../live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../manifest-cache.ts";
 import { checkProcessLiveness } from "../process-status.ts";
+import { mapConcurrent } from "../scheduling/parallel-utils.ts";
 import { isIntentionalWait, isPlanApprovalPendingEffective, type ReconcileResult, reconcileStaleRun } from "../stale-reconciler.ts";
 
 export interface RecoveryPlan {
@@ -690,13 +697,12 @@ export function purgeStaleActiveRunIndex(
 	return { purged, kept };
 }
 
-export function reconcileAllStaleRuns(
+export async function reconcileAllStaleRuns(
 	cwd: string,
 	manifestCache: ManifestCache,
 	now = Date.now(),
 	currentSessionId?: string,
-): ReconcileResult[] {
-	const results: ReconcileResult[] = [];
+): Promise<ReconcileResult[]> {
 	// Capture runIds to reconcile BEFORE acquiring locks — avoids TOCTOU between cache iteration and lock acquisition.
 	const runIds = manifestCache
 		.list(50)
@@ -708,56 +714,78 @@ export function reconcileAllStaleRuns(
 			return true;
 		})
 		.map((m) => m.runId);
-	for (const runId of runIds) {
-		const cached = manifestCache.get(runId);
-		if (!cached) continue;
-		const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
-		if (!loaded) continue;
-		// Use lock to prevent race with cancel/status handlers modifying the same run
-		withRunLockSync(loaded.manifest, () => {
-			// Re-read inside lock to get freshest data
-			const fresh = loadRunManifestById(cwd, runId); // NOTE: inside withRunLockSync - consistent read
-			if (!fresh || (fresh.manifest.status !== "running" && fresh.manifest.status !== "blocked")) return;
-			// Belt-and-suspenders: reconcileStaleRun itself guards this, but the run
-			// may have flipped to blocked+plan-approval between cache-list and lock
-			// acquisition — re-check the freshest manifest under the lock.
-			if (isPlanApprovalPendingEffective(fresh.manifest)) {
-				results.push({
-					runId,
-					verdict: "blocked_awaiting_approval",
-					repaired: false,
-					detail: "Plan approval is pending; stale reconciliation skipped",
-				});
-				return;
-			}
-			const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
-			if (result.repaired || result.verdict === "result_exists") {
-				if (result.repairedTasks) {
-					saveRunTasks(fresh.manifest, result.repairedTasks);
-					for (const task of result.repairedTasks) {
-						try {
-							upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
-						} catch {
-							/* non-critical */
+	// RR-021 WI-1.5 (audit C3): serial reconcile → mapConcurrent bound 4.
+	// Each runId acquires its OWN run lock file (lockPath() is per-run), so the
+	// acquisitions are independent; bound 4 caps fs/CPU contention. Results keep
+	// input (snapshot) order — mapConcurrent indexes by item — and per-run
+	// semantics (re-read inside lock, plan-approval re-check) are unchanged.
+	const perRun = await mapConcurrent(runIds, 4, async (runId): Promise<ReconcileResult[]> => {
+		// RR-021 review remediation: per-run error isolation — one corrupt run
+		// must not reject the whole sweep (serial baseline threw too, but the
+		// SPEC's "independent per-run" intent requires continue-on-error).
+		try {
+			const cached = manifestCache.get(runId);
+			if (!cached) return [];
+			const loaded = await loadRunManifestByIdAsync(cwd, runId); // NOTE: best-effort only; concurrent writes may cause inconsistency
+			if (!loaded) return [];
+			const out: ReconcileResult[] = [];
+			// Use lock to prevent race with cancel/status handlers modifying the same run.
+			// Same v0.9.26 lock family as the old sync acquisition — interop-safe.
+			await withRunLock(loaded.manifest, async () => {
+				// Re-read inside lock to get freshest data
+				const fresh = await loadRunManifestByIdAsync(cwd, runId); // NOTE: inside withRunLock - consistent read
+				if (!fresh || (fresh.manifest.status !== "running" && fresh.manifest.status !== "blocked")) return;
+				// Belt-and-suspenders: reconcileStaleRun itself guards this, but the run
+				// may have flipped to blocked+plan-approval between cache-list and lock
+				// acquisition — re-check the freshest manifest under the lock.
+				if (isPlanApprovalPendingEffective(fresh.manifest)) {
+					out.push({
+						runId,
+						verdict: "blocked_awaiting_approval",
+						repaired: false,
+						detail: "Plan approval is pending; stale reconciliation skipped",
+					});
+					return;
+				}
+				const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
+				if (result.repaired || result.verdict === "result_exists") {
+					if (result.repairedTasks) {
+						// NEW-1 (SDD 2026-09-30 WI-2): persist the FULL task array — the
+						// individual-stale branch filters `repairedTasks` down to the stale
+						// subset, and saveRunTasks full-overwrites tasks.json, which used to
+						// drop every healthy task from disk. `persistTasks` carries the full
+						// array; every other branch leaves it unset and falls back here.
+						saveRunTasks(fresh.manifest, result.persistTasks ?? result.repairedTasks);
+						for (const task of result.repairedTasks) {
+							try {
+								upsertCrewAgent(fresh.manifest, recordFromTask(fresh.manifest, task, "scaffold"));
+							} catch {
+								/* non-critical */
+							}
 						}
 					}
+					updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
+					void terminateLiveAgentsForRun(fresh.manifest.runId, "failed", appendEvent, fresh.manifest.eventsPath).catch((error) =>
+						logInternalError("crash-recovery.reconcile.terminate", error, `runId=${fresh.manifest.runId}`, "warn"),
+					);
+					appendEvent(fresh.manifest.eventsPath, {
+						type: "crew.run.reconciled_stale",
+						runId,
+						message: result.detail,
+						data: { verdict: result.verdict },
+					});
 				}
-				updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
-				void terminateLiveAgentsForRun(fresh.manifest.runId, "failed", appendEvent, fresh.manifest.eventsPath).catch((error) =>
-					logInternalError("crash-recovery.reconcile.terminate", error, `runId=${fresh.manifest.runId}`, "warn"),
-				);
-				appendEvent(fresh.manifest.eventsPath, {
-					type: "crew.run.reconciled_stale",
-					runId,
-					message: result.detail,
-					data: { verdict: result.verdict },
-				});
-			}
-			if (result.verdict !== "healthy") {
-				results.push(result);
-			}
-		});
-	}
+				if (result.verdict !== "healthy") {
+					out.push(result);
+				}
+			});
+			return out;
+		} catch (error) {
+			logInternalError("crash-recovery.reconcileStaleRuns", error, `runId=${runId}`, "warn");
+			return [];
+		}
+	});
+	const results = perRun.flat();
 	// US-002 (2026-09-22): structured stale-lock sweep. Runs after reconciliation
 	// so locks whose holder died (kill -9 / crash) do not linger. The sweep is
 	// strictly safer than acquire-time steal (stale AND holder-dead only), so a

package/src/runtime/stale-reconciler.ts

@@ -44,6 +44,13 @@ export interface ReconcileResult {
 	detail: string;
 	/** Repaired task state, returned to a locked caller for persistence. */
 	repairedTasks?: TeamTaskState[];
+	/** NEW-1 (SDD 2026-09-30 WI-2): what the caller should PERSIST — the FULL
+	 *  task array, including tasks the repair did not touch. Only the
+	 *  individual-stale branch sets it (its `repairedTasks` is filtered down to
+	 *  the stale subset, which must NOT be full-overwrite-persisted or healthy
+	 *  tasks vanish from tasks.json). Callers fall back to `repairedTasks`
+	 *  when absent — every other branch already returns the full array there. */
+	persistTasks?: TeamTaskState[];
 }
 
 /**
@@ -490,6 +497,7 @@ export function reconcileStaleRun(manifest: TeamRunManifest, tasks: TeamTaskStat
 				repaired: true,
 				detail: `No PID; ${staleTaskIds.length} individually stale task(s) repaired: ${staleTaskIds.join(", ")}`,
 				repairedTasks: repaired.filter((t) => staleTaskIds.includes(t.id)),
+				persistTasks: repaired, // NEW-1: persist FULL array (data-loss fix — SDD WI-2)
 			};
 		}
 		// Fall through: no recent activity but not all tasks stale enough yet.

package/src/runtime/subagent-manager.ts

@@ -342,16 +342,43 @@ export class SubagentManager {
 		}
 	}
 
-	async waitForRecord(id: string): Promise<SubagentRecord | undefined> {
+	async waitForRecord(id: string, timeoutMs = 300_000): Promise<SubagentRecord | undefined> {
+		// RR-021 WI-4.3i: bounded wait. A record with no promise whose status
+		// stays running/blocked used to spin forever (100ms sleep loop). On
+		// deadline expiry we return the CURRENT record — never undefined, which
+		// would be ambiguous with 'no such record'. Callers can inspect
+		// record.status to see the wait timed out on a still-active record.
+		const deadline = Date.now() + timeoutMs;
 		while (true) {
 			const record = this.records.get(id);
 			if (!record) return undefined;
 			if (record.status !== "running" && record.status !== "queued") return record;
-			if (record.promise)
-				await record.promise.catch((error) => {
-					logInternalError("subagent-manager.waitForRecord", error, `id=${id}`);
-				});
-			else await new Promise((resolve) => setTimeout(resolve, 100));
+			if (Date.now() > deadline) return record;
+			if (record.promise) {
+				// Race the run promise against the remaining deadline — a wedged
+				// promise must not block the deadline check.
+				const remaining = deadline - Date.now();
+				let timer: NodeJS.Timeout | undefined;
+				try {
+					await Promise.race([
+						record.promise.catch((error) => {
+							logInternalError("subagent-manager.waitForRecord", error, `id=${id}`);
+						}),
+						// RR-021 review remediation: this timer MUST stay ref'd. unref() let the
+						// event loop drain before the deadline fired (node:test then cancels the
+						// awaiting test — "Promise resolution is still pending but the event loop
+						// has already resolved"). Always clearTimeout'd in the finally below, so
+						// ref'ing cannot leak (knowledge.md OwnedProcess timer guidance).
+						new Promise<void>((resolve) => {
+							timer = setTimeout(resolve, remaining);
+						}),
+					]);
+				} finally {
+					if (timer !== undefined) clearTimeout(timer);
+				}
+			} else {
+				await new Promise((resolve) => setTimeout(resolve, Math.min(100, Math.max(1, deadline - Date.now()))));
+			}
 		}
 	}
 
@@ -477,19 +504,22 @@ export class SubagentManager {
 	}
 
 	private async pollRunToTerminal(cwd: string, record: SubagentRecord): Promise<void> {
-		// Safety: max 30 minutes (1800 polls at 1s interval) to prevent infinite
-		// polling if manifest file is deleted or run state becomes unrecoverable.
-		const MAX_POLL_COUNT = 1800;
-		let pollCount = 0;
+		// Safety: max 30 minutes of WALL-CLOCK polling to prevent infinite
+		// polling if the manifest file is deleted or run state becomes unrecoverable.
+		// (RR-021 WI-4.3h: was MAX_POLL_COUNT=1800, which silently assumed a 1s
+		// pollIntervalMs — but the interval is configurable, so a 5s interval
+		// polled for 2.5h while a 200ms interval timed out after 6 minutes.)
+		const POLL_DEADLINE_MS = 30 * 60 * 1000;
+		const pollDeadline = Date.now() + POLL_DEADLINE_MS;
 		while (record.runId && (record.status === "running" || record.status === "blocked")) {
-			if (++pollCount > MAX_POLL_COUNT) {
+			if (Date.now() > pollDeadline) {
 				logInternalError(
 					"subagent-manager.poll-timeout",
-					new Error(`pollRunToTerminal exceeded ${MAX_POLL_COUNT} polls for runId=${record.runId}`),
+					new Error(`pollRunToTerminal exceeded ${POLL_DEADLINE_MS}ms wall-clock for runId=${record.runId}`),
 					`id=${record.id}`,
 				);
 				record.status = "error";
-				record.error = `Poll timeout: run did not reach terminal state after ${MAX_POLL_COUNT} seconds`;
+				record.error = `Poll timeout: run did not reach terminal state after ${POLL_DEADLINE_MS}ms (wall-clock)`;
 				record.completedAt = Date.now();
 				savePersistedSubagentRecord(cwd, record);
 				return;

package/src/runtime/task-output-context.ts

@@ -526,6 +526,16 @@ export function collectDependencyOutputContext(
 	return { dependencies: trimmedDependencies, sharedReads };
 }
 
+// ADR-5 §trust-fence: dependency output is DATA, never instructions. Mirror the
+// ask/delegate seams in src/prompt/prompt-runtime.ts (:323, :426, :589): strip
+// control chars and neutralize a smuggled closing fence tag so worker-controlled
+// content can never close the <dependency-context> fence early (see SDD 2026-09-30 WI-1).
+const DEPENDENCY_CONTROL_CHAR_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+
+function sanitizeFencedBody(body: string): string {
+	return body.replace(DEPENDENCY_CONTROL_CHAR_PATTERN, "").replace(/<\/dependency-context/g, "&lt;/dependency-context");
+}
+
 export function renderDependencyOutputContext(context: DependencyOutputContext): string {
 	const parts: string[] = [];
 	if (context.dependencies.length) {
@@ -565,7 +575,7 @@ export function renderDependencyOutputContext(context: DependencyOutputContext):
 			parts.push("", read.content.trim(), "");
 		}
 	}
-	return parts.join("\n").trim();
+	return sanitizeFencedBody(parts.join("\n").trim());
 }
 
 export function writeTaskSharedOutput(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState): ArtifactDescriptor | undefined {

package/src/runtime/task-runner/child-executor.ts

@@ -68,7 +68,7 @@ import { DEFAULT_RETRY_POLICY } from "../recovery/retry-executor.ts";
 import { runWorker } from "../run-worker.ts";
 import { parseSessionUsage } from "../session-usage.ts";
 import { recordSupervisorContact, supervisorContactFromEvent } from "../supervisor-contact.ts";
-import type { TaskExecutionResult } from "./post-execution.ts";
+import type { ResultSource, TaskExecutionResult } from "./post-execution.ts";
 import type { StreamBridgeHandle, TaskExecutionContext } from "./pre-execution.ts";
 import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./progress.ts";
 import { cleanResultText, isFinalChildEvent } from "./result-utils.ts";
@@ -987,6 +987,20 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			});
 		}
 	}
+	// Finding #2 (2026-09-29 battery): tag WHICH fallback branch produced the
+	// artifact so post-execution can fail stderr/none-sourced results
+	// deterministically — the noise classifier alone is not a verdict oracle.
+	// Order/semantics are identical to the previous `??` chain: first branch
+	// whose cleaned text is non-empty wins; otherwise the placeholder ("none").
+	const resultCandidates: ReadonlyArray<{ source: ResultSource; text: string | undefined }> = [
+		{ source: "rawFinalText", text: cleanResultText(rawFinalText) },
+		{ source: "finalText", text: cleanResultText(parsedOutput?.finalText) },
+		{ source: "stdout", text: cleanResultText(finalStdout) },
+		{ source: "stderr", text: cleanResultText(finalStderr) },
+		{ source: "findings", text: cleanResultText(intermediateFindings) },
+	];
+	const usedResult = resultCandidates.find((candidate) => candidate.text);
+	const resultSource: ResultSource = usedResult?.source ?? "none";
 	const resultArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "result",
 		relativePath: `results/${task.id}.txt`,
@@ -995,14 +1009,10 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			// transcript's 16K compaction — this is the authoritative worker output.
 			// Fall back to transcript-derived finalText, then stdout/stderr, so a
 			// missing raw capture (mock/error path) never yields empty/garbage.
-			cleanResultText(rawFinalText) ??
-			cleanResultText(parsedOutput?.finalText) ??
-			cleanResultText(finalStdout) ??
-			cleanResultText(finalStderr) ??
+			usedResult?.text ??
 			// #7 hardening: if all real output paths are empty (worker exhausted
 			// budget on tool calls, no assistant text), use intermediate findings.
 			// intermediateFindings captures the last N tool-result display lines.
-			cleanResultText(intermediateFindings) ??
 			"(no output)",
 		producer: task.id,
 	});
@@ -1094,6 +1104,7 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		parsedOutput,
 		finalStdout,
 		rawFinalText,
+		resultSource,
 		transcriptPath,
 		terminalEvidence,
 		startupEvidence,

package/src/runtime/task-runner/post-execution.ts

@@ -85,8 +85,18 @@ export interface TaskExecutionResult {
 	transcriptPath: string | undefined;
 	terminalEvidence: OperationTerminalEvidence[];
 	startupEvidence: import("../heartbeat/worker-startup.ts").WorkerStartupEvidence;
+	/** Which child-executor fallback branch produced the result artifact
+	 *  content (rawFinalText → finalText → stdout → stderr → findings →
+	 *  "(no output)"). Finding #2 (2026-09-29 battery): "stderr"/"none" mean
+	 *  every authoritative worker output source was empty — finalizeTaskResult
+	 *  fails those DETERMINISTICALLY; the stderr-noise classifier stays a
+	 *  defense layer, never the verdict oracle. */
+	resultSource?: ResultSource;
 }
 
+/** Result-artifact provenance tags (see {@link TaskExecutionResult.resultSource}). */
+export type ResultSource = "rawFinalText" | "finalText" | "stdout" | "stderr" | "findings" | "none";
+
 /** Final persisted task state returned by finalizeTaskResult. */
 export interface FinalTaskResult {
 	manifest: TeamRunManifest;
@@ -121,6 +131,7 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 	const skillNames = ctx.skillNames;
 	const skillPaths = ctx.skillPaths;
 	const promptArtifact = ctx.promptArtifact;
+	const breakdownArtifact = ctx.breakdownArtifact;
 	const inputsArtifact = ctx.inputsArtifact;
 	const skillArtifact = ctx.skillArtifact;
 	const coordinationArtifact = ctx.coordinationArtifact;
@@ -328,24 +339,39 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 	//            result ALWAYS surfaces in at least one authoritative source);
 	//   gate 2 — the persisted artifact is empty/'(no output)'/whitespace OR
 	//            isStderrOnlyResult says every line is strict log noise.
-	// A read error on the artifact is NOT a failure (conservative). Mirrors the
-	// mutation-guard fail-mode precedent: error marker + exitCode bump + last
-	// modelAttempt success:false → status flips to "failed" (retryable).
+	// Finding #2 (2026-09-29 battery): gate 2 alone is not a verdict oracle —
+	// the strict-noise classifier missed colon-bearing/camelCase extension
+	// tags (`[pi-crew:crash-recovery.reconcileStaleRuns]`, lock-contention
+	// noise about a SIBLING run), so attempts whose stderr carried them
+	// completed tasks with 100%-noise artifacts while sibling attempts on the
+	// same runs failed — verdict divergence depended on per-attempt stderr
+	// composition. The child-executor fallback chain now tags the winning
+	// branch (resultSource); "stderr"/"none"-sourced artifacts fail
+	// UNCONDITIONALLY (classifier-independent), making empty/stderr-only
+	// results never complete a task, uniformly across roles.
+	// A read error on the artifact is NOT a failure (conservative) — unless
+	// the source tag already proves the artifact is stderr/none-sourced.
+	// Mirrors the mutation-guard fail-mode precedent: error marker + exitCode
+	// bump + last modelAttempt success:false → status flips to "failed" (retryable).
 	if (!error) {
 		const finalTextEmpty = !parsedOutput?.finalText?.trim();
 		const finalStdoutEmpty = !finalStdout?.trim();
-		if (finalTextEmpty && finalStdoutEmpty && resultArtifact?.path) {
+		const resultSource = execResult.resultSource;
+		const degradedResultSource = resultSource === "stderr" || resultSource === "none";
+		if (finalTextEmpty && finalStdoutEmpty && (resultArtifact?.path || degradedResultSource)) {
 			let artifactContent: string | undefined;
-			try {
-				artifactContent = readFileSync(resultArtifact.path, "utf8");
-			} catch {
-				artifactContent = undefined; // unreadable artifact — do not fail on read errors
+			if (resultArtifact?.path) {
+				try {
+					artifactContent = readFileSync(resultArtifact.path, "utf8");
+				} catch {
+					artifactContent = undefined; // unreadable artifact — do not fail on read errors
+				}
 			}
-			if (artifactContent !== undefined) {
-				const trimmedArtifact = artifactContent.trim();
+			if (artifactContent !== undefined || degradedResultSource) {
+				const trimmedArtifact = (artifactContent ?? "").trim();
 				const emptyArtifact = trimmedArtifact === "" || trimmedArtifact === "(no output)";
-				const stderrOnlyArtifact = !emptyArtifact && isStderrOnlyResult(artifactContent);
-				if (emptyArtifact || stderrOnlyArtifact) {
+				const stderrOnlyArtifact = !emptyArtifact && isStderrOnlyResult(artifactContent ?? "");
+				if (degradedResultSource || emptyArtifact || stderrOnlyArtifact) {
 					error = "Result artifact is empty or stderr-only (failureCause: empty-or-stderr-only-result)";
 					exitCode = exitCode === 0 ? 1 : exitCode;
 					if (modelAttempts?.length) {
@@ -359,7 +385,11 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 						structurePreserved: false,
 						issues: [
 							`empty-or-stderr-only-result: ${
-								emptyArtifact ? "result artifact is empty" : "result artifact contains only stderr/session-log noise"
+								degradedResultSource && !emptyArtifact && !stderrOnlyArtifact
+									? `result artifact was sourced from the ${resultSource} fallback (no authoritative worker output)`
+									: emptyArtifact
+										? "result artifact is empty"
+										: "result artifact contains only stderr/session-log noise"
 							}`,
 						],
 					};
@@ -373,7 +403,8 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 							structurePreserved: false,
 							issues: outputValidation.issues,
 							failureCause: "empty-or-stderr-only-result",
-							resultPath: resultArtifact.path,
+							...(resultSource ? { resultSource } : {}),
+							resultPath: resultArtifact?.path,
 						},
 					});
 				}
@@ -593,6 +624,7 @@ export async function finalizeTaskResult(ctx: TaskExecutionContext, execResult:
 		artifacts: [
 			...manifest.artifacts,
 			promptArtifact,
+			...(breakdownArtifact ? [breakdownArtifact] : []),
 			...(resultArtifact ? [resultArtifact] : []),
 			inputsArtifact,
 			coordinationArtifact,