pi-crew 0.9.53 → 0.9.55

package/src/config/defaults.ts

@@ -0,0 +1,193 @@
+import type { CrewBrokerConfig } from "./types.ts";
+
+export const DEFAULT_CHILD_PI: Readonly<{
+	postExitStdioGuardMs: number;
+	finalDrainMs: number;
+	/** F12: early-exit the drain if stdout goes silent for ≥ this many ms after
+	 *  the final assistant event AND the assistant already emitted
+	 *  message_end with stopReason=stop. Lets well-behaved workers finish in
+	 *  ~800 ms instead of the full 5 s ceiling. Set to >= finalDrainMs to disable. */
+	finalDrainQuietMs: number;
+	hardKillMs: number;
+	responseTimeoutMs: number;
+	maxCaptureBytes: number;
+	maxAssistantTextChars: number;
+	maxToolResultChars: number;
+	maxToolInputChars: number;
+	maxCompactContentChars: number;
+}> = {
+	postExitStdioGuardMs: 3000,
+	finalDrainMs: 5000,
+	finalDrainQuietMs: 800,
+	hardKillMs: 3000,
+	// Child workers can spend more than a few seconds in provider calls or long-running tools without emitting stdout.
+	// Keep this as a coarse stuck-worker guard rather than a short per-message latency budget.
+	responseTimeoutMs: 10 * 60_000,
+	// #3 unresponsive worker hardening: increased from 256KB to 512KB so critical
+	// diagnostic stderr is less likely to be silently truncated during hang analysis.
+	maxCaptureBytes: 512 * 1024,
+	// L4 output-handling: thresholds sized from real worker-output data
+	// (27 result artifacts measured: max 9226 bytes, median 8272, 100% < 16KB).
+	// Previous values (8192/1024/4096) truncated 62% of real results.
+	// See .crew/research/worker-output-handling.md + source/deer-flow/.research/.
+	maxAssistantTextChars: 16_384,
+	maxToolResultChars: 8_192,
+	maxToolInputChars: 4_096,
+	maxCompactContentChars: 8_192,
+};
+
+export const DEFAULT_LIVE_SESSION = {
+	/** Maximum wall-clock time for a single live-session task before abort (ms). */
+	responseTimeoutMs: 10 * 60_000, // 10 minutes - increased from 5min for complex verification
+	/** Maximum yield reminder attempts before accepting no-yield. */
+	maxYieldRetries: 3,
+	/** Polling interval for session idle check during yield enforcement (ms). */
+	yieldPollIntervalMs: 500,
+	/** Maximum time to wait for session idle after prompt (ms). */
+	idleWaitTimeoutMs: 60_000,
+};
+
+export const DEFAULT_LOCKS = {
+	staleMs: 30_000,
+};
+
+export const DEFAULT_CONCURRENCY = {
+	hardCap: 8,
+	workflow: {
+		parallelResearch: 4,
+		research: 3,
+		implementation: 4,
+		review: 3,
+		default: 3,
+	},
+	fallback: 2,
+};
+
+export const DEFAULT_EVENT_LOG = {
+	terminalEventTypes: [
+		"run.blocked",
+		"run.completed",
+		"run.failed",
+		"run.cancelled",
+		"task.completed",
+		"task.failed",
+		"task.skipped",
+		"task.cancelled",
+		"task.needs_attention",
+	],
+};
+
+export const DEFAULT_ARTIFACT_CLEANUP = {
+	maxAgeDays: 7,
+};
+
+/** Round 25 (L6): thresholds for task-output-context inline-bytes budget.
+ *  Single source of truth for the per-dep cap, total dep cap, and tee
+ *  recovery multiplier. Previously hardcoded in
+ *  src/runtime/task-output-context.ts; moved here so that operators can
+ *  override them via config (Phase 5 ship) without touching runtime code. */
+export const DEFAULT_OUTPUT_CONTEXT = {
+	/** Per-dep inline-bytes cap (chars). Set by plan §5 L4 (96 KB total). */
+	maxResultInlineBytes: 32_000,
+	/** Total inline-bytes budget across all deps for one downstream worker. */
+	maxTotalDepInlineBytes: 96_000,
+	/** Tee recovery threshold: only when file > TEE_THRESHOLD_MULTIPLIER *
+	 *  maxResultInlineBytes, the truncated inline is also written to a
+	 *  tee file (R2: 1.25x = 40 KB). */
+	teeThresholdMultiplier: 1.25,
+} as const;
+
+export const DEFAULT_PATHS = {
+	state: {
+		runsSubdir: "state/runs",
+		artifactsSubdir: "artifacts",
+		subagentsSubdir: "state/subagents",
+		importsSubdir: "imports",
+		worktreesSubdir: "worktrees",
+		manifestFile: "manifest.json",
+		tasksFile: "tasks.json",
+		eventsFile: "events.jsonl",
+	},
+};
+
+export const DEFAULT_UI = {
+	refreshMs: 1000,
+	notifierIntervalMs: 5000,
+	widgetDefaultFrameMs: 1000,
+	widgetPlacement: "aboveEditor" as const,
+	widgetMaxLines: 8,
+	powerbar: true,
+	dashboardPlacement: "center" as const,
+	dashboardWidth: 72,
+	dashboardLiveRefreshMs: 1000,
+	autoOpenDashboard: false,
+	autoOpenDashboardForForegroundRuns: false,
+	showModel: true,
+	showTokens: true,
+	showTools: true,
+	transcriptTailBytes: 1024 * 1024,
+	mascotStyle: "cat" as const,
+	mascotEffect: "random" as const,
+};
+
+export const DEFAULT_NOTIFICATIONS = {
+	severityFilter: ["warning", "error", "critical"] as const,
+	dedupWindowMs: 30_000,
+	batchWindowMs: 0,
+	sinkRetentionDays: 7,
+};
+
+export const DEFAULT_CACHE = {
+	manifestMaxEntries: 64,
+};
+
+export const DEFAULT_MAILBOX = {
+	perFileThresholdBytes: 10 * 1024 * 1024, // 10MB per mailbox file
+	maxArchivesPerDirection: 10, // Keep at most 10 archives per direction per run
+};
+
+export const DEFAULT_SUBAGENT = {
+	stuckBlockedNotifyMs: 5 * 60_000,
+};
+
+/**
+ * Phase 0 inter-pi broker defaults.
+ * Phase 4 (v0.9.47): default is ON (enabled:true). The broker runs
+ * automatically for users on supported platforms (Linux + macOS).
+ * Three independent ways to disable:
+ *   1. `broker.enabled: false` in user config
+ *   2. env `PI_CREW_BROKER=0` (beats config=true)
+ *   3. (Windows) auto-disabled — broker requires unix socket which Windows
+ *      supports only via WSL1/2; native Windows perm model lacks the
+ *      abstract-socket guarantees the broker relies on. See
+ *      docs/decisions/2026-07-21-broker-windows-perms.md.
+ * Limits are bounded by `src/schema/config-schema.ts` CrewBrokerConfigSchema:
+ *   pathHashLen       4..32     (default 8)
+ *   maxFrameBytes     1024..1048576 (default 262144 = 256 KiB)
+ *   outboundQueueCap  32..4096  (default 256)
+ */
+export const DEFAULT_BROKER = {
+	enabled: true,
+	pathHashLen: 8,
+	maxFrameBytes: 262144,
+	outboundQueueCap: 256,
+} as const;
+
+/**
+ * Apply `PI_CREW_BROKER` env override to a parsed broker config.
+ * - `"1"` forces `enabled: true` (beats a config of `false` AND the
+ *   default of `false` when no broker block is configured).
+ * - `"0"` forces `enabled: false` (beats a config of `true`).
+ * - unset / any other value falls through to the parsed value (which
+ *   may itself be `undefined`; the loadConfig merge layer fills defaults).
+ * Phase 0 scope: only the `enabled` flag is overridable via env; numeric
+ * bounds must go through the schema + parser path, not env.
+ */
+export function resolveBrokerEnvOverride(parsed: CrewBrokerConfig | undefined): CrewBrokerConfig | undefined {
+	const override = process.env.PI_CREW_BROKER;
+	if (override === "1" || override === "0") {
+		const base: CrewBrokerConfig = parsed ?? {};
+		return { ...base, enabled: override === "1" };
+	}
+	return parsed;
+}

package/src/config/drift-detector.ts

@@ -0,0 +1,290 @@
+import { PiTeamsConfigSchema } from "../schema/config-schema.ts";
+import type { PiTeamsConfig } from "./config.ts";
+
+/**
+ * A single drift finding between discovered resources and config expectations.
+ */
+export interface DriftItem {
+	kind: "agent" | "team" | "workflow" | "config-key";
+	name: string;
+	status: "missing" | "extra" | "mismatched";
+	expected?: string;
+	actual?: string;
+	severity: "error" | "warning";
+}
+
+/**
+ * Summary counts by drift status.
+ */
+export interface DriftSummary {
+	missing: number;
+	extra: number;
+	mismatched: number;
+}
+
+/**
+ * Full drift report produced by `detectDrift`.
+ */
+export interface DriftReport {
+	hasDrift: boolean;
+	items: DriftItem[];
+	summary: DriftSummary;
+}
+
+/**
+ * Discovered resources passed into the drift detector.
+ */
+export interface DiscoveredResources {
+	agents: string[];
+	teams: string[];
+	workflows: string[];
+}
+
+/**
+ * Config references extracted from team roles and workflow steps.
+ * Used to compare against discovered resources.
+ */
+export interface ConfigReferences {
+	agents: Set<string>;
+	teams: Set<string>;
+	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],
+	};
+}
+
+/**
+ * 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.
+ */
+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.
+ *
+ * Looks at:
+ * - `agents.overrides` keys → referenced agent names
+ * - Top-level keys that aren't in the schema are ignored (handled separately as config-key drift)
+ */
+function extractConfigReferences(config: Record<string, unknown>): ConfigReferences {
+	const agents = new Set<string>();
+	const teams = new Set<string>();
+	const workflows = new Set<string>();
+
+	// agents.overrides keys are explicit agent references
+	const agentsObj =
+		typeof config.agents === "object" && config.agents !== null && !Array.isArray(config.agents)
+			? (config.agents as Record<string, unknown>)
+			: undefined;
+	if (agentsObj) {
+		const overrides =
+			typeof agentsObj.overrides === "object" && agentsObj.overrides !== null && !Array.isArray(agentsObj.overrides)
+				? (agentsObj.overrides as Record<string, unknown>)
+				: undefined;
+		if (overrides) {
+			for (const name of Object.keys(overrides)) {
+				agents.add(name);
+			}
+		}
+	}
+
+	return { agents, teams, workflows };
+}
+
+/**
+ * Detect config drift between discovered resources and the configuration.
+ *
+ * Checks:
+ * 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, 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
+ * discovered are considered missing.
+ *
+ * For teams/workflows: the config currently doesn't have explicit team/workflow references,
+ * so missing/extra checks rely solely on what resources reference each other.
+ */
+export function detectDrift(discovered: DiscoveredResources, config: PiTeamsConfig): DriftReport {
+	const items: DriftItem[] = [];
+
+	const configRaw = config as Record<string, unknown>;
+	const refs = extractConfigReferences(configRaw);
+
+	// --- Agent drift ---
+	const discoveredAgentSet = new Set<string>(discovered.agents);
+
+	// Missing: referenced in agents.overrides but not discovered
+	for (const agentName of refs.agents) {
+		if (!discoveredAgentSet.has(agentName)) {
+			items.push({
+				kind: "agent",
+				name: agentName,
+				status: "missing",
+				expected: "agent file discovered",
+				actual: "not found",
+				severity: "error",
+			});
+		}
+	}
+
+	// Extra: discovered agent referenced in overrides doesn't apply here;
+	// discovered agents not in overrides are not "extra" since they can be built-in.
+	// We only check if the override references a disabled agent that doesn't exist.
+
+	// --- Team drift ---
+	// Teams reference agents via roles; check if any role.agent is not in discovered agents
+	// This is already handled by validate-resources, so we keep it lightweight here.
+	// We do NOT mark teams as "extra" because teams can exist without explicit config references.
+
+	// --- Workflow drift ---
+	// Similar to teams — workflows are discovered but not directly referenced in config.
+	// No extra/missing checks for workflows from config alone.
+
+	// --- Config-key drift ---
+	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 ---
+	// Check if agents.overrides references exist but have unexpected structure
+	if (config.agents?.overrides) {
+		for (const [agentName, override] of Object.entries(config.agents.overrides)) {
+			if (override && typeof override === "object") {
+				const overrideKeys = Object.keys(override as Record<string, unknown>);
+				const knownOverrideKeys = new Set(["disabled", "model", "fallbackModels", "thinking", "tools", "skills"]);
+				const unknownKeys = overrideKeys.filter((key) => !knownOverrideKeys.has(key));
+				if (unknownKeys.length > 0) {
+					items.push({
+						kind: "agent",
+						name: agentName,
+						status: "mismatched",
+						expected: `override keys from schema: ${[...knownOverrideKeys].join(", ")}`,
+						actual: `unknown keys: ${unknownKeys.join(", ")}`,
+						severity: "warning",
+					});
+				}
+			}
+		}
+	}
+
+	// --- Build summary ---
+	const missing = items.filter((item) => item.status === "missing").length;
+	const extra = items.filter((item) => item.status === "extra").length;
+	const mismatched = items.filter((item) => item.status === "mismatched").length;
+
+	return {
+		hasDrift: items.length > 0,
+		items,
+		summary: { missing, extra, mismatched },
+	};
+}
+
+/**
+ * Format a drift report into a human-readable multi-line string.
+ */
+export function formatDriftReport(report: DriftReport): string {
+	if (!report.hasDrift) {
+		return "No drift detected.";
+	}
+	const lines: string[] = [
+		`Drift summary: ${report.summary.missing} missing, ${report.summary.extra} extra, ${report.summary.mismatched} mismatched`,
+		"",
+	];
+	for (const item of report.items) {
+		const severityTag = item.severity === "error" ? "ERROR" : "WARN";
+		const detail = item.expected && item.actual ? ` (expected: ${item.expected}, actual: ${item.actual})` : "";
+		lines.push(`- ${severityTag} [${item.kind}] ${item.name}: ${item.status}${detail}`);
+	}
+	return lines.join("\n");
+}