pi-crew 0.11.26 → 0.11.28

package/package.json

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

package/src/extension/team-tool/chain-executor.ts

@@ -235,7 +235,14 @@ export class ChainTeamRunExecutor implements ChainTaskRunner {
 		// 1. Format chain history into the goal — this is how context reaches the worker.
 		//    Mirrors the parentContext pattern in child-pi.ts (parent context + task delimiter).
 		const historyPrefix = formatChainHistory(context);
-		const enrichedGoal = historyPrefix ? `${historyPrefix}\n\n---\n# Current Chain Step\n${packet.goal}` : packet.goal;
+		// v0.11.27 (R14-C1 tail): `--with-context` carries the previous step's FULL
+		// output as __chainPrevOutput (runner-capped); render it as its own block so
+		// the worker sees raw output, not just the size-capped handoff summary.
+		const prevOutput = typeof context.__chainPrevOutput === "string" ? context.__chainPrevOutput.trim() : "";
+		const prevOutputBlock = prevOutput ? `# Previous Step Output (--with-context)\n\n${prevOutput}` : "";
+		const headerParts = [historyPrefix, prevOutputBlock].filter((part) => part.length > 0);
+		const enrichedGoal =
+			headerParts.length > 0 ? `${headerParts.join("\n\n---\n")}\n\n---\n# Current Chain Step\n${packet.goal}` : packet.goal;
 
 		// 2. Resolve team/workflow/model: step config (set by executeStep) → overrides → default.
 		//    BUG-44 (github #44): a workflow override of "chain" is a dispatcher-only marker
@@ -250,6 +257,11 @@ export class ChainTeamRunExecutor implements ChainTaskRunner {
 		// 3. Call handleRun for the heavy lifting. async:false forces each step to
 		//    complete synchronously (overrides asyncByDefault) so the chain is sequential.
 		//    NO `chain` key here — so the run.ts guard does not re-enter chain dispatch.
+		// v0.11.27 (R14-C2): forward the previously-dead `--timeout N` (s) flag.
+		// resolveRunDeadline honors params.timeoutMs (CORE-8 unified deadline:
+		// params > config.limits.maxRunMinutes > 1h default) for foreground runs.
+		const stepTimeoutMs = typeof context.__chainStepTimeoutMs === "number" ? context.__chainStepTimeoutMs : undefined;
+
 		const runParams: TeamToolParamsValue = {
 			action: "run",
 			goal: enrichedGoal,
@@ -257,6 +269,7 @@ export class ChainTeamRunExecutor implements ChainTaskRunner {
 			async: false,
 			...(stepWorkflow ? { workflow: stepWorkflow } : {}),
 			...(stepModel ? { model: stepModel } : {}),
+			...(stepTimeoutMs !== undefined && Number.isFinite(stepTimeoutMs) ? { timeoutMs: stepTimeoutMs } : {}),
 		};
 		const runRes = await this.handleRunRef(runParams, this.ctx);
 

package/src/runtime/chain-parser.ts

@@ -6,6 +6,12 @@
  *   step1:3 -> step2 --with-context -> step3
  *   parallel(a, b, parallel(c, d)) -> e
  *
+ * `:N` loop counts are CLAMPED to 1..10 (v0.11.27): N=0/absent would silently
+ * skip nothing, N>10 would queue unbounded sequential runs. Clamping (not
+ * throwing) is deliberate — a throw here makes chain-runner fall back to the
+ * simple splitter, which turns `step:99` into ONE literal step named "step:99"
+ * (the exact R14-C1 silent-corruption class this parser exists to prevent).
+ *
  * Pattern origin: pi-prompt-template-model chain-parser.ts
  */
 
@@ -193,6 +199,21 @@ class ChainParser {
 			return step;
 		}
 
+		// v0.11.27 (probe-caught): a QUOTED string is a valid step too —
+		// `"polish output":2` is the natural way to combine an inline goal with
+		// DSL modifiers. Previously only bare NAMEs were accepted here, so any
+		// quoted-goal chain with `:N`/`--with-context` threw and chain-runner
+		// silently fell back to the simple splitter — the constructs died for
+		// the MOST COMMON goal syntax. A quoted step keeps its text as `name`
+		// (executeStep uses it as the goal, mirroring the simple path's
+		// inlineGoal semantics).
+		if (this.peek("QUOTED")) {
+			const quoted = this.consume("QUOTED");
+			const quotedStep: ChainStep = { name: quoted.value };
+			this.parseModifiers(quotedStep);
+			return quotedStep;
+		}
+
 		// Normal step name
 		const name = this.consume("NAME").value;
 		const step: ChainStep = { name };
@@ -207,7 +228,9 @@ class ChainParser {
 			if (this.peek("COLON")) {
 				this.consume("COLON");
 				const num = this.consume("NUMBER");
-				step.loopCount = Number.parseInt(num.value, 10);
+				// v0.11.27: clamp 1..10 (see header). Clamp-not-throw: a throw silently
+				// degrades the whole chain to the simple parser (literal step names).
+				step.loopCount = Math.min(10, Math.max(1, Number.parseInt(num.value, 10)));
 			} else if (this.peek("FLAG", "with-context")) {
 				this.consume("FLAG");
 				step.withContext = true;

package/src/runtime/chain-runner.ts

@@ -105,6 +105,10 @@ export class ChainRunner {
 	/** Maximum size per handoff entry to prevent memory issues from large artifacts */
 	private static readonly MAX_HANDOFF_ENTRY_SIZE = 5000; // bytes per entry
 
+	/** v0.11.27: `--with-context` full-output cap (default history carries only
+	 * 5000-char summaries; this is the explicit full-output channel, bounded). */
+	private static readonly MAX_WITH_CONTEXT_OUTPUT_CHARS = 20000; // chars
+
 	private taskRunner: ChainTaskRunner;
 	private handoffManager: HandoffManager;
 
@@ -186,8 +190,16 @@ export class ChainRunner {
 		// success predicate cannot report a truncated chain as complete.
 		let brokeEarly = false;
 
-		for (let i = 0; i < spec.steps.length; i++) {
-			const step = spec.steps[i];
+		// v0.11.27 (R14-C1 tail): expand `:N` loop steps into an execution plan —
+		// one entry per ITERATION. Each iteration is its own ChainStepResult
+		// (name#k for k>1) so a failing iteration stays visible; the success
+		// predicate counts planned EXECUTIONS, so a chain that broke inside a
+		// loop cannot pass unexecuted iterations off as done (R14-C5 class).
+		const plan = this.buildExecutionPlan(spec);
+		const plannedExecutions = plan.length;
+
+		for (const entry of plan) {
+			const { step, stepIndex: i, displayName, iterations } = entry;
 			const stepStart = Date.now();
 
 			try {
@@ -198,7 +210,7 @@ export class ChainRunner {
 				const stepContext = this.enrichContextFromHandoffs(accumulatedContext, stepResults);
 
 				// Execute step
-				const result = await this.executeStep(effectiveConfig, stepContext);
+				const result = await this.executeStep(effectiveConfig, stepContext, stepResults);
 
 				// Track tokens
 				if (result.usage?.totalTokens) {
@@ -210,7 +222,7 @@ export class ChainRunner {
 
 				stepResults.push({
 					step: i + 1,
-					name: step.name,
+					name: displayName,
 					outcome: result.outcome,
 					result,
 					handoff,
@@ -243,10 +255,10 @@ export class ChainRunner {
 					await appendEventAsync(eventsPath, {
 						type: "chain.step_completed",
 						runId: "chain",
-						taskId: `step-${i + 1}`,
+						taskId: iterations > 1 ? `step-${i + 1}#${entry.iter}` : `step-${i + 1}`,
 						data: {
 							step: i + 1,
-							name: step.name,
+							name: displayName,
 							outcome: result.outcome,
 							duration: Date.now() - stepStart,
 						},
@@ -257,7 +269,7 @@ export class ChainRunner {
 
 				stepResults.push({
 					step: i + 1,
-					name: step.name,
+					name: displayName,
 					outcome: "failure",
 					duration: Date.now() - stepStart,
 					error: errMsg,
@@ -277,7 +289,7 @@ export class ChainRunner {
 		// for a chain whose remaining steps never ran. An empty spec was vacuously
 		// green for the same reason. Success now requires: at least one step, no
 		// early break, every planned step executed, and every outcome `success`.
-		const allStepsExecuted = stepResults.length === spec.steps.length;
+		const allStepsExecuted = stepResults.length === plannedExecutions;
 		const allOutcomesSuccessful = stepResults.every((s) => s.outcome === "success");
 
 		return {
@@ -393,9 +405,14 @@ export class ChainRunner {
 		// Parse step timeout
 		const timeoutStr = this.extractFlag(step, "timeout");
 		if (timeoutStr) {
-			const timeoutMs = parseInt(timeoutStr, 10);
-			if (!Number.isNaN(timeoutMs) && timeoutMs > 0 && timeoutMs <= 86400000) {
-				parsed.timeout = timeoutMs * 1000; // Convert seconds to ms
+			// v0.11.27 (R14-C2): the flag is SECONDS — the old bound compared the
+			// seconds value against 86400000 (a 1000-day ms bound) before
+			// multiplying, so `--timeout 99999999` was silently accepted. Now
+			// 1..86400 s (1 day), and the value is actually CONSUMED (chain-executor
+			// forwards it as runParams.timeoutMs).
+			const timeoutSec = parseInt(timeoutStr, 10);
+			if (!Number.isNaN(timeoutSec) && timeoutSec > 0 && timeoutSec <= 86400) {
+				parsed.timeout = timeoutSec * 1000;
 			}
 		}
 
@@ -412,7 +429,12 @@ export class ChainRunner {
 	 * DSL features: parallel(...), :loopCount, --with-context flag
 	 */
 	private hasDSLConstructs(chainString: string): boolean {
-		return /\bparallel\s*\(/.test(chainString) || /\w+:\d+\b/.test(chainString) || /--with-context/.test(chainString);
+		// v0.11.27 (probe-caught): `:\d+` no longer requires a leading \w — a
+		// QUOTED goal followed by `:2` (`"polish":2`) must route to the DSL
+		// parser too. Broadening is safe: time-like false positives
+		// ("deploy at 10:30") still throw inside the DSL parser and fall back to
+		// the simple splitter exactly as before.
+		return /\bparallel\s*\(/.test(chainString) || /:\d+\b/.test(chainString) || /--with-context/.test(chainString);
 	}
 
 	/**
@@ -613,7 +635,29 @@ export class ChainRunner {
 	/**
 	 * Execute a single step.
 	 */
-	private async executeStep(config: ChainStep, context: Record<string, unknown>): Promise<TaskResult> {
+	private async executeStep(
+		config: ChainStep,
+		context: Record<string, unknown>,
+		previousResults: ChainStepResult[],
+	): Promise<TaskResult> {
+		// v0.11.27 (R14-C1 tail): DSL `args` append to the goal — positional goal
+		// arguments (`"research" "topic X"` -> goal "research topic X").
+		const dslArgs = Array.isArray(config.context?.args) ? (config.context.args as string[]) : undefined;
+		const baseGoal = config.inlineGoal ?? config.name;
+		const goal = dslArgs && dslArgs.length > 0 ? [baseGoal, ...dslArgs].join(" ") : baseGoal;
+
+		// v0.11.27 (R14-C1 tail): DSL `--with-context` passes the PREVIOUS step's
+		// full worker output (capped) — distinct from the default __chainHistory,
+		// which carries only size-capped handoff summaries.
+		const withContext = config.context?.withContext === true;
+		let chainPrevOutput: string | undefined;
+		if (withContext) {
+			const prev = [...previousResults].reverse().find((r) => r.outcome === "success" && r.result?.outputText);
+			if (prev?.result?.outputText) {
+				chainPrevOutput = prev.result.outputText.slice(0, ChainRunner.MAX_WITH_CONTEXT_OUTPUT_CHARS);
+			}
+		}
+
 		// Pass step config (team/workflow/model) into the packet context so the
 		// concrete ChainTaskRunner can resolve which team/workflow to run. Without
 		// this, a step parsed to a @teamName reference would lose its team because
@@ -622,7 +666,7 @@ export class ChainRunner {
 		const packet: TaskPacket = {
 			taskId: `chain-${Date.now()}-${config.name}`,
 			runId: "chain",
-			goal: config.inlineGoal ?? config.name,
+			goal,
 			summarizeThreshold: 3000,
 			collapseContext: true,
 			context: {
@@ -630,12 +674,53 @@ export class ChainRunner {
 				__chainStepTeam: config.team,
 				__chainStepWorkflow: config.workflow,
 				__chainStepModel: config.model,
+				...(chainPrevOutput !== undefined ? { __chainPrevOutput: chainPrevOutput } : {}),
+				// v0.11.27 (R14-C2): wire the previously-dead `--timeout` flag into
+				// the step run's deadline (ms; consumed by chain-executor as
+				// runParams.timeoutMs -> CORE-8 resolveRunDeadline).
+				...(config.timeout !== undefined ? { __chainStepTimeoutMs: config.timeout } : {}),
 			},
 		};
 
 		return this.taskRunner.runTask(packet);
 	}
 
+	/** v0.11.27: iterations planned for a step — `:N` DSL (parser-clamped 1..10). */
+	private plannedIterations(step: ChainStep): number {
+		const n = step.context?.loopCount;
+		return typeof n === "number" && Number.isInteger(n) && n >= 1 ? Math.min(10, n) : 1;
+	}
+
+	/** v0.11.27: expand steps into per-iteration plan entries. */
+	private buildExecutionPlan(spec: ChainSpec): Array<{
+		step: ChainStep;
+		stepIndex: number;
+		iter: number;
+		iterations: number;
+		displayName: string;
+	}> {
+		const plan: Array<{
+			step: ChainStep;
+			stepIndex: number;
+			iter: number;
+			iterations: number;
+			displayName: string;
+		}> = [];
+		spec.steps.forEach((step, stepIndex) => {
+			const iterations = this.plannedIterations(step);
+			for (let iter = 1; iter <= iterations; iter++) {
+				plan.push({
+					step,
+					stepIndex,
+					iter,
+					iterations,
+					displayName: iter > 1 ? `${step.name}#${iter}` : step.name,
+				});
+			}
+		});
+		return plan;
+	}
+
 	/**
 	 * Create minimal packet for handoff generation.
 	 */

package/src/runtime/dwf-state-store.ts

@@ -49,6 +49,13 @@ export interface DwfCheckpointState {
 	 *  Uses Record (not Map) for JSON serialization safety. Optional: legacy
 	 *  checkpoints (and fresh states) omit it. */
 	completedAgentCalls?: Record<string, AgentResult>;
+	/** R14-C3 (wave 7, 2026-10-20): dispatch-time run context fingerprint. On
+	 * save the runner stamps {modelOverride, team}; on resume a mismatch with
+	 * the CURRENT dispatch context emits dwf.resume_context_mismatch — replayed
+	 * agent results were produced under a different model/team and the operator
+	 * should know (fail-open with visibility; the completed-call cache is still
+	 * intentional work-skip). Absent on legacy checkpoints → check skipped. */
+	dispatchContext?: { modelOverride?: string; team?: string };
 	updatedAt: string;
 }
 

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

@@ -210,6 +210,36 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 	const dwfStore = new DwfStore(manifest.stateRoot);
 	const resumedState = dwfStore.load();
 	if (resumedState) {
+		// R14-C3 (wave 7): fingerprint check — a resume that changes the dispatch
+		// context (modelOverride/team) still replays the completed-call cache, but
+		// that replay now carries an operator-visible mismatch warning instead of
+		// silently passing off old-model results as current-model work.
+		const savedCtx2 = resumedState.dispatchContext;
+		const norm = (v: string | undefined): string | undefined => (v && v.length > 0 ? v : undefined);
+		if (savedCtx2 && norm(savedCtx2.modelOverride) !== norm(input.modelOverride)) {
+			await appendEventAsync(eventsPath, {
+				type: "dwf.resume_context_mismatch",
+				runId: manifest.runId,
+				data: {
+					axis: "modelOverride",
+					checkpoint: savedCtx2.modelOverride ?? null,
+					current: input.modelOverride ?? null,
+				},
+				message: `resume modelOverride differs from checkpoint (was ${savedCtx2.modelOverride ?? "default"}, now ${input.modelOverride ?? "default"}) — replayed agent results were produced under the checkpoint's model`,
+			});
+		}
+		if (savedCtx2 && norm(savedCtx2.team) !== norm(input.team?.name)) {
+			await appendEventAsync(eventsPath, {
+				type: "dwf.resume_context_mismatch",
+				runId: manifest.runId,
+				data: {
+					axis: "team",
+					checkpoint: savedCtx2.team ?? null,
+					current: input.team?.name ?? null,
+				},
+				message: `resume team differs from checkpoint (was ${savedCtx2.team ?? "default"}, now ${input.team?.name ?? "default"}) — replayed agent results were produced under the checkpoint's team`,
+			});
+		}
 		await appendEventAsync(eventsPath, {
 			type: "dwf.resumed",
 			runId: manifest.runId,
@@ -228,6 +258,14 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 	const timeoutController = new AbortController();
 	const combinedSignal = AbortSignal.any([signal, timeoutController.signal]);
 
+	// R14-C3 (wave 7): dispatch-time fingerprint stamped into every checkpoint
+	// save; the resume path above compares it against the CURRENT dispatch
+	// context and emits dwf.resume_context_mismatch on drift.
+	const dispatchContext: { modelOverride?: string; team?: string } = {
+		...(input.modelOverride ? { modelOverride: input.modelOverride } : {}),
+		...(input.team?.name ? { team: input.team.name } : {}),
+	};
+
 	const ctx = makeWorkflowCtx(manifest, {
 		concurrency: input.concurrency ?? workflow.maxConcurrency ?? 4,
 		signal: combinedSignal,
@@ -241,9 +279,11 @@ export async function runDynamicWorkflow(input: RunDynamicWorkflowInput): Promis
 		resumedState,
 		// round-18 P2-3: checkpoint after each ctx.agent() call so a crash between calls
 		// leaves durable state. onCheckpoint captures the closure values at call time.
+		// R14-C3 (wave 7): dispatchContext (declared above the ctx) is stamped into
+		// every save so a later resume can compare against the current dispatch.
 		onCheckpoint: (state) => {
 			try {
-				dwfStore.save(state);
+				dwfStore.save({ ...state, dispatchContext });
 			} catch (error) {
 				logInternalError("dynamic-workflow-runner.checkpoint-save", error, `runId=${manifest.runId}`);
 			}

package/src/runtime/pi-spawn.ts

@@ -289,7 +289,15 @@ function validateExplicitBin(explicit: string): string | undefined {
 		}
 	} catch (e) {
 		if (e instanceof Error && e.message.includes("allowed prefixes")) throw e;
-		logInternalError("pi-spawn", e, "validateExplicitBin: unexpected realpathSync error", "error");
+		// R2-L-A2 (wave 7): the drop is now stated explicitly in the message — the
+		// operator sees that their explicit pin was IGNORED and which fallback ran,
+		// not just the raw realpath error.
+		logInternalError(
+			"pi-spawn",
+			e,
+			`validateExplicitBin: unexpected realpathSync error — explicit PI_TEAMS_PI_BIN='${resolved}' IGNORED, falling back to default pi resolution`,
+			"error",
+		);
 		return undefined;
 	}
 	return resolved;

package/src/runtime/scheduling/scheduler.ts

@@ -92,7 +92,12 @@ export class CrewScheduler {
 		//	update() (never add()), so a normal fire's stale nextRun cannot reach here.
 		this.reportMissedCronOccurrences(job);
 		if (job.enabled) this.arm(job);
-		this.emit?.({ type: "added", job });
+		// R14-C4 (wave 7, 2026-10-20): arm() can mutate the stored entry BEFORE the
+		// added event fires (e.g. a past `once` job flips to enabled:false,
+		// lastStatus:"error" via update()). Emitting the ORIGINAL stale object
+		// confused event-order consumers (disk converged; the event stream didn't).
+		// Emit the post-arm truth from the map instead.
+		this.emit?.({ type: "added", job: this.jobs.get(job.id) ?? job });
 	}
 
 	remove(id: string): boolean {
@@ -189,6 +194,12 @@ export class CrewScheduler {
 	private arm(job: ScheduledJob): void {
 		if (this.timers.has(job.id)) return;
 		if (job.scheduleType === "interval" && job.intervalMs) {
+			// R2-L-B10 (wave 7, documented design choice): interval jobs re-arm from
+			// FIRE time via the chained hop, but the fire() → update() → disarm/arm
+			// lifecycle only re-arms after the run COMPLETES — the effective period is
+			// intervalMs + run duration, NOT schedule-aligned wall-clock spacing.
+			// Deliberate (no overlap between occurrences of the same job); recorded
+			// here so the semantics are discoverable at the arm site.
 			// 2026-09-22 spawn-storm root cause: this branch used
 			// setInterval(fire, intervalMs). Node timers are 32-bit — a LEGAL long
 			// interval (e.g. 90d = 7,776,000,000ms > 2^31-1) overflows and Node

package/src/state/contracts.ts

@@ -234,6 +234,9 @@ export const TEAM_EVENT_TYPES = [
 	"crew.task.retry_attempt",
 	// Dynamic workflow resume
 	"dwf.resumed",
+	// R14-C3 (wave 7): resume dispatch-context drift (modelOverride/team) —
+	// replayed agent results were produced under a different context.
+	"dwf.resume_context_mismatch",
 	// Foreground interrupt
 	"foreground.interrupt_requested",
 	// Goal loop (P0/P1) additional outcomes

package/src/state/stores/artifact-store.ts

@@ -206,6 +206,16 @@ export function pruneExpiredArtifacts(descriptors: ArtifactDescriptor[], options
 		if (!lstat.isDirectory()) throw new Error(`artifacts root is not a directory`);
 		realAnchor = fs.realpathSync(options.artifactsRoot);
 	} catch (error) {
+		// W7-C2 (2026-10-20): a MISSING anchor directory means the run's whole
+		// artifacts tree is already gone (age-based cleanup, an earlier prune, or
+		// operator removal) — there is nothing under it left to delete, so this is
+		// success-shaped silence, not a failure. Fail-closed behavior is unchanged
+		// (return 0, nothing deleted). Session start walks EVERY retained manifest,
+		// so warning here printed one line per stale run per boot (battery
+		// 2026-10-19 observation #4). Other anchor failures (symlink anchor,
+		// non-directory, permissions) stay visible warns.
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") return 0;
 		logInternalError(
 			"artifact-store.prune-anchor",
 			error instanceof Error ? error : new Error(String(error)),

package/src/state/stores/state-store.ts

@@ -1243,7 +1243,18 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 	let manifest: TeamRunManifest | undefined;
 	let tasks: TeamTaskState[] | undefined;
 	while (attempts < LOAD_MANIFEST_RETRY_LIMIT) {
-		const freshStat = fs.statSync(manifestPath);
+		let freshStat: fs.Stats;
+		try {
+			freshStat = fs.statSync(manifestPath);
+		} catch (error) {
+			// R2-L-A1 (wave 7, 2026-10-20): the run dir can vanish between the
+			// caller's listing and this load (crash-recovery sweeps, artifact
+			// cleanup, operator rm). A thrown ENOENT aborted the WHOLE best-effort
+			// sweep for the session; "cannot be loaded" is undefined — the loop's
+			// own missing-file contract.
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+			throw error;
+		}
 		// PERF (2026-08-24, Task 12 realized): after saveRunTasksCoalesced the
 		// cache keeps the manifest half of the entry while zeroing only the
 		// tasks stamps, so this slow path runs solely to refresh tasks. When the
@@ -1421,7 +1432,15 @@ export async function loadRunManifestByIdAsync(
 	let tasks: TeamTaskState[] | undefined;
 	let attempts = 0;
 	while (attempts < LOAD_MANIFEST_RETRY_LIMIT) {
-		const freshStat = await fs.promises.stat(manifestPath);
+		let freshStat: fs.Stats;
+		try {
+			freshStat = await fs.promises.stat(manifestPath);
+		} catch (error) {
+			// R2-L-A1 (wave 7): async twin — ENOENT mid-sweep returns undefined
+			// instead of aborting the caller's best-effort sweep.
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+			throw error;
+		}
 		// PERF (2026-08-24, Task 12 realized): async twin of the sync reuse —
 		// after saveRunTasksCoalesced only the tasks stamps are zeroed, so when
 		// the retained manifest stamps match the fresh stat (same verification

package/src/ui/theme-adapter.ts

@@ -195,8 +195,20 @@ function startThemeSourceSubscription(theme: object, subscription: ThemeSourceSu
 		subscription.unsubscribeSource = removeListener;
 		return;
 	}
+	// R2-L-B9 (wave 7, 2026-10-20): the poll closure previously held a STRONG
+	// ref to the theme — an abandoned subscription (consumer never calls the
+	// returned unsubscribe) kept the theme + subscription + callbacks alive
+	// forever with a permanent 1s poll. Hold only a WeakRef: once the theme is
+	// collected, the next tick self-terminates the interval (≤1s later), after
+	// which the closure chain is collectable.
+	const weakTheme = new WeakRef<object>(theme);
 	subscription.pollTimer = setInterval(() => {
-		const nextSignature = themeSignature(theme);
+		const live = weakTheme.deref();
+		if (!live) {
+			clearInterval(subscription.pollTimer);
+			return;
+		}
+		const nextSignature = themeSignature(live);
 		if (nextSignature === subscription.lastSignature) return;
 		subscription.lastSignature = nextSignature;
 		emit();