pi-crew 0.9.64 → 0.9.66

package/src/runtime/merge-gate.ts

@@ -0,0 +1,202 @@
+/**
+ * Monotonic merge gate for parallel task updates.
+ *
+ * Extracted from team-runner.ts (2026-08-10, improvement-plan Tier 2
+ * "team-runner split" — self-contained portion). The merge gate protects
+ * terminal task states from being regressed by stale parallel worker
+ * snapshots: every terminal->non-terminal transition is rejected, plus a
+ * small set of bespoke policies (P2 completed integrity, P3
+ * waiting->running stale-snapshot regression) that are stricter than the
+ * lifecycle table on the parallel-merge path.
+ *
+ * Exhaustively tested in test/unit/team-runner-should-merge-table.test.ts.
+ */
+import { TEAM_TASK_STATUSES, TEAM_TERMINAL_TASK_STATUSES, type TeamTaskStatus } from "../state/contracts.ts";
+import type { TeamTaskState } from "../state/types.ts";
+import { refreshTaskGraphQueues } from "./scheduling/task-graph-scheduler.ts";
+
+export function isNonTerminalTaskStatus(status: TeamTaskState["status"]): boolean {
+	return status === "queued" || status === "running" || status === "waiting";
+}
+
+export function safeFinishedAt(task: TeamTaskState): number {
+	if (!task.finishedAt) return -Infinity;
+	const ms = new Date(task.finishedAt).getTime();
+	return Number.isNaN(ms) ? Infinity : ms;
+}
+
+/**
+ * Returns true when the current task has a malformed finishedAt (NaN/Infinity)
+ * and the updated task has a valid finite finishedAt. Malformed finishedAt
+ * should be replaced rather than persisting corruption.
+ */
+export function isMalformedFinishedAtReplacement(currentTime: number, updatedTime: number): boolean {
+	return !Number.isFinite(currentTime) && Number.isFinite(updatedTime);
+}
+
+/**
+ * RT-16: status-level gate for shouldMergeTaskUpdate. Returns the stable
+ * "from->to" key used by REJECTED_STATUS_MERGE_TRANSITIONS.
+ */
+export function statusMergeKey(from: TeamTaskStatus, to: TeamTaskStatus): string {
+	return `${from}->${to}`;
+}
+
+/**
+ * RT-16 — derived merge-gate transition table.
+ *
+ * The set of old->new status pairs that shouldMergeTaskUpdate must REJECT based
+ * solely on the status transition (before any field-level comparison). It
+ * replaces the former 13 hand-written status guards that hand-duplicated the
+ * lifecycle table. Built once from the single source-of-truth table
+ * (TEAM_TASK_STATUSES + TEAM_TERMINAL_TASK_STATUSES — the terminal half of
+ * TEAM_TASK_STATUS_TRANSITIONS) plus two merge-specific policies that are
+ * STRICTER than the lifecycle table on the parallel-merge path:
+ *
+ *  P1 Terminal preservation — every terminal->non-terminal pair is rejected.
+ *    The lifecycle table permits retries (e.g. completed->queued), but a stale
+ *    worker snapshot must never resurrect a settled task.
+ *  P2 Completed integrity — five terminal->terminal flips that touch the
+ *    "completed" success terminal are rejected: completed->failed,
+ *    completed->needs_attention, failed->completed, cancelled->completed,
+ *    needs_attention->completed. (completed may still move to
+ *    cancelled/skipped; that is intentionally allowed, so these are NOT simply
+ *    "every illegal terminal->terminal flip".)
+ *  P3 waiting->running regression — the single stale-snapshot case.
+ *
+ * The decision for every old->new pair is byte-for-byte identical to the former
+ * 7 status guards (verified exhaustively in
+ * test/unit/team-runner-should-merge-table.test.ts).
+ */
+export const REJECTED_STATUS_MERGE_TRANSITIONS: ReadonlySet<string> = (() => {
+	const rejected = new Set<string>();
+	// P1 — terminal preservation: reject every terminal->non-terminal pair.
+	for (const from of TEAM_TASK_STATUSES) {
+		if (!TEAM_TERMINAL_TASK_STATUSES.has(from)) continue;
+		for (const to of TEAM_TASK_STATUSES) {
+			if (!TEAM_TERMINAL_TASK_STATUSES.has(to)) rejected.add(statusMergeKey(from, to));
+		}
+	}
+	// P3 — waiting->running stale-snapshot regression.
+	rejected.add(statusMergeKey("waiting", "running"));
+	// P2 — completed integrity flips (bespoke terminal->terminal policy).
+	const completedIntegrityFlips: ReadonlyArray<[TeamTaskStatus, TeamTaskStatus]> = [
+		["completed", "failed"],
+		["completed", "needs_attention"],
+		["failed", "completed"],
+		["cancelled", "completed"],
+		["needs_attention", "completed"],
+	];
+	for (const [from, to] of completedIntegrityFlips) rejected.add(statusMergeKey(from, to));
+	return rejected;
+})();
+
+export function shouldMergeTaskUpdate(current: TeamTaskState, updated: TeamTaskState): boolean {
+	// RT-16: status-level gate — reject stale/dangerous transitions via the
+	// derived transition table (REJECTED_STATUS_MERGE_TRANSITIONS) instead of
+	// hand-written guards. Parallel workers receive the same input snapshot; a
+	// later result may still carry stale copies. The table encodes three
+	// merge-specific policies stricter than the lifecycle table: terminal
+	// preservation (no terminal->non-terminal resurrection), completed integrity
+	// (no flipping the "completed" success terminal to/from failed or
+	// needs_attention), and the waiting->running stale-snapshot regression.
+	if (REJECTED_STATUS_MERGE_TRANSITIONS.has(statusMergeKey(current.status, updated.status))) return false;
+	// Guard: when current is "running" but has resultArtifact (another worker already
+	// completed it), a stale updated with status="running" and no resultArtifact
+	// must not overwrite the actual completed state.
+	if (current.status === updated.status && updated.status === "running" && current.resultArtifact && !updated.resultArtifact)
+		return false;
+	// Guard: when current is "completed" and has resultArtifact but updated is also
+	// "completed" without resultArtifact, block the stale update from overwriting
+	// a task that successfully produced output.
+	if (current.status === updated.status && current.status === "completed" && current.resultArtifact && !updated.resultArtifact)
+		return false;
+	// Prevent a stale completed task from overwriting a fresher one.
+	// Restructure to handle undefined current.finishedAt as a special case:
+	// - undefined current + valid updated: allow the update
+	// - valid current + undefined updated: block the update (don't lose completion time)
+	// - both undefined: finishedAt guard does not apply, fall through to heartbeat check
+	// - both valid: compare timestamps as before
+	if (current.finishedAt !== undefined && updated.finishedAt !== undefined) {
+		const currentTime = safeFinishedAt(current);
+		const updatedTime = safeFinishedAt(updated);
+		// Malformed finishedAt (NaN) is treated as Infinity — invalid state should be
+		// replaced rather than persisting corruption. Log warning for visibility.
+		if (!Number.isFinite(currentTime)) {
+			console.warn(`[merge-gate] Task ${current.id} has malformed finishedAt: ${current.finishedAt}`);
+		}
+		if (isMalformedFinishedAtReplacement(currentTime, updatedTime)) {
+			return true;
+		}
+		if (updatedTime < currentTime) return false;
+	}
+	// Block if updated is trying to establish a terminal status without a finishedAt
+	// timestamp. Heartbeat-only updates (status='running', no finishedAt) are
+	// allowed if heartbeat has changed (checked separately in hasMeaningfulUpdate).
+	if (!updated.finishedAt && !isNonTerminalTaskStatus(updated.status)) return false;
+	// Explicitly enumerate all fields that constitute a meaningful update so that
+	// adding a new important field requires updating this list (rather than silently
+	// losing data if a field is forgotten in the boolean OR chain below).
+	const hasMeaningfulUpdate =
+		updated.status !== current.status ||
+		updated.finishedAt !== current.finishedAt ||
+		updated.startedAt !== current.startedAt ||
+		Boolean(updated.resultArtifact) !== Boolean(current.resultArtifact) ||
+		(Boolean(updated.resultArtifact) && updated.resultArtifact !== current.resultArtifact) ||
+		Boolean(updated.error) ||
+		Boolean(updated.modelAttempts?.length) ||
+		Boolean(updated.usage) ||
+		Boolean(updated.attempts?.length) ||
+		updated.heartbeat?.lastSeenAt !== current.heartbeat?.lastSeenAt ||
+		updated.jsonEvents !== current.jsonEvents ||
+		updated.agentProgress?.lastActivityAt !== current.agentProgress?.lastActivityAt;
+	return hasMeaningfulUpdate;
+}
+/** Exposed for the exhaustive status-merge table test (RT-16). */
+export const __test__shouldMergeTaskUpdate = shouldMergeTaskUpdate;
+
+// H4 fix: rename to descriptive name. Kept __test__ as alias for backward
+// compat test imports.
+// FIX (perf P10): replace O(N×M) .find() + .map() inside nested loops with a
+// single-pass Map-based merge. Build an index of `merged` once, then for each
+// incoming updated task do O(1) lookup; the final pass reassembles `merged`
+// preserving original order. For a 20-task run × 5-batch merger with
+// ~10 updates per result, this reduces from O(50×20) = 1000 ops to O(120).
+// Behavior is unchanged: skipped updates (shouldMergeTaskUpdate=false) still
+// leave the existing task in place.
+export function mergeTaskUpdatesPreservingTerminal(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
+	// Index current merged state by id for O(1) lookup during the merge pass.
+	const indexById = new Map<string, TeamTaskState>();
+	for (const task of base) indexById.set(task.id, task);
+
+	let skipped = 0;
+	for (const result of results) {
+		for (const updated of result.tasks) {
+			const current = indexById.get(updated.id);
+			if (!current) continue;
+			if (!shouldMergeTaskUpdate(current, updated)) {
+				// Log skipped merges for visibility into rejected parallel updates.
+				// In distributed systems with parallel workers, rejected merges may
+				// indicate bugs (wrong status, timestamp corruption) if they accumulate.
+				console.debug("[merge-gate] Skipping stale merge for task", updated.id, {
+					currentStatus: current.status,
+					updatedStatus: updated.status,
+					currentFinishedAt: current.finishedAt,
+					updatedFinishedAt: updated.finishedAt,
+				});
+				skipped += 1;
+				continue;
+			}
+			indexById.set(updated.id, updated);
+		}
+	}
+	// Reassemble in original `base` order so downstream snapshots stay stable.
+	const merged = base.map((task) => indexById.get(task.id) ?? task);
+	// `skipped` is intentional visibility — currently no caller reads it but
+	// we'd rather leave the count available for future instrumentation than
+	// remove the cumulative silent-rejection signal it provides.
+	void skipped;
+	return refreshTaskGraphQueues(merged);
+}
+/** @deprecated Use mergeTaskUpdatesPreservingTerminal. Kept for backward test import compat. */
+export const __test__mergeTaskUpdates = mergeTaskUpdatesPreservingTerminal;

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

@@ -365,6 +365,17 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
 	/safety/i,
 	/is[_ ]?overloaded/i,
 	/\b408\b/,
+	//
+	// EPIPE / broken-pipe. In the child-pi worker path this typically means
+	// the child `pi` process exited (crash or early exit) while the parent
+	// was still writing to its stdin — spawning a fresh child on the next
+	// model in the fallback chain usually recovers. In the network path it
+	// is a transient pipe close. Both are retryable on a different model.
+	// See docs/failure-mode-inventory.md EPIPE gap; NON_RETRYABLE patterns
+	// (auth/billing) are checked first, so an auth error mentioning EPIPE
+	// stays non-retryable.
+	/epipe/i,
+	/broken pipe/i,
 ];
 
 // These patterns indicate auth/key/billing issues that will never succeed on retry.

package/src/runtime/model/provider-extensions.ts

@@ -22,7 +22,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { userPiRoot } from "../../utils/paths.ts";
+import { packageRoot, userPiRoot } from "../../utils/paths.ts";
 
 export interface DiscoveredProviderExtension {
 	/** Package specifier as written in settings.json packages (e.g. "npm:pi-commandcode-provider"). */
@@ -95,12 +95,17 @@ function resolvePackageEntry(pkgDir: string): string | undefined {
 
 /**
  * Discover provider extension entry points from Pi's installed package registry.
- * Reads `~/.pi/agent/settings.json` → `packages` (npm: specs only — local
- * relative paths are the pi-crew extension itself and other local work, which
- * children already handle) and resolves each against `~/.pi/agent/npm/node_modules/`.
+ * Reads `~/.pi/agent/settings.json` → `packages` and resolves each spec:
+ *   - `npm:<name>`      → `~/.pi/agent/npm/node_modules/<name>/`
+ *   - local path spec   → resolved relative to the settings.json dir (the way
+ *     `pi install <local-path>` records them), e.g. "../../src/foo"
+ *   - git:/file: specs   → skipped (not resolvable on disk)
  *
- * Non-npm specs (local paths, git URLs) are skipped: they are not part of the
- * npm registry dir and resolving them is outside this module's scope.
+ * Both npm: and local-path specs are SANCTIONED channels — the user wrote them
+ * into settings.json (directly or via `pi install`), so they are trusted at the
+ * same level. This is distinct from project-sourced AGENT extensions
+ * (`.crew/agents/*.md` `extensions:` frontmatter), which are repo-adjacent
+ * untrusted data and stay gated by SEC-1 in discover-agents.ts.
  */
 export function discoverProviderExtensions(settingsPath?: string): DiscoveredProviderExtension[] {
 	const root = userPiRoot();
@@ -125,13 +130,27 @@ export function discoverProviderExtensions(settingsPath?: string): DiscoveredPro
 	const npmBase = path.join(baseDir, "npm", "node_modules");
 	for (const spec of settings.packages ?? []) {
 		if (typeof spec !== "string") continue;
-		// Only npm: specs resolve into the npm registry dir. Skip local path
-		// packages (e.g. "../../source/my_pi/pi-crew") and git specs.
-		if (!spec.startsWith("npm:")) continue;
-		const pkgName = spec.slice(4);
-		// Scoped packages: "@scope/name" → "@scope/name"; plain: "name".
-		const pkgDir = path.join(npmBase, pkgName);
+		let pkgDir: string;
+		if (spec.startsWith("npm:")) {
+			// Scoped packages: "@scope/name" → "@scope/name"; plain: "name".
+			pkgDir = path.join(npmBase, spec.slice(4));
+		} else if (spec.startsWith("./") || spec.startsWith("../") || path.isAbsolute(spec)) {
+			// Local path spec — resolve relative to the settings.json dir, matching
+			// how `pi install <local-path>` records it. Same trust level as npm:
+			// (user wrote it into settings.json). Not to be confused with project
+			// AGENT extensions (.crew/agents/* frontmatter) — those stay SEC-1 gated.
+			pkgDir = path.resolve(baseDir, spec);
+		} else {
+			// git:/file:/http: specs etc. — not resolvable on disk, skip.
+			continue;
+		}
 		if (!fs.existsSync(pkgDir)) continue;
+		// Skip self: pi-crew's own package is a settings package (the orchestrator
+		// extension the parent loads), but a child WORKER must not re-load it — it
+		// would register the team tool / observability / MCP wiring intended for
+		// the orchestrator process, not a worker. Provider + adapter extensions
+		// (pi-other-provider, pi-mcp-adapter, pi-rlm, ...) stay.
+		if (path.resolve(pkgDir) === path.resolve(packageRoot())) continue;
 		const entryPath = resolvePackageEntry(pkgDir);
 		if (entryPath) out.push({ spec, entryPath });
 	}

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

@@ -9,13 +9,41 @@
  * (headings, code blocks, URLs) after compression.
  */
 
-/** Role-specific output format patterns — constructed fresh per call to avoid /g lastIndex leak */
+/**
+ * Why relax: real worker LLMs emit markdown handoffs (`## Handoff`,
+ * `### Summary`, `## Follow-ups`, `- bullet`, `**bold**`) instead of the
+ * caveman formats (`file:line — text`, `PASS:`/`FAIL:`, emoji findings)
+ * these patterns originally required. Each role pattern below ORs its
+ * strict contract with a markdown-structured alternation so structured
+ * handoffs validate while empty/garbage output still fails.
+ *
+ * What changed: added the MARKDOWN_STRUCTURED alternation to every role.
+ * What is preserved: the strict patterns still match verbatim, and the
+ * structural-preservation checks (code blocks, URLs, headings) in
+ * validateWorkerOutput are UNCHANGED.
+ */
+
+/** Accepts atx headings (`## X`), bold (`**x**`), bullets (`- x` / `* x`), and numbered lists (`1. x`) */
+const MARKDOWN_STRUCTURED = /^(?:#{1,6}\s|\*\*|[-*]\s|\d+\.\s)/m;
+
+/** Strict per-role contract patterns (kept verbatim; `.source` is embedded in the alternations below) */
+const STRICT_ROLE_PATTERNS: Record<string, RegExp> = {
+	explorer: /^(\S+:\d+|Defs:|Refs:|Callers:|Tests:|Sites:|No match\.|totals:)/m,
+	executor: /^(\S+:\d+(-\d+)? — .{1,80}\.|verified:|too-big\.|needs-confirm\.|ambiguous\.|regressed\.)/m,
+	reviewer: /^([^:\s]+:\d+:\s+\p{Emoji_Presentation}|No issues\.|totals:)/mu,
+	"security-reviewer": /^([^:\s]+:\d+:\s+\p{Emoji_Presentation}|No issues\.|totals:)/mu,
+	verifier: /^(PASS:|FAIL:)/m,
+};
+
+/** Role-specific output format patterns — constructed fresh per call to avoid /g lastIndex leak.
+ * Each factory: strict contract OR markdown-structured alternation. */
 const ROLE_PATTERN_DEFS: Record<string, () => RegExp> = {
-	explorer: () => /^(\S+:\d+|Defs:|Refs:|Callers:|Tests:|Sites:|No match\.|totals:)/m,
-	executor: () => /^(\S+:\d+(-\d+)? — .{1,80}\.|verified:|too-big\.|needs-confirm\.|ambiguous\.|regressed\.)/m,
-	reviewer: () => /^([^:\s]+:\d+:\s+\p{Emoji_Presentation}|No issues\.|totals:)/mu,
-	"security-reviewer": () => /^([^:\s]+:\d+:\s+\p{Emoji_Presentation}|No issues\.|totals:)/mu,
-	verifier: () => /^(PASS:|FAIL:)/m,
+	explorer: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.explorer.source})|(?:${MARKDOWN_STRUCTURED.source})`, "m"),
+	executor: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.executor.source})|(?:${MARKDOWN_STRUCTURED.source})`, "m"),
+	reviewer: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.reviewer.source})|(?:${MARKDOWN_STRUCTURED.source})`, "mu"),
+	"security-reviewer": () =>
+		new RegExp(`(?:${STRICT_ROLE_PATTERNS["security-reviewer"].source})|(?:${MARKDOWN_STRUCTURED.source})`, "mu"),
+	verifier: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.verifier.source})|(?:${MARKDOWN_STRUCTURED.source})`, "m"),
 };
 
 /** Fresh RegExp factories for structural preservation checks (avoids /g lastIndex leak) */

package/src/runtime/output/progress-tracker.ts

@@ -1,5 +1,4 @@
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import { crewEventBus } from "../../observability/event-bus.ts";
 
 export interface AgentProgress {
 	toolCalls: number;
@@ -25,7 +24,7 @@ export class ProgressTracker {
 			subscribe: (listener: (event: AgentSessionEvent) => void) => () => void;
 		},
 		agentId: string,
-		runId: string,
+		_runId: string,
 	): AgentProgress {
 		if (this.sessions.has(agentId)) {
 			return this.sessions.get(agentId)!.progress;
@@ -42,26 +41,19 @@ export class ProgressTracker {
 		};
 
 		const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
-			this.handleEvent(event, progress, agentId, runId);
+			this.handleEvent(event, progress);
 		});
 
 		this.sessions.set(agentId, { unsubscribe, progress });
 		return progress;
 	}
 
-	private handleEvent(event: AgentSessionEvent, progress: AgentProgress, agentId: string, runId: string): void {
+	private handleEvent(event: AgentSessionEvent, progress: AgentProgress): void {
 		switch (event.type) {
 			case "tool_execution_start":
 				progress.toolCalls++;
 				progress.currentTool = event.toolName;
 				progress.toolStartTime = Date.now();
-				crewEventBus.emit({
-					type: "agent:progress",
-					runId,
-					agentId,
-					payload: { ...progress },
-					timestamp: Date.now(),
-				});
 				break;
 
 			case "tool_execution_end":
@@ -69,21 +61,7 @@ export class ProgressTracker {
 				progress.toolStartTime = null;
 				if (event.isError) {
 					progress.errors.push(String(event.result ?? "Unknown error"));
-					crewEventBus.emit({
-						type: "agent:error",
-						runId,
-						agentId,
-						payload: String(event.result ?? "Unknown error"),
-						timestamp: Date.now(),
-					});
 				}
-				crewEventBus.emit({
-					type: "agent:progress",
-					runId,
-					agentId,
-					payload: { ...progress },
-					timestamp: Date.now(),
-				});
 				break;
 
 			case "turn_start":
@@ -92,13 +70,6 @@ export class ProgressTracker {
 
 			case "agent_end":
 				progress.status = "completed";
-				crewEventBus.emit({
-					type: "agent:complete",
-					runId,
-					agentId,
-					payload: { ...progress },
-					timestamp: Date.now(),
-				});
 				break;
 
 			case "agent_start":
@@ -120,5 +91,4 @@ export class ProgressTracker {
 	}
 }
 
-// Export singleton instance
 export const globalProgressTracker = new ProgressTracker();

package/src/runtime/scheduling/scheduler.ts

@@ -229,24 +229,72 @@ function parseIntervalMs(s: string): number | undefined {
 	return ms;
 }
 
-function nextCronDate(spec: string, from: Date): Date | { error: string } | null {
-	const parts = spec.split(/\s+/);
-	if (parts.length < 5) return { error: "Invalid cron expression" };
-	const [minStr, hourStr, domStr, monthStr, dowStr] = parts;
+/** Named-token maps for cron DOW (SUN=0..SAT=6) and month (JAN=1..DEC=12). */
+const CRON_DOW_NAMES: Record<string, number> = { SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6 };
+const CRON_MONTH_NAMES: Record<string, number> = {
+	JAN: 1,
+	FEB: 2,
+	MAR: 3,
+	APR: 4,
+	MAY: 5,
+	JUN: 6,
+	JUL: 7,
+	AUG: 8,
+	SEP: 9,
+	OCT: 10,
+	NOV: 11,
+	DEC: 12,
+};
 
-	function matchField(value: number, str: string, min: number, max: number): boolean {
-		if (str === "*") return true;
-		const n = parseInt(str, 10);
-		if (!Number.isNaN(n) && n >= min && n <= max && n === value) return true;
-		if (/^\d+-\d+$/.test(str)) {
-			const [a, b] = str.split("-").map(Number);
-			return value >= a && value <= b;
+/**
+ * Match a single cron field value against a cron field expression.
+ * Supports the standard cron grammar: wildcard, single N, range a-b, list a,b,c,
+ * step syntax (wildcard-step, range-step, from-step), and named tokens
+ * (MON, JAN) when a `names` map is passed. Fixes the prior matcher that
+ * rejected step values and named DOW (parseInt returned NaN).
+ */
+function cronFieldMatches(value: number, field: string, min: number, max: number, names?: Record<string, number>): boolean {
+	let normalized = field.trim().toUpperCase();
+	if (names) {
+		for (const name of Object.keys(names).sort((a, b) => b.length - a.length)) {
+			normalized = normalized.split(name).join(String(names[name]));
+		}
+	}
+	// Cron permits 7 for Sunday in the DOW field — normalize to 0.
+	if (min === 0 && max === 6) normalized = normalized.replace(/\b7\b/g, "0");
+	const matched = new Set<number>();
+	for (const rawPart of normalized.split(",")) {
+		const part = rawPart.trim();
+		if (part === "") return false;
+		const stepMatch = part.match(/^(.*)\/(\d+)$/);
+		const step = stepMatch ? Number.parseInt(stepMatch[2], 10) : 1;
+		if (!Number.isFinite(step) || step < 1) return false;
+		const rangeStr = stepMatch ? stepMatch[1] : part;
+		let lo: number;
+		let hi: number;
+		if (rangeStr === "*") {
+			lo = min;
+			hi = max;
+		} else if (/^\d+$/.test(rangeStr)) {
+			lo = Number.parseInt(rangeStr, 10);
+			hi = stepMatch ? max : lo; // bare `N` = single value; `N/S` = N..max step S
+		} else {
+			const rm = rangeStr.match(/^(\d+)-(\d+)$/);
+			if (!rm) return false;
+			lo = Number.parseInt(rm[1], 10);
+			hi = Number.parseInt(rm[2], 10);
 		}
-		if (str.includes(",")) {
-			return str.split(",").some((part) => matchField(value, part.trim(), min, max));
+		for (let v = lo; v <= hi; v += step) {
+			if (v >= min && v <= max) matched.add(v);
 		}
-		return false;
 	}
+	return matched.has(value);
+}
+
+function nextCronDate(spec: string, from: Date): Date | { error: string } | null {
+	const parts = spec.split(/\s+/);
+	if (parts.length < 5) return { error: "Invalid cron expression" };
+	const [minStr, hourStr, domStr, monthStr, dowStr] = parts;
 
 	let cursor = new Date(from.getTime());
 	cursor.setSeconds(0, 0);
@@ -261,11 +309,11 @@ function nextCronDate(spec: string, from: Date): Date | { error: string } | null
 		const dow = cursor.getUTCDay();
 
 		if (
-			matchField(min, minStr, 0, 59) &&
-			matchField(hour, hourStr, 0, 23) &&
-			matchField(dom, domStr, 1, 31) &&
-			matchField(month, monthStr, 1, 12) &&
-			matchField(dow, dowStr, 0, 6)
+			cronFieldMatches(min, minStr, 0, 59) &&
+			cronFieldMatches(hour, hourStr, 0, 23) &&
+			cronFieldMatches(dom, domStr, 1, 31) &&
+			cronFieldMatches(month, monthStr, 1, 12, CRON_MONTH_NAMES) &&
+			cronFieldMatches(dow, dowStr, 0, 6, CRON_DOW_NAMES)
 		) {
 			return cursor;
 		}

package/src/runtime/scratchpad/engine.ts

@@ -17,7 +17,7 @@
  *     grace, truncateWithMarker, the childClosed race guard — is ported 1:1.
  */
 
-import { type ChildProcess, spawn } from "node:child_process";
+import { type ChildProcess, spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { closeSync, constants as fsConstants, fstatSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
@@ -198,6 +198,15 @@ export class EngineManager {
 				...(this.options.env ?? {}),
 				[NONCE_ENV]: this.nonce,
 			},
+			// Run the guest as its own session leader so descendants
+			// (cell-spawned subprocesses) share its process group. teardown
+			// then uses `process.kill(-pid, ...)` (POSIX) or `taskkill /T`
+			// (Windows) to clean up the whole tree — closing the
+			// "cell-subprocess orphan on session_shutdown" gap declared in
+			// docs/failure-mode-inventory.md (D.4 narrowed).
+			// stdio pipes are still owned by the parent; `detached` only
+			// affects process-group / kill-on-parent-exit semantics.
+			detached: true,
 			// fd 3 carries protocol traffic so stdout/stderr stay pure user output.
 			stdio: ["pipe", "pipe", "pipe", "pipe"],
 		});
@@ -303,7 +312,36 @@ export class EngineManager {
 		this.engineState = "shutdown";
 		liveEngines.delete(this);
 		this.failAllPending(new Error("Engine has been shut down"));
-		this.child?.kill("SIGKILL");
+		// Kill the whole process group / job tree so cell-spawned
+		// subprocesses (grandchildren of the host) do not orphan when the
+		// session shuts down. Best-effort: fall back to a single-pid kill
+		// if the group/tree kill fails (already dead, EPERM, etc.).
+		const child = this.child;
+		const pid = child?.pid;
+		if (pid !== undefined && pid > 0) {
+			try {
+				if (process.platform === "win32") {
+					// taskkill /T /F kills the entire process tree rooted at pid.
+					spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+				} else {
+					// Negative pid = signal the entire process group.
+					// Requires the guest to be its own session leader (detached:true above).
+					process.kill(-pid, "SIGKILL");
+				}
+			} catch {
+				try {
+					child?.kill("SIGKILL");
+				} catch {
+					/* already gone — nothing to clean up */
+				}
+			}
+		} else if (child) {
+			try {
+				child.kill("SIGKILL");
+			} catch {
+				/* already gone */
+			}
+		}
 		this.child = undefined;
 		this.protocolReader?.close();
 		this.protocolReader = undefined;