pi-crew 0.9.41 → 0.9.44

package/src/schema/config-schema.ts

@@ -37,6 +37,7 @@ export const PiTeamsLimitsConfigSchema = Type.Object(
 		maxRetriesPerTask: Type.Optional(Type.Integer({ minimum: 1 })),
 		maxTasksPerRun: Type.Optional(Type.Integer({ minimum: 1 })),
 		heartbeatStaleMs: Type.Optional(Type.Integer({ minimum: 1 })),
+		serializeOnPathOverlap: Type.Optional(Type.Boolean()),
 	},
 	{ additionalProperties: false },
 );
@@ -59,6 +60,17 @@ export const PiTeamsRuntimeConfigSchema = Type.Object(
 		effectivenessGuard: Type.Optional(
 			Type.Union([Type.Literal("off"), Type.Literal("warn"), Type.Literal("block"), Type.Literal("fail")]),
 		),
+		yield: Type.Optional(
+			Type.Object(
+				{
+					enabled: Type.Optional(Type.Boolean()),
+					maxReminders: Type.Optional(Type.Integer({ minimum: 0 })),
+					reminderPrompt: Type.Optional(Type.String({ maxLength: 1000 })),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		excludeContextBash: Type.Optional(Type.Boolean()),
 		isolationPolicy: Type.Optional(
 			Type.Object(
 				{
@@ -182,7 +194,7 @@ export const PiTeamsObservabilityConfigSchema = Type.Object(
 	{
 		enabled: Type.Optional(Type.Boolean()),
 		pollIntervalMs: Type.Optional(Type.Integer({ minimum: 1000, maximum: 60000 })),
-		metricRetentionDays: Type.Optional(Type.Integer({ minimum: 1, maximum: 365 })),
+		metricRetentionDays: Type.Optional(Type.Integer({ minimum: 1, maximum: 90 })),
 	},
 	{ additionalProperties: false },
 );
@@ -205,6 +217,11 @@ export const PiTeamsReliabilityConfigSchema = Type.Object(
 		autoRecover: Type.Optional(Type.Boolean()),
 		deadletterThreshold: Type.Optional(Type.Integer({ minimum: 1 })),
 		cleanupOrphanedTempDirs: Type.Optional(Type.Boolean()),
+		autoRepairIntervalMs: Type.Optional(Type.Integer({ minimum: 0 })),
+		forcePreflight: Type.Optional(Type.Boolean()),
+		ambientStatusInjection: Type.Optional(Type.Boolean()),
+		perWriteValidation: Type.Optional(Type.Boolean()),
+		scopeModels: Type.Optional(Type.Boolean()),
 	},
 	{ additionalProperties: false },
 );
@@ -235,6 +252,7 @@ export const PiTeamsUiConfigSchema = Type.Object(
 		dashboardLiveRefreshMs: Type.Optional(Type.Integer({ minimum: 250, maximum: 60000 })),
 		autoOpenDashboard: Type.Optional(Type.Boolean()),
 		autoOpenDashboardForForegroundRuns: Type.Optional(Type.Boolean()),
+		autoCloseDashboardMs: Type.Optional(Type.Integer({ minimum: 0 })),
 		showModel: Type.Optional(Type.Boolean()),
 		showTokens: Type.Optional(Type.Boolean()),
 		showTools: Type.Optional(Type.Boolean()),

package/src/schema/team-tool-schema.ts

@@ -194,6 +194,8 @@ export const TeamToolParams = Type.Object({
 			description: "Path to a markdown plan document for orchestration.",
 		}),
 	),
+	subAction: Type.Optional(Type.String({ description: "Sub-action for schedule management (remove, disable, enable, update)." })),
+	jobId: Type.Optional(Type.String({ description: "Job ID for schedule management actions." })),
 	cron: Type.Optional(
 		Type.String({
 			description: "Cron expression for recurring scheduled runs (e.g., '0 9 * * MON').",

package/src/skills/discover-skills.ts

@@ -28,23 +28,34 @@ export interface SkillDescriptor {
 }
 
 /**
- * F6 (v0.7.9): discover skills from all five roots (matching pi-subagents'
- * skill-loader so users authoring skills under either convention find them).
- * Roots, in precedence order (first hit wins):
- *   1. <cwd>/.pi/skills          (project, Pi standard)
- *   2. <cwd>/.agents/skills      (project, Agent Skills spec — agentskills.io)
- *   3. <cwd>/skills              (project, legacy pi-crew convention)
- *   4. <getAgentDir>/skills      (user, Pi standard)
- *   5. <homedir>/.agents/skills  (user, Agent Skills spec)
- *   6. <homedir>/.pi/skills      (user, legacy Pi — pre-standard)
- *   7. PACKAGE_SKILLS_DIR        (bundled, trusted)
- * The `PACKAGE_SKILLS_DIR` (bundled) and the legacy `<cwd>/skills` root are
- * kept as separate `source` values to preserve the existing capability
- * inventory shape — callers that key on `source === "package"` / `source ===
- * "project"` keep working.
+ * F6 (v0.7.9): discover skills from all roots (matching pi-subagents' skill-loader
+ * so users authoring skills under either convention find them).
+ *
+ * IMPORTANT — inventory vs injection (SEC-003): this function returns EVERY
+ * skill found across roots (NO first-wins dedup) because it feeds the capability
+ * INVENTORY, which intentionally surfaces all skills (incl. project shadows) for
+ * transparency; `capability-inventory.ts` then marks project/user items that
+ * shadow a package/builtin one and re-sorts by id.
+ *
+ * The actual skill-content INJECTION path is separate: `skill-instructions.ts`
+ * `candidateSkillDirs` + `readSkillMarkdown` use first-wins with PACKAGE FIRST
+ * (SEC-003 fix, regression-tested in test/unit/skill-instructions.test.ts) so a
+ * project skill can NEVER override a trusted package skill's content in worker
+ * prompts. The package-first order below mirrors that injection path for
+ * consistency/defense-in-depth.
+ *
+ * Roots:
+ *   1. PACKAGE_SKILLS_DIR        (bundled, trusted)
+ *   2. <cwd>/.pi/skills          (project, Pi standard)
+ *   3. <cwd>/.agents/skills      (project, Agent Skills spec — agentskills.io)
+ *   4. <cwd>/skills              (project, legacy pi-crew convention)
+ *   5. <getAgentDir>/skills      (user, Pi standard)
+ *   6. <homedir>/.agents/skills  (user, Agent Skills spec)
+ *   7. <homedir>/.pi/skills      (user, legacy Pi — pre-standard)
  */
 function listSkillDirs(cwd: string): Array<{ root: string; source: SkillDescriptor["source"] }> {
 	return [
+		{ root: PACKAGE_SKILLS_DIR, source: "package" },
 		{ root: path.resolve(cwd, ".pi", "skills"), source: "project-pi" },
 		{
 			root: path.resolve(cwd, ".agents", "skills"),
@@ -57,7 +68,6 @@ function listSkillDirs(cwd: string): Array<{ root: string; source: SkillDescript
 			source: "user-agents",
 		},
 		{ root: path.join(os.homedir(), ".pi", "skills"), source: "user-pi" },
-		{ root: PACKAGE_SKILLS_DIR, source: "package" },
 	];
 }
 

package/src/state/active-run-registry.ts

@@ -2,7 +2,6 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
-import { logInternalError } from "../utils/internal-error.ts";
 import { userCrewRoot } from "../utils/paths.ts";
 import { isSafePathId } from "../utils/safe-paths.ts";
 import { sharedScanCache } from "../utils/scan-cache.ts";

package/src/state/atomic-write.ts

@@ -315,8 +315,13 @@ function isRetryableLinkError(error: unknown): boolean {
  * It atomically creates a hard link to the source. We then unlink the source.
  * This prevents TOCTOU attacks where an attacker plants a symlink at the
  * destination between the check and the rename operation.
+ *
+ * ST-8: this is the canonical symlink-safe rename helper used by both
+ * `atomicWriteFile` (sync) and `atomicWriteFileAsync` (async) paths. The
+ * helper is exported so any future caller can share the same symlink-safe
+ * rename semantics; keep this signature stable.
  */
-function renameWithLinkSync(tempPath: string, filePath: string, retries = 8): void {
+export function renameWithLinkSync(tempPath: string, filePath: string, retries = 8): void {
 	let lastError: unknown;
 	for (let attempt = 0; attempt <= retries; attempt++) {
 		try {
@@ -371,7 +376,12 @@ function renameWithLinkSync(tempPath: string, filePath: string, retries = 8): vo
 	throw lastError;
 }
 
-async function renameWithLinkAsync(tempPath: string, filePath: string, retries = 8): Promise<void> {
+/**
+ * ST-8: async twin of `renameWithLinkSync`. Exported so any future caller
+ * can share the same symlink-safe rename semantics as the primary
+ * `atomicWriteFileAsync` path.
+ */
+export async function renameWithLinkAsync(tempPath: string, filePath: string, retries = 8): Promise<void> {
 	let lastError: unknown;
 	for (let attempt = 0; attempt <= retries; attempt++) {
 		try {
@@ -496,21 +506,21 @@ export type WriteDurability = "full" | "best-effort";
 /** Options accepted by atomicWriteFile (forward-compatible string | object form). */
 export type AtomicWriteOptions =
 	| string // legacy: expectedHash
-	| { expectedHash?: string; durability?: WriteDurability };
+	| { expectedHash?: string; durability?: WriteDurability; mode?: number };
 
-function normalizeOptions(arg: unknown): { expectedHash?: string; durability: WriteDurability } {
-	if (typeof arg === "string") return { expectedHash: arg, durability: "full" };
+function normalizeOptions(arg: unknown): { expectedHash?: string; durability: WriteDurability; mode?: number } {
+	if (typeof arg === "string") return { expectedHash: arg, durability: "full", mode: undefined };
 	if (arg && typeof arg === "object") {
-		const o = arg as { expectedHash?: string; durability?: WriteDurability };
+		const o = arg as { expectedHash?: string; durability?: WriteDurability; mode?: number };
 		const durability: WriteDurability = o.durability === "best-effort" ? "best-effort" : "full";
-		return { expectedHash: o.expectedHash, durability };
+		return { expectedHash: o.expectedHash, durability, mode: o.mode };
 	}
-	return { durability: "full" };
+	return { durability: "full", mode: undefined };
 }
 
 export function atomicWriteFile(filePath: string, content: string, options?: AtomicWriteOptions): void {
 	cancelPendingCoalescedWrite(filePath);
-	const { durability } = normalizeOptions(options);
+	const { durability, mode } = normalizeOptions(options);
 	if (!isSymlinkSafeDirCached(filePath))
 		throw new Error(`Refusing to write: target is a symlink or inside untrusted directory: ${filePath}`);
 	// On Windows the parent directory may be referenced via a short-name alias
@@ -556,7 +566,7 @@ export function atomicWriteFile(filePath: string, content: string, options?: Ato
 	const O_NOFOLLOW = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
 	let fd: number | undefined;
 	try {
-		fd = fs.openSync(tempPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | O_NOFOLLOW, 0o600);
+		fd = fs.openSync(tempPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | O_NOFOLLOW, mode ?? 0o600);
 		// Post-open verification: on Windows O_NOFOLLOW is 0, so verify FD is a regular file
 		const openedStat = fs.fstatSync(fd);
 		if (!openedStat.isFile()) {
@@ -747,6 +757,14 @@ let flushInProgress = 0;
  * Buffer a JSON write and flush it after `coalesceMs` ms (default 50).
  * Multiple writes to the same path within the window collapse to one disk write.
  *
+ * ST-7 escape hatch: pass `skipCoalesce: true` to bypass the buffer entirely
+ * and write synchronously via `atomicWriteJson`. Use for terminal task status
+ * transitions where a SIGKILL during the 50ms coalesce window must NOT lose
+ * the terminal status update — otherwise crash recovery would see "running"
+ * in tasks.json while events.jsonl already shows "completed", causing
+ * double-execution / zombie detection. Defaults to `false` (buffered write)
+ * so all existing callers preserve their behavior.
+ *
  * @see The coalescing caveat: a `readJsonFile` call between buffer and flush
  *      sees the previous on-disk content. Callers needing read-after-write
  *      must call `flushPendingAtomicWrites()` first or use `atomicWriteJson`.
@@ -754,9 +772,17 @@ let flushInProgress = 0;
 export function atomicWriteJsonCoalesced<T>(
 	filePath: string,
 	value: T,
-	coalesceMs = DEFAULT_ATOMIC_COALESCE_MS,
+	coalesceMs: number = DEFAULT_ATOMIC_COALESCE_MS,
 	options?: AtomicWriteOptions,
+	skipCoalesce: boolean = false,
 ): void {
+	// ST-7: bypass coalescing for callers that need durable synchronous
+	// semantics. atomicWriteJson goes through atomicWriteFile which uses
+	// renameWithLinkSync + fsync — fully durable, no SIGKILL window.
+	if (skipCoalesce) {
+		atomicWriteJson(filePath, value, options);
+		return;
+	}
 	const content = `${JSON.stringify(value, null, 2)}\n`;
 	const previous = pendingAtomicWrites.get(filePath);
 	if (previous) clearTimeout(previous.timer);

package/src/state/blob-store.ts

@@ -2,7 +2,6 @@ import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { sleepSync } from "../utils/sleep.ts";
 import { atomicWriteFile, renameWithRetry } from "./atomic-write.ts";
 import { withFileLockSync } from "./locks.ts";
 
@@ -152,14 +151,9 @@ export function writeBlob(
 	// FIX: Write blob content FIRST, then metadata. If blob write fails, no orphan metadata.
 	// Previous order was metadata first, then blob - causing orphan metadata on blob failure.
 	let blobContentWritten = false;
-	try {
-		// Write blob content first (immutable, content-addressed)
-		atomicWriteBuffer(blobPath, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf-8"));
-		blobContentWritten = true;
-	} catch (error) {
-		// Blob write failed - no metadata to clean up since we haven't written it yet
-		throw error;
-	}
+	// Write blob content first (immutable, content-addressed)
+	atomicWriteBuffer(blobPath, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf-8"));
+	blobContentWritten = true;
 
 	// Metadata only after blob content is successfully written
 	// Issue 3 fix: Use two-phase commit for metadata - write to temp file first,

package/src/state/contracts.ts

@@ -44,7 +44,7 @@ export const TEAM_TASK_STATUS_TRANSITIONS: Readonly<Record<TeamTaskStatus, reado
 };
 
 /** @internal */
-const TEAM_EVENT_TYPES = [
+export const TEAM_EVENT_TYPES = [
 	"run.created",
 	"run.queued",
 	"run.planning",
@@ -56,6 +56,10 @@ const TEAM_EVENT_TYPES = [
 	"task.created",
 	"task.started",
 	"task.progress",
+	"hook.pre_step_started",
+	"hook.pre_step_completed",
+	"hook.pre_step_failed",
+	"hook.pre_step_optional_failed",
 	"task.blocked",
 	"task.green",
 	"task.red",

package/src/state/crew-init.ts

@@ -17,6 +17,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { atomicWriteFile } from "./atomic-write.ts";
 import { updateGitignore } from "./gitignore-manager.ts";
 
 // Re-export updateGitignore for backwards compatibility with tests.
@@ -238,12 +239,12 @@ export async function ensureCrewDirectory(cwd: string): Promise<void> {
 
 	for (const placeholder of placeholders) {
 		if (!fs.existsSync(placeholder)) {
-			fs.writeFileSync(placeholder, "", "utf-8");
+			atomicWriteFile(placeholder, "");
 		}
 	}
 
 	// 3. Write README.md (always overwrite to keep it current)
-	fs.writeFileSync(safeJoin(crewRoot, "README.md"), buildCrewReadme(), "utf-8");
+	atomicWriteFile(safeJoin(crewRoot, "README.md"), buildCrewReadme());
 
 	// 4. Update .gitignore at project root
 	const repoRoot = findProjectRoot(cwd);

package/src/state/decision-ledger.ts

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { assertSafePathId } from "../utils/safe-paths.ts";
 import { atomicWriteFile } from "./atomic-write.ts";

package/src/state/event-log-rotation.ts

@@ -220,7 +220,7 @@ export function rotateEventLogUnlocked(eventsPath: string): boolean {
 		// copyFileSync + writeFileSync("") ensures eventsPath ALWAYS exists
 		// (no missing-file window for concurrent readers).
 		fs.copyFileSync(eventsPath, archivePath);
-		fs.writeFileSync(eventsPath, "", "utf-8");
+		atomicWriteFile(eventsPath, "");
 		return true;
 	} catch (error) {
 		logInternalError("event-log.rotate", error, `eventsPath=${eventsPath}`);

package/src/state/event-log.ts

@@ -93,7 +93,7 @@ export function withEventLogLockSync<T>(eventsPath: string, fn: () => T, options
 	const pidFile = path.join(lockDir, "pid");
 	const start = Date.now();
 	// SECURITY (HIGH #2 fix): Reduced from 120s to 5s to prevent blocking the
-	// event loop indefinitely. 500 retries × 10ms = 5s max. After timeout, we
+	// event loop indefinitely. ~100 retries × 50ms ≈ 5s max. After timeout, we
 	// throw a clear error instead of blocking forever. This ensures AbortSignal
 	// handlers, SIGTERM, and graceful shutdown can fire within seconds.
 	const timeout = options?.timeoutMs ?? 5000;
@@ -109,7 +109,7 @@ export function withEventLogLockSync<T>(eventsPath: string, fn: () => T, options
 			// (reduced from 120s) is appropriate.
 			fs.mkdirSync(lockDir);
 			try {
-				fs.writeFileSync(pidFile, String(process.pid), "utf-8");
+				atomicWriteFile(pidFile, String(process.pid));
 			} catch {
 				/* best-effort */
 			}
@@ -162,7 +162,7 @@ export function withEventLogLockSync<T>(eventsPath: string, fn: () => T, options
 			} catch {
 				/* no pid file — mtime check above already handles it */
 			}
-			sleepSync(10);
+			sleepSync(50);
 		}
 	}
 	try {
@@ -998,6 +998,7 @@ export function appendEventBuffered(eventsPath: string, event: AppendTeamEvent,
 				});
 			}, bufferMs);
 			bufferedTimers.set(eventsPath, timer);
+			timer.unref();
 		}
 	});
 }

package/src/state/gitignore-manager.ts

@@ -3,6 +3,7 @@
  * Only adds entries if not already present; preserves existing content.
  */
 import * as fs from "node:fs";
+import { atomicWriteFile } from "./atomic-write.ts";
 
 /**
  * Entries to add to .gitignore for .crew directory management.
@@ -25,7 +26,7 @@ const CREW_GITIGNORE_ENTRIES = [
  */
 export async function updateGitignore(gitignorePath: string): Promise<void> {
 	if (!fs.existsSync(gitignorePath)) {
-		fs.writeFileSync(gitignorePath, CREW_GITIGNORE_ENTRIES.join("\n") + "\n", "utf-8");
+		atomicWriteFile(gitignorePath, CREW_GITIGNORE_ENTRIES.join("\n") + "\n");
 		return;
 	}
 

package/src/state/health-store.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ManifestSummary, RunHealth } from "../runtime/task-health.ts";
+import type { ManifestSummary } from "../runtime/task-health.ts";
 import { computeRunHealth } from "../runtime/task-health.ts";
+import { atomicWriteFile } from "./atomic-write.ts";
 
 // Relative to the crew root (`<cwd>/.crew`). BUG A fix (pts/2 hang
 // investigation 2026-06-16): this was `.crew/state/health`, which double-joined
@@ -41,7 +42,9 @@ export class HealthStore {
 		const dir = this.healthDir();
 		fs.mkdirSync(dir, { recursive: true });
 		const file = path.join(dir, `${manifest.runId}.json`);
-		fs.writeFileSync(file, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+		// ST-2: atomic (temp + rename + fsync) — a crash mid-writeFileSync would truncate
+		// the snapshot and loadAllSnapshots() silently skips unparseable files.
+		atomicWriteFile(file, JSON.stringify(snapshot, null, 2) + "\n");
 		return snapshot;
 	}
 

package/src/state/instinct-store.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { assertSafePathId } from "../utils/safe-paths.ts";
+import { atomicWriteFile } from "./atomic-write.ts";
 
 /**
  * Represents a learned instinct that guides agent behavior.
@@ -87,7 +88,13 @@ export class InstinctStore {
 	private appendInstinctToFile(filePath: string, instinct: Instinct): void {
 		const dir = path.dirname(filePath);
 		this.ensureDir(dir);
-		fs.appendFileSync(filePath, `${JSON.stringify(instinct)}\n`, "utf-8");
+		// ST-3: read existing + append + atomic rewrite. appendFileSync has no fsync and
+		// can interleave bytes on concurrent writes. Callers should wrap this in
+		// withFileLockSync(filePath) to serialize concurrent RMW on the same file.
+		const existing = fs.existsSync(filePath) ? this.readInstinctsFromFile(filePath) : [];
+		existing.push(instinct);
+		const content = existing.map((i) => JSON.stringify(i)).join("\n") + "\n";
+		atomicWriteFile(filePath, content);
 	}
 
 	/**
@@ -97,7 +104,9 @@ export class InstinctStore {
 		const dir = path.dirname(filePath);
 		this.ensureDir(dir);
 		const content = instincts.map((i) => JSON.stringify(i)).join("\n") + "\n";
-		fs.writeFileSync(filePath, content, "utf-8");
+		// ST-3: atomic write (temp + rename + fsync) — crash mid-writeFileSync truncates
+		// the JSONL and readInstinctsFromFile silently returns [] (all instincts lost).
+		atomicWriteFile(filePath, content);
 	}
 
 	/**