pi-crew 0.9.26 → 0.9.27

package/src/extension/crew-vibes/speed.ts

@@ -0,0 +1,286 @@
+import type { SpeedConfig } from "./config.ts";
+
+/**
+ * Token-speed engine ported from pi-speeed (MIT, attribution in NOTICE.md).
+ * Tracks output tok/s with a sliding window and suppresses unreliable
+ * burst-only readings. No stats/font handling — just the live + session avg.
+ */
+
+export type TokenEvent = { time: number; tokens: number };
+
+const COMPACTION_THRESHOLD = 5000;
+
+export type EngineConfig = Pick<SpeedConfig, "slidingWindowMs" | "minReliableDurationMs" | "maxDisplayTokS">;
+
+export function estimateTokensFromDelta(text: string): number {
+	if (!text) return 0;
+	const matches = text.match(/\w+|[^\s\w]/g);
+	return matches ? matches.length : 0;
+}
+
+export class TokenSpeedEngine {
+	private _isStreaming = false;
+	private _tokenCount = 0;
+	private _startTime = 0;
+	private _endTime = 0;
+	private _events: TokenEvent[] = [];
+	private _windowStartIndex = 0;
+	private _lastStableTokS = 0;
+	private _lastUsageOutput = 0;
+	private _config: EngineConfig;
+
+	constructor(config: EngineConfig) {
+		this._config = config;
+	}
+
+	updateConfig(config: EngineConfig): void {
+		this._config = config;
+	}
+
+	get isStreaming(): boolean {
+		return this._isStreaming;
+	}
+
+	get tokenCount(): number {
+		return this._tokenCount;
+	}
+
+	get elapsedMs(): number {
+		if (this._startTime === 0) return 0;
+		return this._isStreaming ? Date.now() - this._startTime : this._endTime - this._startTime;
+	}
+
+	get avgTokS(): number {
+		const elapsedSec = this.elapsedMs / 1000;
+		if (elapsedSec <= 0) return 0;
+		return this._tokenCount / elapsedSec;
+	}
+
+	sanitizeTokS(value: number | null, durationMs = this.elapsedMs): number | null {
+		if (value === null || !Number.isFinite(value) || value <= 0) return null;
+		if (durationMs < this._config.minReliableDurationMs) return null;
+		if (value > this._config.maxDisplayTokS) return null;
+		return value;
+	}
+
+	get tokS(): number {
+		const candidate = this.rawTokS;
+		const stable = this.sanitizeTokS(candidate);
+		if (stable !== null) this._lastStableTokS = stable;
+		return this._lastStableTokS;
+	}
+
+	get rawTokS(): number {
+		if (this.elapsedMs < this._config.slidingWindowMs) return this.avgTokS;
+		if (!this._isStreaming) return this.avgTokS;
+
+		const now = Date.now();
+		const windowStart = now - this._config.slidingWindowMs;
+
+		while (this._windowStartIndex < this._events.length && this._events[this._windowStartIndex].time < windowStart) {
+			this._windowStartIndex++;
+		}
+
+		if (this._windowStartIndex >= this._events.length) return this.avgTokS;
+
+		let windowTokenCount = 0;
+		for (let i = this._windowStartIndex; i < this._events.length; i++) {
+			windowTokenCount += this._events[i].tokens;
+		}
+		if (windowTokenCount === 0) return this.avgTokS;
+
+		const windowDuration = (now - this._events[this._windowStartIndex].time) / 1000;
+		if (windowDuration <= 0) return 0;
+
+		return windowTokenCount / windowDuration;
+	}
+
+	start(): void {
+		this._tokenCount = 0;
+		this._isStreaming = true;
+		this._startTime = Date.now();
+		this._endTime = this._startTime;
+		this._events = [];
+		this._windowStartIndex = 0;
+		this._lastStableTokS = 0;
+		this._lastUsageOutput = 0;
+	}
+
+	stop(): void {
+		this._isStreaming = false;
+		this._endTime = Date.now();
+		this._events = [];
+		this._windowStartIndex = 0;
+	}
+
+	recordDelta(delta: string, usageOutput?: number): void {
+		if (!this._isStreaming) return;
+		if (usageOutput !== undefined && usageOutput > 0) {
+			// usageOutput may be cumulative across message_update events. Track the
+			// delta to avoid inflating _tokenCount by N× the true total.
+			const increment = usageOutput - this._lastUsageOutput;
+			this._lastUsageOutput = usageOutput;
+			this.recordTokens(Math.max(0, increment));
+			return;
+		}
+		this.recordTokens(estimateTokensFromDelta(delta));
+	}
+
+	reconcileTotal(tokens: number): void {
+		if (tokens > 0) this._tokenCount = tokens;
+	}
+
+	recordTokens(tokens: number): void {
+		if (!this._isStreaming || tokens <= 0) return;
+		this._tokenCount += tokens;
+		this._events.push({ time: Date.now(), tokens });
+		if (this._windowStartIndex >= COMPACTION_THRESHOLD) this.compact();
+	}
+
+	private compact(): void {
+		if (this._windowStartIndex === 0) return;
+		this._events = this._events.slice(this._windowStartIndex);
+		this._windowStartIndex = 0;
+	}
+}
+
+export type CompletedMessageSpeed = {
+	outputTokens: number;
+	durationMs: number;
+	tokS: number | null;
+};
+
+function isSuccessfulStop(stopReason: string | undefined): boolean {
+	return stopReason !== "error" && stopReason !== "aborted";
+}
+
+export class SpeedTracker {
+	private readonly engine: TokenSpeedEngine;
+	private lastStableTokS: number | null = null;
+	private sessionOutputTokens = 0;
+	private sessionDurationMs = 0;
+
+	constructor(config: SpeedConfig) {
+		this.engine = new TokenSpeedEngine(config);
+	}
+
+	updateConfig(config: SpeedConfig): void {
+		this.engine.updateConfig(config);
+	}
+
+	get isStreaming(): boolean {
+		return this.engine.isStreaming;
+	}
+
+	get lastTokS(): number | null {
+		return this.lastStableTokS;
+	}
+
+	resetSession(): void {
+		this.sessionOutputTokens = 0;
+		this.sessionDurationMs = 0;
+	}
+
+	startMessage(): void {
+		this.engine.start();
+	}
+
+	recordDelta(delta: string, usageOutput?: number): void {
+		this.engine.recordDelta(delta, usageOutput);
+	}
+
+	stopMessage(): void {
+		if (this.engine.isStreaming) this.engine.stop();
+	}
+
+	liveTokS(): number | null {
+		const speed = this.engine.tokS;
+		return speed > 0 ? speed : this.lastStableTokS;
+	}
+
+	sessionAvgTokS(): number | null {
+		return this.sessionDurationMs > 0 ? this.sessionOutputTokens / (this.sessionDurationMs / 1000) : null;
+	}
+
+	finishMessage(outputTokens: number, stopReason: string | undefined): CompletedMessageSpeed | null {
+		if (!this.engine.isStreaming) return null;
+
+		this.engine.reconcileTotal(outputTokens);
+		const durationMs = this.engine.elapsedMs;
+		const tokens = this.engine.tokenCount;
+		const rawAvgTokS = durationMs > 0 ? tokens / (durationMs / 1000) : null;
+		const tokS = this.engine.sanitizeTokS(rawAvgTokS, durationMs);
+		this.lastStableTokS = tokS;
+		this.engine.stop();
+
+		if (tokS !== null && isSuccessfulStop(stopReason)) {
+			this.sessionOutputTokens += tokens;
+			this.sessionDurationMs += durationMs;
+		}
+
+		return { outputTokens: tokens, durationMs, tokS };
+	}
+}
+
+export class SpeedAnimator {
+	private from: number | null = null;
+	private target: number | null = null;
+	private startedAt = 0;
+	private durationMs: number;
+
+	constructor(durationMs: number) {
+		this.durationMs = durationMs;
+	}
+
+	updateDuration(durationMs: number): void {
+		this.durationMs = durationMs;
+	}
+
+	reset(value: number | null = null, now = Date.now()): void {
+		this.from = value;
+		this.target = value;
+		this.startedAt = now;
+	}
+
+	setTarget(target: number | null, now = Date.now()): number | null {
+		if (target === null) {
+			this.reset(null, now);
+			return null;
+		}
+
+		const current = this.value(now);
+		if (current === null) {
+			this.reset(target, now);
+			return target;
+		}
+
+		if (this.target !== null && Math.abs(target - this.target) < 0.05) return current;
+
+		this.from = current;
+		this.target = target;
+		this.startedAt = now;
+		return current;
+	}
+
+	value(now = Date.now()): number | null {
+		if (this.target === null) return null;
+		if (this.from === null || this.durationMs <= 0) return this.target;
+
+		const progress = Math.max(0, Math.min(1, (now - this.startedAt) / this.durationMs));
+		if (progress >= 1) {
+			this.from = this.target;
+			return this.target;
+		}
+
+		return this.from + (this.target - this.from) * progress;
+	}
+
+	isAnimating(now = Date.now()): boolean {
+		return (
+			this.target !== null &&
+			this.from !== null &&
+			Math.abs(this.target - this.from) >= 0.05 &&
+			now - this.startedAt < this.durationMs
+		);
+	}
+}

package/src/extension/knowledge-injection.ts

@@ -22,6 +22,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { logInternalError } from "../utils/internal-error.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import type { BeforeAgentStartEvent, ExtensionAPI } from "./pi-api.ts";
 
@@ -259,6 +260,13 @@ export function readKnowledge(cwd: string, query?: KnowledgeQuery): string {
 			knowledgeCache.delete(p);
 			return "";
 		}
+		// Security: reject symlinks to prevent information disclosure.
+		// An attacker could replace knowledge.md with a symlink to /etc/shadow
+		// or other sensitive files.
+		if (stat.isSymbolicLink) {
+			logInternalError("knowledge-injection.symlink", new Error(`Refusing to read symlink: ${p}`));
+			return "";
+		}
 		// P5 (Round 15): mtime+size cache. readKnowledge fires on every agent
 		// start (main session + every worker), re-reading the file each time.
 		// For a run with N workers this is N redundant readFileSync of the same
@@ -322,10 +330,11 @@ export function readKnowledge(cwd: string, query?: KnowledgeQuery): string {
 }
 
 /** Stat helper returning undefined on error (file missing, perms, etc.). */
-function tryStat(p: string): { mtimeMs: number; size: number } | undefined {
+function tryStat(p: string): { mtimeMs: number; size: number; isSymbolicLink: boolean } | undefined {
 	try {
-		const s = fs.statSync(p);
-		return { mtimeMs: s.mtimeMs, size: s.size };
+		// Use lstatSync to detect symlinks (statSync follows them).
+		const s = fs.lstatSync(p);
+		return { mtimeMs: s.mtimeMs, size: s.size, isSymbolicLink: s.isSymbolicLink() };
 	} catch {
 		return undefined;
 	}

package/src/extension/management.ts

@@ -3,21 +3,32 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig, ResourceSource, RoutingMetadata } from "../agents/agent-config.ts";
 import { serializeAgent } from "../agents/agent-serializer.ts";
-import { discoverAgents } from "../agents/discover-agents.ts";
+import { discoverAgents, invalidateAgentDiscoveryCache } from "../agents/discover-agents.ts";
 import type { PiTeamsConfig } from "../config/config.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
-import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { allTeams, discoverTeams, invalidateTeamDiscoveryCache } from "../teams/discover-teams.ts";
 import type { TeamConfig, TeamRole } from "../teams/team-config.ts";
 import { serializeTeam } from "../teams/team-serializer.ts";
 import { hasOwn, parseConfigObject, requireString, sanitizeName } from "../utils/names.ts";
 import { projectCrewRoot, userPiRoot } from "../utils/paths.ts";
-import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { allWorkflows, discoverWorkflows, invalidateWorkflowDiscoveryCache } from "../workflows/discover-workflows.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import { serializeWorkflow } from "../workflows/workflow-serializer.ts";
 import { enforceDestructiveIntent } from "./team-tool/intent-policy.ts";
 import type { TeamToolDetails } from "./team-tool-types.ts";
 import { type PiTeamsToolResult, toolResult } from "./tool-result.ts";
 
+/**
+ * Invalidate all discovery caches that may have read the on-disk resource
+ * file we are about to (or just did) write. Called once per create/update/delete
+ * to keep the 5 s TTL caches in sync without forcing a per-render full rescan.
+ */
+function invalidateResourceCaches(): void {
+	invalidateAgentDiscoveryCache();
+	invalidateTeamDiscoveryCache();
+	invalidateWorkflowDiscoveryCache();
+}
+
 interface ManagementContext {
 	cwd: string;
 	config?: PiTeamsConfig;
@@ -385,6 +396,9 @@ export function handleCreate(params: TeamToolParamsValue, ctx: ManagementContext
 			true,
 		);
 	}
+	// F17/F15: bust the discovery caches so future powerbar/scheduler reads see
+	// the new file immediately (instead of after the 5 s TTL expires).
+	invalidateResourceCaches();
 	return result(`Created ${params.resource} '${name}' at ${filePath}.`);
 }
 
@@ -507,9 +521,13 @@ export function handleUpdate(params: TeamToolParamsValue, ctx: ManagementContext
 			true,
 		);
 	}
+	// F17/F15: bust the discovery caches so the renamed/updated resource is
+	// visible immediately. updateReferencesForRename may have rewritten peer
+	// files too, so we invalidate AFTER that pass completes.
 	const updatedRefs = params.updateReferences
 		? updateReferencesForRename(ctx, params.resource!, current.name, nextName, source, false)
 		: [];
+	invalidateResourceCaches();
 	return result(
 		[
 			`Updated ${params.resource} at ${nextPath}. Backup: ${backupPath}.`,
@@ -546,5 +564,7 @@ export function handleDelete(params: TeamToolParamsValue, ctx: ManagementContext
 			true,
 		);
 	}
+	// F17/F15: bust the discovery caches so the deletion is visible immediately.
+	invalidateResourceCaches();
 	return result(`Deleted ${params.resource} at ${resolved.resource!.filePath}. Backup: ${backupPath}.`);
 }

package/src/extension/register.ts

@@ -64,6 +64,7 @@ import { registerCrewAutocomplete } from "./crew-autocomplete.ts";
 import { registerCleanupHandler } from "./crew-cleanup.ts";
 import { registerCrewInputRouter } from "./crew-input-router.ts";
 import { registerCrewShortcuts } from "./crew-shortcuts.ts";
+import { registerCrewVibes } from "./crew-vibes/index.ts";
 import { type PiCrewRpcHandle, registerPiCrewRpc } from "./cross-extension-rpc.ts";
 import { registerKnowledgeInjection } from "./knowledge-injection.ts";
 import { registerCrewMessageRenderers } from "./message-renderers.ts";
@@ -1545,4 +1546,10 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	registerContextStatusInjection(pi, {
 		enabled: loadConfig(process.cwd()).config.reliability?.ambientStatusInjection !== false,
 	});
+
+	try {
+		registerCrewVibes(pi);
+	} catch (err) {
+		console.warn("[pi-crew] crew-vibes initialization failed:", err instanceof Error ? err.message : err);
+	}
 }

package/src/runtime/child-pi.ts

@@ -31,6 +31,18 @@ const MAX_COMPACT_CONTENT_CHARS = DEFAULT_CHILD_PI.maxCompactContentChars;
 const activeChildProcesses = new Map<number, ChildProcess>();
 const childHardKillTimers = new Map<number, NodeJS.Timeout>();
 
+// Periodic cleanup of dead child process entries to prevent memory leaks.
+// If a child process never emits exit/close (zombie), the entry would leak.
+setInterval(() => {
+	for (const [pid, child] of activeChildProcesses) {
+		try {
+			process.kill(pid, 0); // Throws ESRCH if dead
+		} catch {
+			activeChildProcesses.delete(pid);
+		}
+	}
+}, 60_000).unref();
+
 /**
  * SEC-1: Extract a redacted stderr/stdout excerpt for embedding in lifecycle
  * events and error messages. The in-memory stdout/stderr accumulators receive
@@ -176,6 +188,10 @@ export interface ChildPiLifecycleEvent {
 	stderrExcerpt?: string;
 	/** Timestamp (ISO). */
 	ts: string;
+	/** F12: optional cause for `final_drain` events. `"stdout-quiet"` indicates
+	 *  the drain was triggered by the quiet-window early-exit rather than the
+	 *  default 5 s ceiling. Other drain reasons (default) leave this undefined. */
+	reason?: "stdout-quiet";
 	/** Phase-0 diagnostic (HB-003a): the signal that killed the child (when
 	 *  available). Was previously discarded after building the error string. */
 	signal?: string;
@@ -205,6 +221,9 @@ export interface ChildPiRunInput {
 	onLifecycleEvent?: (event: ChildPiLifecycleEvent) => void;
 	maxDepth?: number;
 	finalDrainMs?: number;
+	/** F12: early-exit the drain when stdout has been silent for this many ms
+	 *  after the final assistant event. Set to ≥ finalDrainMs to disable. */
+	finalDrainQuietMs?: number;
 	hardKillMs?: number;
 	responseTimeoutMs?: number;
 	/** Soft limit on assistant turns — inject steer at this count. */
@@ -569,17 +588,22 @@ function compactChildPiLine(line: string): {
 export class ChildPiLineObserver {
 	private buffer = "";
 	private readonly input: ChildPiRunInput;
-	/** RAW (uncapped) assistant-text fragments, accumulated in arrival order.
-	 *  Mirrors {@link parsePiJsonOutput}'s textEvents/finalText extraction but
-	 *  operates on the RAW event stream instead of the 16K-compacted transcript.
-	 *  This is the source of the AUTHORITATIVE result.txt; the transcript stays
-	 *  compacted (memory bound). */
+	/** F9: bounded ring buffer for RAW assistant-text fragments. Consumers
+	 * (getRawFinalText) only read the last element, but the legacy implementation
+	 * accumulated every fragment unconditionally, which let a verbose/long-running
+	 * worker grow this array linearly with output. We retain the last 2 entries:
+	 * the consumer needs the last; we keep the second-to-last only as a defensive
+	 * fence against a race where a final event arrives just after the consumer
+	 * read (the previous "last" is still the most-recent pre-final text in that
+	 * window). 2 is well below any plausible consumer's "tail-only" need while
+	 * bounding memory. */
+	private static readonly MAX_RAW_TEXT_EVENTS = 2;
 	private readonly rawTextEvents: string[] = [];
-	/** #7 hardening: bounded digest of intermediate findings. When a worker spends
-	 *  its entire budget on tool calls (never emits a final assistant text),
-	 *  getRawFinalText() returns undefined but this digest captures the last
-	 *  display lines (tool results, stdout fragments) before budget exhaustion.
-	 *  Capped at MAX_INTERMEDIATE_DIGEST_LINES so result artifacts stay bounded. */
+	/** F9: bounded ring buffer for intermediate findings. The downstream digest
+	 * (getIntermediateFindings) slices the last 20, but the array previously grew
+	 * to 1000s of entries. We keep MAX_INTERMEDIATE_DIGEST_LINES + headroom so
+	 * the public API behaviour is preserved (still returns "last 20 lines"). */
+	private static readonly MAX_INTERMEDIATE_FINDINGS = 32;
 	private readonly intermediateFindings: string[] = [];
 
 	constructor(input: ChildPiRunInput) {
@@ -633,12 +657,19 @@ export class ChildPiLineObserver {
 			const rawParsed = JSON.parse(line);
 			const rawTexts = extractText(rawParsed);
 			if (rawTexts.length > 0) {
+				// F9: trim from the front if the push would exceed the cap. Slice's
+				// second arg excludes the index, so this drops the oldest entries
+				// while keeping the freshly pushed tail.
 				this.rawTextEvents.push(...rawTexts);
+				const rawOverflow = this.rawTextEvents.length - ChildPiLineObserver.MAX_RAW_TEXT_EVENTS;
+				if (rawOverflow > 0) this.rawTextEvents.splice(0, rawOverflow);
 				// Also capture raw assistant text as intermediate findings — the last raw
 				// text may be a partial answer before the worker ran out of budget.
 				const last = rawTexts[rawTexts.length - 1];
 				if (last.trim().length > 0) {
 					this.intermediateFindings.push(last.trim());
+					const findingsOverflow = this.intermediateFindings.length - ChildPiLineObserver.MAX_INTERMEDIATE_FINDINGS;
+					if (findingsOverflow > 0) this.intermediateFindings.splice(0, findingsOverflow);
 				}
 			}
 		} catch {
@@ -663,6 +694,8 @@ export class ChildPiLineObserver {
 			// findings. This ensures we capture tool output even when no assistant text
 			// is emitted (budget exhausted on tool calls).
 			this.intermediateFindings.push(compact.displayLine!.trim());
+			const findingsOverflow = this.intermediateFindings.length - ChildPiLineObserver.MAX_INTERMEDIATE_FINDINGS;
+			if (findingsOverflow > 0) this.intermediateFindings.splice(0, findingsOverflow);
 		}
 	}
 }
@@ -921,6 +954,10 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			// handler know a drain timer existed even after clearFinalDrainTimers() ran;
 			// spawnMonotonicMs gives us relative timing to distinguish a race from a crash.
 			let finalDrainArmed = false;
+			// F12: monotonic timestamp of the last stdout JSON event (any event —
+			// we want to know when stdout *stopped*, not when the final assistant
+			// event arrived). Updated on every onJsonEvent dispatch.
+			let lastStdoutActivityMonotonicMs = performance.now();
 			let finalDrainFiredMonotonicMs: number | undefined;
 			const spawnMonotonicMs = performance.now();
 			let finalAssistantEventMonotonicMs: number | undefined;
@@ -1141,10 +1178,80 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 						completeOperation(eventOpId);
 						throw err;
 					}
+					// F12: capture monotonic timestamp BEFORE dispatching — any stdout
+					// JSON event counts as activity. This lets the quiet-window
+					// detection measure "time since last byte of stdout" accurately
+					// regardless of what onJsonEvent does.
+					lastStdoutActivityMonotonicMs = performance.now();
 					input.onJsonEvent?.(event);
 					if (!isFinalAssistantEvent(event) || childExited || settled || finalDrainTimer) return;
 					finalAssistantEventMonotonicMs = performance.now();
 					finalDrainArmed = true; // Phase-0 diagnostic: track that a drain timer was created.
+					// F12: alongside the 5 s ceiling timer, start a polling watcher
+					// that fires the drain early if stdout goes quiet for `quietMs`
+					// after the final assistant event. Heavy children that emit a
+					// stopReason=stop message_end and then sit idle will exit in
+					// ~quietMs (default 800 ms) instead of up to up to 5 s. unref() so
+					// the poller never holds the event loop on shutdown.
+					// NOTE: The polling watcher is NOT explicitly cleared on process exit.
+					// This is safe because: (1) it's unref()'d, so it won't prevent exit;
+					// (2) the `settled || childExited` guard at the top prevents firing
+					// after the child has exited; (3) sending SIGTERM to an already-
+					// exiting process is harmless. The `finalDrainQuietMs` config allows
+					// disabling this behavior (set >= finalDrainMs, e.g., 10000).
+					const quietMs = input.finalDrainQuietMs ?? DEFAULT_CHILD_PI.finalDrainQuietMs;
+					if (quietMs < (input.finalDrainMs ?? DEFAULT_CHILD_PI.finalDrainMs)) {
+						const pollHandle = setInterval(() => {
+							if (settled || childExited) {
+								clearInterval(pollHandle);
+								pollHandle.unref();
+								return;
+							}
+							const sinceLast = performance.now() - lastStdoutActivityMonotonicMs;
+							if (sinceLast >= quietMs) {
+								clearInterval(pollHandle);
+								pollHandle.unref();
+								// Trigger the same drain path as the 5 s timer:
+								// mark forced, fire final_drain lifecycle, SIGTERM.
+								forcedFinalDrain = true;
+								finalDrainFiredMonotonicMs = performance.now();
+								input.onLifecycleEvent?.({
+									type: "final_drain",
+									pid: child.pid,
+									ts: new Date().toISOString(),
+									reason: "stdout-quiet",
+								});
+								try {
+									child.kill(process.platform === "win32" ? undefined : "SIGTERM");
+								} catch (error) {
+									logInternalError("child-pi.quiet-drain-term", error, `pid=${child.pid}`);
+								}
+								// Mark for hard kill fallback so the existing timer is
+								// still reaped if it ever fires later.
+								hardKillTimer = setTimeout(() => {
+									if (settled || childExited) return;
+									try {
+										hardKilled = true;
+										input.onLifecycleEvent?.({
+											type: "hard_kill",
+											pid: child.pid,
+											ts: new Date().toISOString(),
+										});
+										child.kill(process.platform === "win32" ? undefined : "SIGKILL");
+									} catch (error) {
+										logInternalError("child-pi.quiet-drain-hard-kill", error, `pid=${child.pid}`);
+									}
+								}, hardKillMs);
+								hardKillTimer.unref();
+								// Cancel the 5 s ceiling so we don't double-fire.
+								if (finalDrainTimer) {
+									clearTimeout(finalDrainTimer);
+									finalDrainTimer = undefined;
+								}
+							}
+						}, 200);
+						pollHandle.unref();
+					}
 					finalDrainTimer = setTimeout(() => {
 						if (settled || childExited) return;
 						forcedFinalDrain = true;

package/src/runtime/crew-agent-records.ts

@@ -338,7 +338,9 @@ export function upsertCrewAgent(manifest: TeamRunManifest, record: CrewAgentReco
 
 export function writeCrewAgentStatus(manifest: TeamRunManifest, record: CrewAgentRecord): void {
 	ensureAgentStateDir(manifest, record.taskId);
-	atomicWriteJson(agentStatusPath(manifest, record.taskId), redactSecrets(record));
+	// F4: terminal agent status (completed/failed/cancelled/blocked) — keep full
+	// durability so the notifier/dashboard health sees the final state immediately.
+	atomicWriteJson(agentStatusPath(manifest, record.taskId), redactSecrets(record), { durability: "full" });
 }
 
 // 2.5 — coalesced variants. Buffer per-agent record + aggregate writes for
@@ -350,14 +352,19 @@ const AGENT_COALESCE_MS = 250;
 export function saveCrewAgentsCoalesced(manifest: TeamRunManifest, records: CrewAgentRecord[]): void {
 	const filePath = agentsPath(manifest);
 	fs.mkdirSync(manifest.stateRoot, { recursive: true });
-	atomicWriteJsonCoalesced(filePath, redactSecrets(records), AGENT_COALESCE_MS);
+	// F4: progress write — best-effort is safe because the terminal
+	// writeCrewAgentStatus above remains durable and the notifier watches the
+	// events.jsonl independently of these JSON files.
+	atomicWriteJsonCoalesced(filePath, redactSecrets(records), AGENT_COALESCE_MS, { durability: "best-effort" });
 	asyncAgentReaderCache.delete(filePath);
 	for (const record of records) writeCrewAgentStatusCoalesced(manifest, record);
 }
 
 export function writeCrewAgentStatusCoalesced(manifest: TeamRunManifest, record: CrewAgentRecord): void {
 	ensureAgentStateDir(manifest, record.taskId);
-	atomicWriteJsonCoalesced(agentStatusPath(manifest, record.taskId), redactSecrets(record), AGENT_COALESCE_MS);
+	atomicWriteJsonCoalesced(agentStatusPath(manifest, record.taskId), redactSecrets(record), AGENT_COALESCE_MS, {
+		durability: "best-effort",
+	});
 }
 
 /** @internal Flush all coalesced agent writes synchronously. Hook into cleanup paths. */

package/src/runtime/retry-executor.ts

@@ -33,7 +33,10 @@ function asError(error: unknown): Error {
 }
 
 function globToRegex(pattern: string): RegExp {
-	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	const escaped = pattern
+		.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+		.replace(/\*/g, ".*")
+		.replace(/\?/g, ".");
 	return new RegExp(`^${escaped}$`, "i");
 }