pi-crew 0.9.64 → 0.9.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.9.64",
+  "version": "0.9.66",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",
@@ -67,11 +67,12 @@
   ],
   "scripts": {
     "check": "npm run ci",
-    "ci": "npm run typecheck && npm run lint && npm run format:check && npm run check:conflict-markers && npm run check:lazy-imports && npm run check:bundle-staleness && npm run build:bundle && npm run check:bundle-size && npm run test:bundle && npm test && npm pack --dry-run",
+    "ci": "npm run typecheck && npm run lint && npm run format:check && npm run check:conflict-markers && npm run check:decision-drift && npm run check:lazy-imports && npm run check:bundle-staleness && npm run build:bundle && npm run check:bundle-size && npm run test:bundle && npm test && npm pack --dry-run",
     "check:lazy-imports": "node scripts/check-lazy-imports.mjs",
     "check:bundle-staleness": "node scripts/check-bundle-staleness.mjs",
     "check:bundle-size": "node scripts/check-bundle-size.mjs",
     "check:conflict-markers": "node scripts/check-conflict-markers.mjs",
+    "check:decision-drift": "node scripts/check-decision-drift.mjs",
     "typecheck": "tsc --noEmit && node --experimental-strip-types -e \"await import('./index.ts'); console.log('strip-types import ok')\"",
     "lint": "biome check --linter-enabled=true --formatter-enabled=false --max-diagnostics=50 .",
     "format:check": "biome format .",

package/scripts/pty_probe.py

@@ -1,20 +1,22 @@
 #!/usr/bin/env python3
-"""pty_probe.py — bulk-key + diag probe for pi-crew TUI components.
+"""pty_probe.py — bulk-key probe for pi-crew TUI components.
 
 Spawns a real `pi` session under a pty, sends a sequence of keys with
 short sleeps, captures the resulting output. Useful for verifying that
 keystrokes reached the component's handleInput after a ui/ change.
 
+NOTE (2026-08-10): the per-keystroke diag env var (PI_CREW_BROKER_DIAG_UI)
+was REMOVED in e3ee6fe2 (PR-B5/UI-8 — "remove TEMP DIAGNOSTIC from
+run-dashboard"). There is no replacement in src/. Keystroke arrival is now
+proven by SCREEN-CHANGE evidence: capture the output frames before/after
+each key and diff them — a key that changes screen state reached the TUI.
+
 Requires Python 3.x on PATH. Unix only (Linux + macOS) — uses POSIX `pty.fork`.
 Does NOT work on native Windows (no `pty` module); use WSL or Tier 5 (tmux) instead.
 
 Usage:
     python3 scripts/pty_probe.py [--keys j,k,q] [--cwd /path/to/repo]
 
-Env:
-    PI_CREW_BROKER_DIAG_UI=1   enable diag stderr writes from run-dashboard
-                              (only component wired; see src/ui/run-dashboard.ts:831)
-
 Examples:
     # Default probe (vim nav + arrow keys + quit)
     python3 scripts/pty_probe.py
@@ -22,8 +24,8 @@ Examples:
     # Custom probe: only arrow keys
     python3 scripts/pty_probe.py --keys '\x1bOA,\x1bOB,\x1bOC,\x1bOD,q,q'
 
-    # Capture to a file
-    python3 scripts/pty_probe.py 2>&1 | tee /tmp/diag.log
+    # Capture to a file (diff frames for screen-change evidence)
+    python3 scripts/pty_probe.py 2>&1 | tee /tmp/pty-probe.log
 """
 import argparse
 import os
@@ -99,7 +101,7 @@ def main() -> int:
             pass  # use as-is if decode fails
         keys.append(k)
 
-    env = {**os.environ, "PI_CREW_BROKER_DIAG_UI": "1"}
+    env = dict(os.environ)  # keystroke diag env var removed (see module docstring)
 
     pid, fd = pty.fork()
     if pid == 0:

package/skills/real-test-pi-crew/SKILL.md

@@ -303,7 +303,7 @@ tmux capture-pane -t pi -p > /tmp/screen-after-up.txt
 import os, sys, time
 
 CMD = ['pi']
-ENV = {**os.environ, 'PI_CREW_BROKER_DIAG_UI': '1'}
+ENV = dict(os.environ)  # keystroke diag env var REMOVED (see note below)
 
 pid, fd = pty.fork()
 if pid == 0:
@@ -331,14 +331,14 @@ else:
 > ```
 > The inline code works for a quick one-off but **leaks a zombie `pi` process** on exit.
 
-**`PI_CREW_BROKER_DIAG_UI=1`** makes `run-dashboard`'s `handleInput` write a `[PI-CREW-DIAG]` line to stderr for every keystroke. (The diag is currently wired only in `run-dashboard`, not in `settings-overlay` or other overlays — if you need diag in another overlay, port the `process.env.PI_CREW_BROKER_DIAG_UI === "1"` check from `src/ui/run-dashboard.ts:831`.) Pair with `2>&1 | tee /tmp/diag.log`.
+**Keystroke diag env var REMOVED (2026-08-10)**: `PI_CREW_BROKER_DIAG_UI=1` made `run-dashboard`'s `handleInput` write a `[PI-CREW-DIAG]` line to stderr per keystroke. It was removed in `e3ee6fe2` (PR-B5: remove TEMP DIAGNOSTIC from run-dashboard, UI-8) — there is no replacement in `src/`. **To prove keystroke arrival now, rely on screen-change evidence** (Tier 5 tmux `capture-pane` before/after each key, or the pty output diff): a key that changes screen state reached the TUI; a key that does not was consumed or never arrived. Capture the probe output to a file with `2>&1 | tee /tmp/pty-probe.log` and diff the rendered frames.
 
 **References**:
 
 | What | Where |
 |---|---|
-| Diag env var | `PI_CREW_BROKER_DIAG_UI=1` — checked at `src/ui/run-dashboard.ts:831` |
-| Reduced-noise commit | `00e8ba0 chore(broker): strip diagnostic noise from focused-field fix` — diag calls left in but no longer noisy |
+| Keystroke diag env var | **REMOVED** — `e3ee6fe2` (PR-B5/UI-8). No replacement; use screen-change evidence |
+| Reduced-noise commit | `00e8ba0 chore(broker): strip diagnostic noise from focused-field fix` — diag calls left in but no longer noisy (pre-removal) |
 | Original probe | `84944f7 test(probe): add invalidate() to control object so typecheck passes` |
 
 ---
@@ -637,7 +637,7 @@ The skill mentions specific commits, line numbers, and version pins. As the code
 |---|---|---|
 | Verify line refs after each `src/` commit | Every commit touching the cited file | `git log -p -- src/extension/registration/lifecycle-handlers.ts \| grep effectiveEnabled` — if line moved, update the skill |
 | Verify commit hashes still exist | Quarterly or before major edits | `git log --oneline -1 <hash>` — if gone, find the equivalent newer commit |
-| Verify version pins (v0.9.46, etc.) | Each release | `git log --oneline -- src/ui/run-dashboard.ts \| head -5` — find when diag was wired |
+| Verify version pins (v0.9.46, etc.) | Each release | `git log --oneline -- src/ui/run-dashboard.ts \| head -5` — confirm diag removal history (e3ee6fe2) still accurate |
 | Verify `test:critical` still has 14 files | Each `src/runtime/crew-broker*.ts` edit | `cat package.json \| grep test:critical` — adjust the file list |
 | Verify Tier 7 verifier prompts still say `test:critical` | Each workflow file edit | `grep "Run FAST checks" workflows/*.workflow.md` |
 
@@ -662,7 +662,7 @@ readlink ../node_modules/pi-crew  # dev: → ../pi-crew
 readlink "$(npm root -g)"/pi-crew  # global install
 # Tier 5 (tmux probe)
 tmux -S /tmp/sock new-session -d -x 160 -y 50 -s pi \
-  "cd ${PWD} && PI_CREW_BROKER_DIAG_UI=1 exec pi 2>&1"
+  "cd ${PWD} && exec pi 2>&1"
 tmux send-keys -t pi '<key>' ; sleep 0.5
 tmux capture-pane -t pi -p
 # Tier 6 (pty probe)

package/src/config/config.ts

@@ -1249,12 +1249,20 @@ export function updateConfig(patch: PiTeamsConfig, options: UpdateConfigOptions
 			for (const unset of options.unsetPaths) unsetPath(raw, unset);
 			merged = parseConfig(raw);
 		}
+		// Skip-if-unchanged: an empty/identical patch must not rewrite the file
+		// (e.g. `team action='config'` with an empty patch — read-only path).
+		// Both sides are parseConfig-normalized, so JSON.stringify key order is
+		// deterministic (same construction path); no key sorting needed.
+		const normalizedCurrent = parseConfig(current);
+		if (JSON.stringify(merged) === JSON.stringify(normalizedCurrent)) {
+			return { path: filePath, config: merged, written: false }; // unchanged — skip write
+		}
 		fs.mkdirSync(path.dirname(filePath), { recursive: true });
 		atomicWriteFile(filePath, `${JSON.stringify(merged, null, 2)}\n`);
 		// (F16) Invalidate the loadConfig cache after a write — the next
 		// caller must see the new value, not a 0-2s stale snapshot.
 		invalidateConfigCache();
-		return { path: filePath, config: merged };
+		return { path: filePath, config: merged, written: true };
 	});
 }
 
@@ -1273,10 +1281,18 @@ export function updateAutonomousConfig(patch: PiTeamsAutonomousConfig): SavedPiT
 			current.autonomous && typeof current.autonomous === "object" && !Array.isArray(current.autonomous)
 				? (current.autonomous as Record<string, unknown>)
 				: {};
-		current.autonomous = { ...currentAutonomous, ...patch };
+		// Skip-if-unchanged (raw shape): a no-op autonomous patch must not
+		// rewrite the file. NOTE: compare the RAW on-disk record, NOT the
+		// parseConfig-normalized shape — normalizing would add default keys and
+		// false-positive the equality check.
+		const next = { ...current, autonomous: { ...currentAutonomous, ...patch } };
+		if (JSON.stringify(next) === JSON.stringify(current)) {
+			return { path: filePath, config: parseConfig(current), written: false }; // unchanged — skip write
+		}
+		current.autonomous = next.autonomous;
 		atomicWriteFile(filePath, `${JSON.stringify(current, null, 2)}\n`);
 		// (F16) Invalidate the loadConfig cache after a write — see updateConfig.
 		invalidateConfigCache();
-		return { path: filePath, config: parseConfig(current) };
+		return { path: filePath, config: parseConfig(current), written: true };
 	});
 }

package/src/config/types.ts

@@ -312,6 +312,8 @@ export interface ConfigValidationResult {
 export interface SavedPiTeamsConfig {
 	config: PiTeamsConfig;
 	path: string;
+	/** Whether the file was actually rewritten. `false` when a no-op patch hit the skip-write guard. */
+	written: boolean;
 }
 
 export interface UpdateConfigOptions {

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

@@ -21,6 +21,28 @@ import { enforceDestructiveIntent, intentFromConfig } from "./intent-policy.ts";
 import { paramRequired } from "./param-error.ts";
 import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
+/** Retryable terminal statuses (a task in one of these can be re-queued). */
+const RETRYABLE_STATUSES: ReadonlySet<string> = new Set(["failed", "cancelled"]);
+
+/**
+ * Pure pre-lock decision for `action='retry'`: a run whose manifest status is
+ * "completed" (terminal success) and has no retryable tasks has nothing to
+ * retry. Returns true so the caller short-circuits with a clear message
+ * BEFORE acquiring the run lock — avoiding a misleading
+ * "run.lock is locked by another operation" error from a stale lock file left
+ * behind by a completed async run (finding #4, real-test-2026-08-10-full-9-tier).
+ *
+ * Exported for unit testing (handleRetry itself needs filesystem state).
+ */
+export function retryShortCircuitsCompleted(
+	runStatus: string,
+	tasks: ReadonlyArray<{ id: string; status: string }>,
+	targetTaskId?: string,
+): boolean {
+	if (runStatus !== "completed") return false;
+	return !tasks.some((task) => (targetTaskId ? task.id === targetTaskId : true) && RETRYABLE_STATUSES.has(task.status));
+}
+
 export interface AbortOwnedResult {
 	abortedIds: string[];
 	missingIds: string[];
@@ -126,6 +148,18 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 
 	const targetTaskId = typeof params.taskId === "string" ? params.taskId : undefined;
 
+	// Pre-lock terminal-status check: a completed run has nothing to retry.
+	// Short-circuit BEFORE acquiring the run lock so a stale lock file left by a
+	// completed async run does not surface a misleading "run.lock is locked by
+	// another operation" error (finding #4 in real-test-2026-08-10-full-9-tier).
+	if (retryShortCircuitsCompleted(loaded.manifest.status, loaded.tasks, targetTaskId)) {
+		return result(
+			`Run ${loaded.manifest.runId} is already completed; retry only applies to failed/cancelled runs.`,
+			{ action: "retry", status: "error", runId: loaded.manifest.runId },
+			true,
+		);
+	}
+
 	return withRunLockSync(loaded.manifest, () => {
 		const retryableStatuses: ReadonlySet<string> = new Set(["failed", "cancelled"]);
 

package/src/extension/team-tool/dispatch/manage.ts

@@ -130,10 +130,13 @@ export async function handleManageDomain(params: TeamToolParamsValue, ctx: TeamC
 						unsetPaths,
 					});
 					return result(
-						["Updated pi-crew config.", `Path: ${saved.path}`, "Effective config:", JSON.stringify(saved.config, null, 2)].join(
-							"\n",
-						),
-						{ action: "config", status: "ok" },
+						[
+							saved.written ? "Updated pi-crew config." : "Config unchanged (no effective changes).",
+							`Path: ${saved.path}`,
+							"Effective config:",
+							JSON.stringify(saved.config, null, 2),
+						].join("\n"),
+						{ action: "config", status: "ok", written: saved.written },
 					);
 				} catch (error) {
 					const message = error instanceof Error ? error.message : String(error);

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

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { locateRunCwd } from "../team-tool.ts";
 import { RUN_NOT_FOUND_HINT } from "./run-not-found.ts";
 
 /**
@@ -215,7 +216,8 @@ export function handleExplain(
 		return result("explain requires runId", { action: "explain", status: "error" }, true);
 	}
 
-	const loaded = loadRunManifestById(cwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+	const runCwd = locateRunCwd(params.runId, cwd);
+	const loaded = runCwd ? loadRunManifestById(runCwd, params.runId) : undefined; // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) {
 		return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "explain", status: "error" }, true);
 	}

package/src/extension/team-tool/lifecycle-actions.ts

@@ -16,6 +16,7 @@ import { listImportedRuns } from "../import-index.ts";
 import { exportRunBundle } from "../run-export.ts";
 import { importRunBundle } from "../run-import.ts";
 import { pruneFinishedRuns } from "../run-maintenance.ts";
+import { locateRunCwd } from "../team-tool.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
 import { enforceDestructiveIntent, intentFromConfig } from "./intent-policy.ts";
@@ -29,7 +30,9 @@ export function handleWorktrees(params: TeamToolParamsValue, ctx: TeamContext):
 			{ action: "worktrees", status: "error" },
 			true,
 		);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+	const runCwd = locateRunCwd(params.runId, ctx.cwd);
+	if (!runCwd) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "worktrees", status: "error" }, true);
+	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "worktrees", status: "error" }, true);
 	const withWorktrees = loaded.tasks.filter((task) => task.worktree);
 	const lines = [

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

@@ -10,6 +10,8 @@ export interface TeamToolDetails {
 	resumedIds?: string[];
 	retriedTaskIds?: string[];
 	mailboxIds?: string[];
+	/** Whether a config write actually persisted (false on no-op/skip-write). */
+	written?: boolean;
 	/** Resource scope affected by the action (e.g. cleanup: "project"). */
 	scope?: string;
 	/** Run metrics for compact display in TUI tool result rendering. */

package/src/observability/event-to-metric.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { MetricRegistry } from "./metric-registry.ts";
+import { getCardinalityEvictions } from "./metrics-primitives.ts";
 
 function recordValue(value: unknown): Record<string, unknown> {
 	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
@@ -41,6 +42,19 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const deadletterCount = registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
 	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
 	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
+	const unboundedConcurrencyCount = registry.counter(
+		"crew.limits.unbounded_total",
+		"Runs that enabled allowUnboundedConcurrency (advisory; bypasses hard cap)",
+	);
+	// Gauge reflecting cumulative label-combination evictions across all
+	// metrics in this process. Updated lazily on every metric event so the
+	// value stays fresh without a separate timer. Non-zero = aggregation
+	// for high-cardinality labels is unreliable. See metrics-primitives.ts
+	// `enforceLabelCap`.
+	const cardinalityEvictedGauge = registry.gauge(
+		"crew.metrics.cardinality_evicted",
+		"Cumulative label-combination evictions (non-zero = unreliable aggregation)",
+	);
 	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
 	const runDuration = registry.histogram(
 		"crew.run.duration_ms",
@@ -146,11 +160,26 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 				});
 			},
 		],
+		[
+			"crew.limits.unbounded",
+			() => {
+				// Fires when a run enables allowUnboundedConcurrency (bypasses the
+				// hard cap of 8 and the worker cap). One emit per affected run.
+				unboundedConcurrencyCount.inc({});
+			},
+		],
 	];
 
 	const unsubscribers: Array<() => void> = [];
 	for (const [event, handler] of handlers) {
 		const unsubscribe = events?.on?.(event, (data: unknown) => {
+			// Refresh the cardinality-eviction gauge on every event so the
+			// value reflects the latest eviction state without a timer.
+			try {
+				cardinalityEvictedGauge.set({}, getCardinalityEvictions());
+			} catch {
+				/* gauge refresh must never break event delivery */
+			}
 			try {
 				handler(data);
 			} catch {

package/src/observability/metrics-primitives.ts

@@ -36,13 +36,51 @@ interface StoredHistogram {
 
 export const DEFAULT_HISTOGRAM_BUCKETS = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000] as const;
 
-/** Maximum number of unique label combinations per metric. */
+/**
+ * Maximum number of unique label combinations per metric.
+ *
+ * When this cap is reached, the oldest label combination is silently
+ * evicted (FIFO by insertion order, with MRU promotion on use). Read
+ * {@link getCardinalityEvictions} to detect when aggregation has become
+ * unreliable for high-cardinality labels.
+ */
 const MAX_LABEL_COMBINATIONS = 10_000;
 
-function enforceLabelCap(map: Map<string, unknown>, metricName: string): void {
+/**
+ * Cumulative count of label-combination evictions across all metrics in
+ * this process. Incremented every time {@link enforceLabelCap} drops an
+ * entry. Exported so observability wiring and OTLP/Prometheus exporters
+ * can surface `crew.metrics.cardinality_evicted` without risking the
+ * recursion of routing this signal through a `Counter` (a Counter itself
+ * consumes a label slot and could self-evict).
+ */
+let cardinalityEvictions = 0;
+
+/**
+ * Returns the cumulative number of metric label-combination evictions
+ * that have occurred in this process. A non-zero value means at least
+ * one metric exceeded {@link MAX_LABEL_COMBINATIONS} and silently dropped
+ * the oldest label combination — aggregation for high-cardinality labels
+ * is unreliable.
+ */
+export function getCardinalityEvictions(): number {
+	return cardinalityEvictions;
+}
+
+/** Reset the eviction counter. Intended for tests only. */
+export function _resetCardinalityEvictionsForTests(): void {
+	cardinalityEvictions = 0;
+}
+
+function enforceLabelCap(map: Map<string, unknown>, _metricName: string): void {
 	while (map.size > MAX_LABEL_COMBINATIONS) {
 		const firstKey = map.keys().next().value;
-		if (firstKey !== undefined) map.delete(firstKey);
+		if (firstKey !== undefined) {
+			map.delete(firstKey);
+			cardinalityEvictions++;
+		} else {
+			break;
+		}
 	}
 }
 

package/src/runtime/README.md

@@ -7,7 +7,7 @@ clusters are extracted into subdirectories; the remaining files stay at the root
 
 | Subdir | Phase | Cluster | Key files |
 |--------|-------|---------|-----------|
-| [`child-pi/`](./child-pi/) | B-1 | child Pi worker spawn/lifecycle/steering/transcript | `child-pi.ts`, `child-pi-spawn.ts`, `child-pi-kill.ts`, `child-pi-constants.ts`, `child-pi-steering.ts`, `child-pi-streams.ts`, `child-pi-transcript.ts`, `child-pi-pool.ts` |
+| [`child-pi/`](./child-pi/) | B-1 | child Pi worker spawn/lifecycle/steering/transcript | `child-pi.ts`, `child-pi-spawn.ts`, `child-pi-kill.ts`, `child-pi-constants.ts`, `child-pi-steering.ts`, `child-pi-streams.ts`, `child-pi-transcript.ts` |
 | [`broker/`](./broker/) | B-2 | crew broker server/client/auth (child-pi ↔ parent IPC) | `crew-broker.ts`, `crew-broker-client.ts`, `crew-broker-child.ts`, `crew-broker-tokens.ts`, `broker-issuer.ts` |
 | [`task-runner/`](./task-runner/) | (pre-existing) | per-task execution (pre-execution, child-executor) | `child-executor.ts`, `pre-execution.ts`, ... |
 | [`live-session/`](./live-session/) | 3 | live agent control/manager, session runtime, IRC, health, extension bridge | `live-session-runtime.ts`, `live-agent-manager.ts`, `live-agent-control.ts`, `live-control-realtime.ts`, `live-irc.ts`, `live-session-health.ts`, `live-extension-bridge.ts`, `intercom-bridge.ts` |

package/src/runtime/broker/crew-broker.ts

@@ -357,22 +357,6 @@ export class CrewBroker {
 		this.resolvedSocketPath = null;
 	}
 
-	/**
-	 * Non-throwing enqueue entry point for the post-append mailbox observer
-	 * (Phase 1) or any other in-process producer. Phase 0 accepts `notifyMessage`
-	 * as a no-op shape so the lifecycle controller can install a single
-	 * observer regardless of broker state.
-	 *
-	 * Fanout goes ONLY to authenticated connections matching the recipient.
-	 * Phase 0 keeps this as a typed no-op (`not-implemented` would be
-	 * inappropriate here — the caller is in-process and shouldn't be
-	 * punished for testing the broker skeleton).
-	 */
-	notifyMessage(_message: unknown): void {
-		// Phase 0: no fanout. Phase 1 replaces this with the single
-		// post-durable mailbox observer fanout.
-	}
-
 	// ------------------------------------------------------------------------
 	// Connection lifecycle
 	// ------------------------------------------------------------------------

package/src/runtime/effectiveness.ts

@@ -26,6 +26,24 @@ export function taskHasObservableWorkerActivity(task: TeamTaskState): boolean {
 	);
 }
 
+/**
+ * True when the task completed but its result artifact is an EMPTY file
+ * (0 bytes). Closes the F4 monitoring gap (real-test-2026-08-10 finding):
+ * a child worker absorbed by a rate-limit (429) or a model-not-found
+ * failure still emits transcript/usage events, so
+ * {@link taskHasObservableWorkerActivity} reports "activity" — but the
+ * actual result content is empty. A completed task with an empty result
+ * has done no real work and must not count toward run effectiveness.
+ *
+ * Deliberately only flags `sizeBytes === 0` (a written-but-empty file).
+ * A missing resultArtifact stays non-flagging (some tasks legitimately
+ * produce no result file), and an undefined sizeBytes stays non-flagging
+ * (legacy tasks — do not false-positive on absent metadata).
+ */
+export function taskHasEmptyResult(task: TeamTaskState): boolean {
+	return Boolean(task.resultArtifact && task.resultArtifact.sizeBytes === 0);
+}
+
 export function resolveEffectivenessGuardMode(
 	runtimeConfig: CrewRuntimeConfig | undefined,
 	manifest?: TeamRunManifest,
@@ -43,7 +61,11 @@ export function evaluateRunEffectiveness(input: {
 	runtimeConfig?: CrewRuntimeConfig;
 }): RunEffectivenessSummary {
 	const completedTasks = input.tasks.filter((task) => task.status === "completed");
-	const noObservedWorkTasks = completedTasks.filter((task) => !taskHasObservableWorkerActivity(task));
+	// F4: a completed task with an EMPTY result artifact (0 bytes) is
+	// treated exactly like no-observed-work — the worker may have spun up
+	// and streamed transcript events, but it produced no real output
+	// (e.g. a 429 rate-limit absorbed by the fallback chain).
+	const noObservedWorkTasks = completedTasks.filter((task) => !taskHasObservableWorkerActivity(task) || taskHasEmptyResult(task));
 	const needsAttentionTasks = input.tasks.filter((task) => task.agentProgress?.activityState === "needs_attention");
 	const workerExecution: WorkerExecutionState = input.executeWorkers ? "enabled" : "disabled/scaffold";
 	const guardMode = resolveEffectivenessGuardMode(input.runtimeConfig, input.manifest);