pi-crew 0.9.65 → 0.9.66

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 > **Note:** `atomic-write-v2.ts` / `AtomicWriter` mentioned in historical entries below was consolidated into `atomic-write.ts` as of v0.9.42. This changelog is preserved as historical record — the migration was completed (the v2 class was never adopted; v1 won on simplicity + symlink-safety + link+unlink atomicity). See `docs/migration/atomic-write-v2-migration.md` for the decision rationale.
 
+## [0.9.66] — real-test findings: cross-project run lookup, output validation, config no-op-write, retry clarity, cron grammar (2026-08-10)
+
+Six fixes distilled from the `real-test-pi-crew` 9-tier battery (run 2026-08-10). All verified live end-to-end; `npm run test:critical` 101/101, `npx tsc --noEmit` exit 0, biome lint+format clean.
+
+### Fixes
+- **Cross-project run lookup** (`src/extension/team-tool/explain.ts`, `lifecycle-actions.ts`): `explain` and `worktrees` now resolve runs via `locateRunCwd` (the same cross-project resolver `status`/`cancel`/`inspect` use) instead of raw `ctx.cwd`. A run created with a nested `cwd` override is now reachable from the parent session root (previously "Run not found"). Finding #1.
+- **Output validation accepts markdown** (`src/runtime/output/output-validator.ts`): `ROLE_PATTERN_DEFS` only matched the strict caveman format, so every task tripped `output_validation valid:false`. Each role pattern now also accepts markdown-structured handoffs (`## Handoff`, bullets, bold); structural-preservation checks and empty-output rejection are unchanged. Finding #2.
+- **Config skip-write guard** (`src/config/config.ts`, `types.ts`): `action='config'` with an empty patch went through the write path (`parseConfig({})` yields a full default config → `shouldUpdate=true`) and rewrote `~/.pi/agent/pi-crew.json` on every read. Added a skip-if-unchanged guard (and a `written` flag) so a no-op patch leaves the file untouched. Finding #3.
+- **Retry clarity for completed runs** (`src/extension/team-tool/cancel.ts`): `action='retry'` on a completed run acquired the run lock and surfaced a stale-lock error ("run.lock is locked by another operation"). A pre-lock terminal-status check now short-circuits to "already completed; retry only applies to failed/cancelled runs" before touching the lock. Finding #4.
+- **Cron grammar** (`src/runtime/scheduling/scheduler.ts`): `nextCronDate`'s matcher rejected standard cron step values (`*/30`, `9-17/2`) and named tokens (`MON`, `JAN`), so `action='schedule cron='0 9 * * MON'` errored with "No next cron occurrence found". Rewritten as `cronFieldMatches` handling wildcard, single, range, list, step, and named DOW/month tokens. Cosmetic finding.
+- **"Config unchanged" message** (`src/extension/team-tool-types.ts`, `dispatch/manage.ts`): the config action always said "Updated" even when the skip-write guard left the file untouched; now shows "Config unchanged (no effective changes)." when no write occurred. Cosmetic finding.
+
+### Verified
+- `npm run test:critical`: 101/101 pass (default, `PI_CREW_BROKER=0`, `PI_CREW_BROKER=1`).
+- `npx tsc --noEmit` exit 0; biome lint + format clean.
+- Bundle md5 `a32223b037f35d8605fa3013e1d8a095` (~2857 KB).
+- Full 9-tier `real-test-pi-crew` re-run (2026-08-10): all tiers green, all 6 fixes live-verified. Reports under `docs/real-test/reports/real-test-2026-08-10-full-9-tier*.md`.
+
 ## [0.9.65] — team-tool schema empty-string guard (budgetTotal) + effectiveness empty-result guard + skill drift fix (2026-08-10)
 
 ### Fixes

package/dist/index.mjs

@@ -10934,11 +10934,15 @@ function updateConfig(patch, options = {}) {
       for (const unset of options.unsetPaths) unsetPath(raw, unset);
       merged = parseConfig(raw);
     }
+    const normalizedCurrent = parseConfig(current);
+    if (JSON.stringify(merged) === JSON.stringify(normalizedCurrent)) {
+      return { path: filePath, config: merged, written: false };
+    }
     fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
     atomicWriteFile(filePath, `${JSON.stringify(merged, null, 2)}
 `);
     invalidateConfigCache();
-    return { path: filePath, config: merged };
+    return { path: filePath, config: merged, written: true };
   });
 }
 function updateAutonomousConfig(patch) {
@@ -10953,11 +10957,15 @@ function updateAutonomousConfig(patch) {
       throw new Error(`Could not update pi-crew config: ${message}`);
     }
     const currentAutonomous = current.autonomous && typeof current.autonomous === "object" && !Array.isArray(current.autonomous) ? current.autonomous : {};
-    current.autonomous = { ...currentAutonomous, ...patch };
+    const next = { ...current, autonomous: { ...currentAutonomous, ...patch } };
+    if (JSON.stringify(next) === JSON.stringify(current)) {
+      return { path: filePath, config: parseConfig(current), written: false };
+    }
+    current.autonomous = next.autonomous;
     atomicWriteFile(filePath, `${JSON.stringify(current, null, 2)}
 `);
     invalidateConfigCache();
-    return { path: filePath, config: parseConfig(current) };
+    return { path: filePath, config: parseConfig(current), written: true };
   });
 }
 var CONFIG_CACHE_TTL_MS, configCache, configCacheTtlMsOverride, KNOWN_TOP_LEVEL_KEYS, LIMIT_CEILINGS, DANGEROUS_OBJECT_KEYS;
@@ -35647,23 +35655,46 @@ function parseIntervalMs(s) {
   }
   return ms;
 }
+function cronFieldMatches(value, field, min, max, names) {
+  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]));
+    }
+  }
+  if (min === 0 && max === 6) normalized = normalized.replace(/\b7\b/g, "0");
+  const matched = /* @__PURE__ */ new Set();
+  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;
+    let hi;
+    if (rangeStr === "*") {
+      lo = min;
+      hi = max;
+    } else if (/^\d+$/.test(rangeStr)) {
+      lo = Number.parseInt(rangeStr, 10);
+      hi = stepMatch ? max : lo;
+    } else {
+      const rm = rangeStr.match(/^(\d+)-(\d+)$/);
+      if (!rm) return false;
+      lo = Number.parseInt(rm[1], 10);
+      hi = Number.parseInt(rm[2], 10);
+    }
+    for (let v = lo; v <= hi; v += step) {
+      if (v >= min && v <= max) matched.add(v);
+    }
+  }
+  return matched.has(value);
+}
 function nextCronDate(spec, from) {
   const parts = spec.split(/\s+/);
   if (parts.length < 5) return { error: "Invalid cron expression" };
   const [minStr, hourStr, domStr, monthStr, dowStr] = parts;
-  function matchField(value, str, min, max) {
-    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;
-    }
-    if (str.includes(",")) {
-      return str.split(",").some((part) => matchField(value, part.trim(), min, max));
-    }
-    return false;
-  }
   let cursor = new Date(from.getTime());
   cursor.setSeconds(0, 0);
   cursor = new Date(cursor.getTime() + 6e4);
@@ -35674,7 +35705,7 @@ function nextCronDate(spec, from) {
     const dom = cursor.getUTCDate();
     const month = cursor.getUTCMonth() + 1;
     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)) {
+    if (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;
     }
     cursor = new Date(cursor.getTime() + 6e4);
@@ -35752,7 +35783,7 @@ function humanizeSchedule(spec) {
   }
   return "unknown schedule";
 }
-var CrewScheduler;
+var CrewScheduler, CRON_DOW_NAMES, CRON_MONTH_NAMES;
 var init_scheduler = __esm({
   "src/runtime/scheduling/scheduler.ts"() {
     "use strict";
@@ -35907,6 +35938,21 @@ var init_scheduler = __esm({
         throw new Error(`Invalid schedule "${s}". Use "5m", "+10m", ISO timestamp, or cron expression.`);
       }
     };
+    CRON_DOW_NAMES = { SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6 };
+    CRON_MONTH_NAMES = {
+      JAN: 1,
+      FEB: 2,
+      MAR: 3,
+      APR: 4,
+      MAY: 5,
+      JUN: 6,
+      JUL: 7,
+      AUG: 8,
+      SEP: 9,
+      OCT: 10,
+      NOV: 11,
+      DEC: 12
+    };
   }
 });
 
@@ -36532,8 +36578,13 @@ var cancel_exports = {};
 __export(cancel_exports, {
   abortOwned: () => abortOwned,
   handleCancel: () => handleCancel,
-  handleRetry: () => handleRetry
+  handleRetry: () => handleRetry,
+  retryShortCircuitsCompleted: () => retryShortCircuitsCompleted
 });
+function retryShortCircuitsCompleted(runStatus, tasks, targetTaskId) {
+  if (runStatus !== "completed") return false;
+  return !tasks.some((task) => (targetTaskId ? task.id === targetTaskId : true) && RETRYABLE_STATUSES.has(task.status));
+}
 function abortOwned(runId, taskIds, ctx, force) {
   const runCwd = locateRunCwd(runId, ctx.cwd);
   if (!runCwd) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
@@ -36606,6 +36657,13 @@ async function handleRetry(params, ctx, deps) {
     );
   }
   const targetTaskId = typeof params.taskId === "string" ? params.taskId : void 0;
+  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 = /* @__PURE__ */ new Set(["failed", "cancelled"]);
     const matchingTasks = loaded.tasks.filter((task) => {
@@ -36810,6 +36868,7 @@ async function handleCancel(params, ctx, deps) {
     });
   });
 }
+var RETRYABLE_STATUSES;
 var init_cancel = __esm({
   "src/extension/team-tool/cancel.ts"() {
     "use strict";
@@ -36829,6 +36888,7 @@ var init_cancel = __esm({
     init_intent_policy();
     init_param_error();
     init_run_not_found();
+    RETRYABLE_STATUSES = /* @__PURE__ */ new Set(["failed", "cancelled"]);
   }
 });
 
@@ -38806,7 +38866,9 @@ function handleWorktrees(params, ctx) {
       { action: "worktrees", status: "error" },
       true
     );
-  const loaded = loadRunManifestById(ctx.cwd, params.runId);
+  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);
   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 = [
@@ -39331,6 +39393,7 @@ var init_lifecycle_actions = __esm({
     init_run_export();
     init_run_import();
     init_run_maintenance();
+    init_team_tool2();
     init_context();
     init_intent_policy();
     init_param_error();
@@ -41167,10 +41230,13 @@ async function handleManageDomain(params, ctx) {
             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);
@@ -47796,7 +47862,8 @@ function handleExplain(params, cwd) {
   if (!params.runId) {
     return result3("explain requires runId", { action: "explain", status: "error" }, true);
   }
-  const loaded = loadRunManifestById(cwd, params.runId);
+  const runCwd = locateRunCwd(params.runId, cwd);
+  const loaded = runCwd ? loadRunManifestById(runCwd, params.runId) : void 0;
   if (!loaded) {
     return result3(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "explain", status: "error" }, true);
   }
@@ -47855,6 +47922,7 @@ var init_explain = __esm({
   "src/extension/team-tool/explain.ts"() {
     "use strict";
     init_state_store();
+    init_team_tool2();
     init_run_not_found();
   }
 });
@@ -54561,16 +54629,24 @@ function validateWorkerOutput(role, output) {
     issues
   };
 }
-var ROLE_PATTERN_DEFS, makeUrlRe;
+var MARKDOWN_STRUCTURED, STRICT_ROLE_PATTERNS, ROLE_PATTERN_DEFS, makeUrlRe;
 var init_output_validator = __esm({
   "src/runtime/output/output-validator.ts"() {
     "use strict";
+    MARKDOWN_STRUCTURED = /^(?:#{1,6}\s|\*\*|[-*]\s|\d+\.\s)/m;
+    STRICT_ROLE_PATTERNS = {
+      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: new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
+      "security-reviewer": new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
+      verifier: /^(PASS:|FAIL:)/m
+    };
     ROLE_PATTERN_DEFS = {
-      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: () => new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
-      "security-reviewer": () => new RegExp("^([^:\\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")
     };
     makeUrlRe = () => /\bhttps?:\/\/[^\s<>)\]"',;]+/gi;
   }

package/package.json

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

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/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/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;
 		}