pi-crew 0.9.40 → 0.9.42

package/src/config/config.ts

@@ -676,6 +676,7 @@ function parseLimitsConfig(value: unknown): CrewLimitsConfig | undefined {
 		maxRetriesPerTask: parsePositiveInteger(obj.maxRetriesPerTask, LIMIT_CEILINGS.maxRetriesPerTask),
 		maxTasksPerRun: parsePositiveInteger(obj.maxTasksPerRun, LIMIT_CEILINGS.maxTasksPerRun),
 		heartbeatStaleMs: parsePositiveInteger(obj.heartbeatStaleMs, LIMIT_CEILINGS.heartbeatStaleMs),
+		serializeOnPathOverlap: parseWithSchema(Type.Boolean(), obj.serializeOnPathOverlap),
 	};
 	return Object.values(limits).some((entry) => entry !== undefined) ? limits : undefined;
 }
@@ -717,6 +718,17 @@ function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
 			Type.Union([Type.Literal("off"), Type.Literal("warn"), Type.Literal("block"), Type.Literal("fail")]),
 			obj.effectivenessGuard,
 		),
+		yield: (() => {
+			const y = asRecord(obj.yield);
+			if (!y) return undefined;
+			const parsed: NonNullable<CrewRuntimeConfig["yield"]> = {
+				enabled: parseWithSchema(Type.Boolean(), y.enabled),
+				maxReminders: parseWithSchema(Type.Integer({ minimum: 0 }), y.maxReminders),
+				reminderPrompt: parseWithSchema(Type.String({ maxLength: 1000 }), y.reminderPrompt),
+			};
+			return Object.values(parsed).some((v) => v !== undefined) ? parsed : undefined;
+		})(),
+		excludeContextBash: parseWithSchema(Type.Boolean(), obj.excludeContextBash),
 		isolationPolicy: parseIsolationPolicy(obj.isolationPolicy),
 	};
 	return Object.values(runtime).some((entry) => entry !== undefined) ? runtime : undefined;
@@ -815,6 +827,7 @@ function parseUiConfig(value: unknown): CrewUiConfig | undefined {
 		dashboardLiveRefreshMs: parseIntegerInRange(obj.dashboardLiveRefreshMs, 250, 60_000),
 		autoOpenDashboard: parseWithSchema(Type.Boolean(), obj.autoOpenDashboard),
 		autoOpenDashboardForForegroundRuns: parseWithSchema(Type.Boolean(), obj.autoOpenDashboardForForegroundRuns),
+		autoCloseDashboardMs: parseWithSchema(Type.Integer({ minimum: 0 }), obj.autoCloseDashboardMs),
 		showModel: parseWithSchema(Type.Boolean(), obj.showModel),
 		showTokens: parseWithSchema(Type.Boolean(), obj.showTokens),
 		showTools: parseWithSchema(Type.Boolean(), obj.showTools),
@@ -932,6 +945,11 @@ function parseReliabilityConfig(value: unknown): CrewReliabilityConfig | undefin
 		autoRecover: parseWithSchema(Type.Boolean(), obj.autoRecover),
 		deadletterThreshold: parsePositiveInteger(obj.deadletterThreshold),
 		cleanupOrphanedTempDirs: parseWithSchema(Type.Boolean(), obj.cleanupOrphanedTempDirs),
+		autoRepairIntervalMs: parseWithSchema(Type.Integer({ minimum: 0 }), obj.autoRepairIntervalMs),
+		forcePreflight: parseWithSchema(Type.Boolean(), obj.forcePreflight),
+		ambientStatusInjection: parseWithSchema(Type.Boolean(), obj.ambientStatusInjection),
+		perWriteValidation: parseWithSchema(Type.Boolean(), obj.perWriteValidation),
+		scopeModels: parseWithSchema(Type.Boolean(), obj.scopeModels),
 	};
 	return Object.values(reliability).some((entry) => entry !== undefined) ? reliability : undefined;
 }
@@ -985,6 +1003,7 @@ export function parseConfig(raw: unknown): PiTeamsConfig {
 		executeWorkers: parseWithSchema(Type.Boolean(), obj.executeWorkers),
 		notifierIntervalMs: parseWithSchema(Type.Number({ minimum: 1_000 }), obj.notifierIntervalMs),
 		requireCleanWorktreeLeader: parseWithSchema(Type.Boolean(), obj.requireCleanWorktreeLeader),
+		ignoreMethod: parseWithSchema(Type.Union([Type.Literal("gitignore"), Type.Literal("exclude")]), obj.ignoreMethod),
 		autonomous: parseAutonomousConfig(obj.autonomous),
 		limits: parseLimitsConfig(obj.limits),
 		runtime: parseRuntimeConfig(obj.runtime),

package/src/config/drift-detector.ts

@@ -50,10 +50,92 @@ export interface ConfigReferences {
 	workflows: Set<string>;
 }
 
+const MAX_CONFIG_KEY_DEPTH = 3;
+
+type ConfigSchemaNode = Record<string, unknown>;
+
+interface SchemaKeyResolution {
+	allowed: boolean;
+	childSchema?: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function schemaAlternatives(schema: unknown): ConfigSchemaNode[] {
+	if (!isRecord(schema)) return [];
+	const alternatives = Array.isArray(schema.anyOf) ? schema.anyOf.flatMap((entry) => schemaAlternatives(entry)) : [];
+	return [schema, ...alternatives];
+}
+
+function resolveSchemaKey(schema: unknown, key: string): SchemaKeyResolution {
+	let sawObjectSchema = false;
+	let allowsAdditionalProperties = false;
+	const childSchemas: unknown[] = [];
+
+	for (const candidate of schemaAlternatives(schema)) {
+		const properties = isRecord(candidate.properties) ? candidate.properties : undefined;
+		const patternProperties = isRecord(candidate.patternProperties) ? candidate.patternProperties : undefined;
+		if (candidate.type !== "object" && !properties && !patternProperties) continue;
+		sawObjectSchema = true;
+
+		if (properties && Object.hasOwn(properties, key)) {
+			childSchemas.push(properties[key]);
+			continue;
+		}
+
+		let matchedPattern = false;
+		if (patternProperties) {
+			for (const [pattern, childSchema] of Object.entries(patternProperties)) {
+				try {
+					if (new RegExp(pattern).test(key)) {
+						childSchemas.push(childSchema);
+						matchedPattern = true;
+						break;
+					}
+				} catch {
+					// Schema patterns are trusted constants; an invalid one simply cannot match.
+				}
+			}
+		}
+		if (!matchedPattern && candidate.additionalProperties !== false) {
+			allowsAdditionalProperties = true;
+		}
+	}
+
+	return {
+		allowed: !sawObjectSchema || childSchemas.length > 0 || allowsAdditionalProperties,
+		childSchema: childSchemas[0],
+	};
+}
+
 /**
- * Known top-level config keys allowed by the schema.
+ * Recursively compare object keys with their TypeBox schema nodes. Root is
+ * depth 0; nested objects are traversed through depth 3, which covers the
+ * deepest current config shapes (`goalWrap.<workflow>.verification` and
+ * `agents.overrides.<agent>`) without allowing attacker-controlled recursion.
  */
-const SCHEMA_KEYS: ReadonlySet<string> = new Set<string>(Object.keys(PiTeamsConfigSchema.properties ?? {}));
+function findUnknownConfigKeyPaths(value: unknown, schema: unknown, depth = 0, path: readonly string[] = []): string[][] {
+	if (!isRecord(value) || depth > MAX_CONFIG_KEY_DEPTH) return [];
+	const unknownPaths: string[][] = [];
+	for (const [key, childValue] of Object.entries(value)) {
+		const childPath = [...path, key];
+		const resolution = resolveSchemaKey(schema, key);
+		if (!resolution.allowed) {
+			unknownPaths.push(childPath);
+			continue;
+		}
+		if (resolution.childSchema !== undefined && depth < MAX_CONFIG_KEY_DEPTH) {
+			unknownPaths.push(...findUnknownConfigKeyPaths(childValue, resolution.childSchema, depth + 1, childPath));
+		}
+	}
+	return unknownPaths;
+}
+
+function isAgentOverrideKeyPath(path: readonly string[]): boolean {
+	return path.length === 4 && path[0] === "agents" && path[1] === "overrides";
+}
 
 /**
  * Extract all agent, team, and workflow names referenced in a raw config object.
@@ -94,7 +176,7 @@ function extractConfigReferences(config: Record<string, unknown>): ConfigReferen
  * 1. **Missing**: resource referenced in config (e.g. agents.overrides) but not discovered → error
  * 2. **Extra**: discovered resource not referenced anywhere in config → warning
  * 3. **Mismatched**: resource exists in both but with structural differences → warning
- * 4. **Config keys**: config keys not present in the schema → warning
+ * 4. **Config keys**: config keys not present in the schema, recursively through depth 3 → warning
  *
  * For agents: compares against `agents.overrides` in config. Discovered agents not in overrides
  * are NOT considered extra (they may be built-in). Only agents referenced in overrides but not
@@ -140,18 +222,18 @@ export function detectDrift(discovered: DiscoveredResources, config: PiTeamsConf
 	// No extra/missing checks for workflows from config alone.
 
 	// --- Config-key drift ---
-	const configKeys = Object.keys(configRaw);
-	for (const key of configKeys) {
-		if (!SCHEMA_KEYS.has(key)) {
-			items.push({
-				kind: "config-key",
-				name: key,
-				status: "extra",
-				expected: `key not in schema`,
-				actual: `present in config`,
-				severity: "warning",
-			});
-		}
+	for (const keyPath of findUnknownConfigKeyPaths(configRaw, PiTeamsConfigSchema)) {
+		// Preserve the existing, more specific agent/mismatched finding for
+		// agents.overrides.<agent>.<key> instead of reporting the same key twice.
+		if (isAgentOverrideKeyPath(keyPath)) continue;
+		items.push({
+			kind: "config-key",
+			name: keyPath.join("."),
+			status: "extra",
+			expected: `key not in schema`,
+			actual: `present in config`,
+			severity: "warning",
+		});
 	}
 
 	// --- Mismatched config-key check ---

package/src/config/resilient-parser.ts

@@ -86,11 +86,11 @@ export function parseConfigResilient(raw: unknown): ResilientParseResult {
 		const value = raw[key];
 		const subSchema = (PiTeamsConfigSchema.properties as Record<string, unknown>)[key];
 		if (subSchema && !Value.Check(subSchema as TSchema, value)) {
-			// Collect the first error for this field
+			// Collect ALL errors for this field
 			const fieldErrors = [...Value.Errors(subSchema as TSchema, value)];
-			if (fieldErrors.length > 0) {
-				const first = fieldErrors[0] as unknown as Record<string, unknown>;
-				const msg = typeof first.message === "string" ? first.message : "invalid value";
+			for (const err of fieldErrors) {
+				const errObj = err as unknown as Record<string, unknown>;
+				const msg = typeof errObj.message === "string" ? errObj.message : "invalid value";
 				errors.push({
 					field: key,
 					message: msg,

package/src/extension/crew-cleanup.ts

@@ -93,11 +93,25 @@ export function registerCleanupHandler(pi: ExtensionAPI): void {
 
 async function cleanupChildProcesses(): Promise<void> {
 	const pids = childProcessRegistry.getAllPids();
-
+	if (pids.length === 0) return;
+	// Lazy-import to avoid eagerly pulling the heavy runtime/child-pi chain into the
+	// extension load path (check-lazy-imports) AND to avoid a static import cycle
+	// (child-pi.ts already imports registerChildProcess from this module).
+	// LAZY: defer child-pi.ts load (heavy runtime chain) + avoid static import cycle.
+	const { killProcessPid } = await import("../runtime/child-pi.ts");
 	for (const pid of pids) {
+		// killProcessPid signals the whole process GROUP (-pid on POSIX, taskkill /T on
+		// Windows) and escalates to SIGKILL after HARD_KILL_MS. A bare
+		// process.kill(pid, "SIGTERM") only reaches the direct child — grandchildren
+		// (bash/MCP the worker spawned) in the child's group survive as orphans, and
+		// a child that lags SIGTERM would linger forever with no escalation.
+		// NOTE: on graceful session_shutdown (reason=quit/reload) register.ts ALSO runs
+		// terminateActiveChildPiProcesses(); both are idempotent for a dying pid. This
+		// signal handler (SIGTERM/SIGHUP) is the SOLE teardown path when the Pi process
+		// is killed by signal, so it must be robust on its own.
 		try {
-			process.kill(pid, "SIGTERM");
-			console.log(`[pi-crew] Sent SIGTERM to child process ${pid}`);
+			killProcessPid(pid);
+			console.log(`[pi-crew] Sent group SIGTERM (+SIGKILL escalation) to child process ${pid}`);
 		} catch (error: unknown) {
 			// Process may already be dead or not exist
 			const err = error as NodeJS.ErrnoException;

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

@@ -19,7 +19,7 @@ function safeUiCall(scope: string, fn: () => void): void {
 	}
 }
 
-import { type CrewVibesConfig, loadConfig, PROVIDER_STATUS_ID, saveConfig } from "./config.ts";
+import { type CrewVibesConfig, loadConfig, saveConfig } from "./config.ts";
 import { intervalForSpeed } from "./figures.ts";
 import { type CrewVibesFooterSource, createCrewVibesFooter } from "./footer.ts";
 import { clearProviderUsageCache, fetchProviderUsage, type ProviderUsage } from "./provider-usage.ts";

package/src/extension/cross-extension-rpc.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
-import { resolveContainedPath } from "../utils/safe-paths.ts";
+import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { withHmacVerification } from "./rpc-hmac.ts";
 // Lazy-loaded to avoid pulling team-tool.ts (and its entire runtime chain) into module load.
 import type { handleTeamTool as HandleTeamToolFn } from "./team-tool.ts";
@@ -109,7 +109,10 @@ export function resetRpcRateLimit(): void {
 	rpcRunTimestamps.length = 0;
 }
 
-function isAllowedRpcRunParams(params: TeamToolParamsValue): {
+export function isAllowedRpcRunParams(
+	params: TeamToolParamsValue,
+	ctx: ExtensionContext,
+): {
 	ok: boolean;
 	error?: string;
 } {
@@ -123,10 +126,16 @@ function isAllowedRpcRunParams(params: TeamToolParamsValue): {
 			error: "RPC run requires config.intent (a non-empty intent string)",
 		};
 	}
-	// SECURITY: Validate cwd is within the project directory if provided.
+	// SECURITY: Validate cwd, if provided, resolves WITHIN the project directory (ctx.cwd).
+	// Arg order is (baseDir=ctx.cwd, targetPath=params.cwd): the project dir is the container,
+	// the caller-supplied cwd is the contained target. (Previously the args were swapped —
+	// resolveContainedPath(params.cwd, ".") — which validates that "." is inside params.cwd,
+	// trivially true for ANY path, so the check never rejected anything.)
+	// NOTE: defense-in-depth — handleTeamTool currently uses ctx.cwd and ignores params.cwd,
+	// but a correct guard here prevents a future regression from silently enabling cwd escape.
 	if (params.cwd && typeof params.cwd === "string") {
 		try {
-			resolveContainedPath(params.cwd, ".");
+			resolveRealContainedPath(ctx.cwd, params.cwd);
 		} catch {
 			return {
 				ok: false,
@@ -152,6 +161,10 @@ export function registerPiCrewRpc(
 	getCtx: () => ExtensionContext | undefined,
 ): PiCrewRpcHandle | undefined {
 	if (!events) return undefined;
+	// Note: the prior loud startup warning has been replaced by a soft, opt-out
+	// info note emitted lazily by withHmacVerification only when an actual RPC
+	// request is processed (see rpc-hmac.ts). This avoids noisy output during
+	// every pi load for users who never wire cross-extension RPC.
 	const unsubs = [
 		on(
 			events,
@@ -214,7 +227,7 @@ export function registerPiCrewRpc(
 					} else {
 						params = { action: "run" };
 					}
-					const permission = isAllowedRpcRunParams(params);
+					const permission = isAllowedRpcRunParams(params, ctx);
 					if (!permission.ok) {
 						reply(events, "pi-crew:rpc:run", id, {
 							success: false,

package/src/extension/management.ts

@@ -6,6 +6,7 @@ import { serializeAgent } from "../agents/agent-serializer.ts";
 import { discoverAgents, invalidateAgentDiscoveryCache } from "../agents/discover-agents.ts";
 import type { PiTeamsConfig } from "../config/config.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { allTeams, discoverTeams, invalidateTeamDiscoveryCache } from "../teams/discover-teams.ts";
 import type { TeamConfig, TeamRole } from "../teams/team-config.ts";
 import { serializeTeam } from "../teams/team-serializer.ts";
@@ -258,7 +259,7 @@ function updateReferencesForRename(
 		changed.push(team.filePath);
 		if (!dryRun) {
 			backupFile(team.filePath);
-			fs.writeFileSync(team.filePath, serializeTeam(nextTeam), "utf-8");
+			atomicWriteFile(team.filePath, serializeTeam(nextTeam));
 		}
 	}
 	// L12 fix: also update workflow step role references when renaming agents.
@@ -276,7 +277,7 @@ function updateReferencesForRename(
 		changed.push(workflow.filePath);
 		if (!dryRun) {
 			backupFile(workflow.filePath);
-			fs.writeFileSync(workflow.filePath, serializeWorkflow({ ...workflow, steps: newSteps }), "utf-8");
+			atomicWriteFile(workflow.filePath, serializeWorkflow({ ...workflow, steps: newSteps }));
 		}
 	}
 	// L12 fix: update agent references in test fixtures.
@@ -290,7 +291,7 @@ function updateReferencesForRename(
 			if (newContent !== content) {
 				changed.push(fixture);
 				if (!dryRun) {
-					fs.writeFileSync(fixture, newContent, "utf-8");
+					atomicWriteFile(fixture, newContent);
 				}
 			}
 		}
@@ -388,7 +389,7 @@ export function handleCreate(params: TeamToolParamsValue, ctx: ManagementContext
 
 	if (params.dryRun) return result(`[dry-run] Would create ${params.resource} '${name}' at ${filePath}:\n\n${content}`);
 	try {
-		fs.writeFileSync(filePath, content, "utf-8");
+		atomicWriteFile(filePath, content);
 	} catch (writeError) {
 		return result(
 			`Failed to create ${params.resource}: ${writeError instanceof Error ? writeError.message : String(writeError)}`,
@@ -513,7 +514,7 @@ export function handleUpdate(params: TeamToolParamsValue, ctx: ManagementContext
 				}
 			}
 		}
-		fs.writeFileSync(nextPath, content, "utf-8");
+		atomicWriteFile(nextPath, content);
 	} catch (updateError) {
 		return result(
 			`Failed to update ${params.resource}: ${updateError instanceof Error ? updateError.message : String(updateError)}`,