pi-crew 0.1.45 → 0.1.49

package/src/runtime/manifest-cache.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
 import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { activeRunEntries } from "../state/active-run-registry.ts";
 import { isSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
@@ -106,8 +107,10 @@ function parseManifestIfChanged(root: string, runId: string, filePath: string, p
 }
 
 function listRunRoots(cwd: string): string[] {
+	const roots = new Set<string>();
 	const base = findRepoRoot(cwd) ? projectCrewRoot(cwd) : userCrewRoot();
-	return [path.join(base, DEFAULT_PATHS.state.runsSubdir)];
+	roots.add(path.join(base, DEFAULT_PATHS.state.runsSubdir));
+	return [...roots];
 }
 
 function collectRoots(root: string): ParsedEntry[] {
@@ -156,6 +159,15 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 	function loadManifest(runId: string, rootsToCheck: string[]): CachedManifest | undefined {
 		let cached = manifestIndex.get(runId);
 		if (!isSafePathId(runId)) return undefined;
+		const activeEntry = activeRunEntries().find((entry) => entry.runId === runId);
+		if (activeEntry) {
+			const activeRoot = path.dirname(activeEntry.stateRoot);
+			const parsed = parseManifestIfChanged(activeRoot, runId, activeEntry.manifestPath, cached);
+			if (parsed) {
+				manifestIndex.set(runId, parsed);
+				return parsed;
+			}
+		}
 		for (const root of rootsToCheck) {
 			const manifestPath = manifestPathForRun(root, runId);
 			if (!manifestPath) continue;
@@ -180,7 +192,10 @@ export function createManifestCache(cwd: string, options: ManifestCacheOptions =
 		if (cached && cached.expireAtMs > now) {
 			return cached.runs;
 		}
-		const parsedEntries = roots.flatMap((root) => collectRoots(root));
+		const parsedEntries = [
+			...roots.flatMap((root) => collectRoots(root)),
+			...activeRunEntries().map((entry) => ({ runId: entry.runId, path: entry.manifestPath })),
+		];
 		const unique = new Map<string, CachedManifest | undefined>();
 		for (const entry of parsedEntries) {
 			if (entry.runId.length === 0) continue;

package/src/runtime/mcp-proxy.ts

@@ -0,0 +1,113 @@
+/**
+ * G2: MCP Proxy for live-session workers.
+ *
+ * When the parent process has MCP servers configured, live-session workers
+ * can reuse those connections instead of establishing their own. This module
+ * discovers MCP tools available in the parent environment and creates proxy
+ * tool definitions that forward calls through the parent's connections.
+ *
+ * Strategy:
+ * 1. If the Pi SDK session has MCP tools after bindExtensions → use them directly
+ * 2. If not → create proxy custom tools that wrap MCP calls
+ * 3. If no MCP config exists → disable MCP in the session
+ *
+ * The Pi SDK's `createAgentSession` accepts a `customTools` array for injecting
+ * proxy tools. The session also accepts `enableMCP: false` to skip MCP discovery
+ * when proxying from the parent.
+ */
+
+import { defineTool, type ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { Type, type Static, type TSchema } from "@sinclair/typebox";
+
+export interface McpProxyConfig {
+	/** Whether to enable MCP in the child session. */
+	enableMcp: boolean;
+	/** Proxy tools to inject via customTools (replaces MCP connection). */
+	proxyTools: Array<ToolDefinition<TSchema, unknown>>;
+	/** Names of MCP tools available (for metadata/tracking). */
+	proxyToolNames: string[];
+}
+
+/**
+ * Build MCP proxy configuration for a live-session worker.
+ *
+ * @param options.parentMcpTools — MCP tool names from the parent session (if available)
+ * @param options.shareMcp — Whether to share MCP connections (default: true)
+ */
+export function buildMcpProxyConfig(options: {
+	parentMcpTools?: string[];
+	shareMcp?: boolean;
+}): McpProxyConfig {
+	if (options.shareMcp === false) {
+		return { enableMcp: true, proxyTools: [], proxyToolNames: [] };
+	}
+
+	const parentTools = options.parentMcpTools ?? [];
+	if (parentTools.length === 0) {
+		// No MCP tools in parent — let session discover on its own
+		return { enableMcp: true, proxyTools: [], proxyToolNames: [] };
+	}
+
+	// MCP tools exist in parent — try to create proxy tools.
+	// If proxy tools are not available (stub), keep enableMcp: true
+	// so the child session can self-discover MCP instead of losing all access.
+	const proxyTools = createMcpProxyTools(parentTools);
+	if (proxyTools.length === 0) {
+		// No proxy tools available — let child discover MCP on its own
+		return { enableMcp: true, proxyTools: [], proxyToolNames: parentTools };
+	}
+	return {
+		enableMcp: false,
+		proxyTools,
+		proxyToolNames: parentTools,
+	};
+}
+
+/**
+ * Create lightweight proxy tools that represent MCP tools from the parent.
+ *
+ * These tools tell the model that the MCP tools are available, but actual
+ * execution is forwarded through the parent's MCP connections. Since we
+ * can't directly access the parent's MCP manager from a child session,
+ * the tools return a message indicating the model should use them normally.
+ *
+ * In a future iteration, these can be wired to the actual MCP connections
+ * via an inter-process bridge.
+ */
+function createMcpProxyTools(
+	toolNames: string[],
+): Array<ToolDefinition<TSchema, unknown>> {
+	// For now, we don't create individual proxy tools because we can't
+	// forward MCP calls without the parent's MCP manager reference.
+	//
+	// Instead, we let the child session discover MCP on its own (enableMcp: true)
+	// or share the parent's MCP config directory.
+	//
+	// This will be enhanced when we add inter-process MCP call forwarding.
+	return [];
+}
+
+/**
+ * Discover MCP tool names from a live session's active tools.
+ * MCP tools typically have names containing "__" (e.g., "mcp__filesystem__read_file").
+ */
+export function discoverMcpToolNames(activeToolNames: string[]): string[] {
+	return activeToolNames.filter(
+		(name) =>
+			name.startsWith("mcp__") ||
+			name.startsWith("mcp-") ||
+			(name.includes("__") && !name.startsWith("submit_result")),
+	);
+}
+
+/**
+ * Build MCP proxy config from a real Pi SDK session's active tools.
+ * This is the preferred way — inspect what the parent session has available.
+ */
+export function buildMcpProxyFromSession(
+	activeToolNames: string[],
+	options?: { shareMcp?: boolean },
+): McpProxyConfig {
+	const mcpTools = discoverMcpToolNames(activeToolNames);
+	return buildMcpProxyConfig({ parentMcpTools: mcpTools, shareMcp: options?.shareMcp });
+}

package/src/runtime/model-fallback.ts

@@ -117,9 +117,10 @@ export function configuredModelInfosFromPiConfig(cwd?: string): AvailableModelIn
 	const globalSettings = readJsonObject(path.join(agentDir, "settings.json")) as PiSettingsLike | undefined;
 	const projectSettings = cwd ? readJsonObject(path.join(cwd, ".pi", "settings.json")) as PiSettingsLike | undefined : undefined;
 	const effectiveSettings = { ...(globalSettings ?? {}), ...(projectSettings ?? {}) };
+	const defaultModel = settingsModelInfo(effectiveSettings);
 	return uniqueModelInfos([
+		...(defaultModel ? [defaultModel] : []),
 		...modelsJsonInfos(readJsonObject(path.join(agentDir, "models.json")) as PiModelsJsonLike | undefined),
-		...(settingsModelInfo(effectiveSettings) ? [settingsModelInfo(effectiveSettings)!] : []),
 	]);
 }
 
@@ -236,6 +237,7 @@ export interface ConfiguredModelRouting {
 export function buildConfiguredModelRouting(input: {
 	overrideModel?: string;
 	stepModel?: string;
+	teamRoleModel?: string;
 	agentModel?: string;
 	fallbackModels?: string[];
 	parentModel?: unknown;
@@ -250,11 +252,11 @@ export function buildConfiguredModelRouting(input: {
 	// B3: Parent model inheritance — when agent has no model specified,
 	// inherit from parent session model before falling back to defaults.
 	const effectiveAgentModel = input.agentModel?.trim() ? input.agentModel : parentModel;
-	const requested = [input.overrideModel, input.stepModel, effectiveAgentModel].find((model): model is string => Boolean(model?.trim()));
+	const requested = [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel].find((model): model is string => Boolean(model?.trim()));
 	if (availableModels && availableModels.length === 0) return { requested, candidates: [], reason: "no configured Pi models available" };
 	const rawModels = availableModels
-		? [input.overrideModel, input.stepModel, effectiveAgentModel, ...(input.fallbackModels ?? []), ...availableModels.map((model) => model.fullId)]
-		: [input.overrideModel, parentModel];
+		? [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel, ...(input.fallbackModels ?? []), ...availableModels.map((model) => model.fullId)]
+		: [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel, ...(input.fallbackModels ?? []), parentModel];
 	const configuredModels = rawModels
 		.filter((model): model is string => Boolean(model?.trim()))
 		.filter((model) => isAvailableModel(model.trim(), availableModels));

package/src/runtime/notebook-helpers.ts

@@ -0,0 +1,90 @@
+export interface NotebookCell {
+  index: number;
+  cellType: "code" | "markdown" | "raw";
+  source: string;
+  outputs?: unknown[];
+  metadata?: Record<string, unknown>;
+}
+
+export interface Notebook {
+  cells: NotebookCell[];
+  metadata?: Record<string, unknown>;
+  nbformat: number;
+}
+
+/** Check if a file path is a notebook */
+export function isNotebookPath(filePath: string): boolean {
+  return filePath.toLowerCase().endsWith(".ipynb");
+}
+
+function normalizeSource(source: unknown): string {
+  if (typeof source === "string") return source;
+  if (Array.isArray(source)) return source.join("");
+  return "";
+}
+
+/** Parse a .ipynb JSON file into a Notebook structure */
+export function parseNotebook(content: string): Notebook {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(content);
+  } catch {
+    return { cells: [], nbformat: 4 };
+  }
+  if (typeof raw !== "object" || raw === null) return { cells: [], nbformat: 4 };
+  const obj = raw as Record<string, unknown>;
+  const nbformat = typeof obj.nbformat === "number" ? obj.nbformat : 4;
+  const rawCells = Array.isArray(obj.cells) ? obj.cells : [];
+  const cells: NotebookCell[] = rawCells
+    .map((c: unknown, i: number): NotebookCell | null => {
+      if (typeof c !== "object" || c === null) return null;
+      const cell = c as Record<string, unknown>;
+      const cellType = cell.cell_type;
+      if (cellType !== "code" && cellType !== "markdown" && cellType !== "raw") return null;
+      return {
+        index: i,
+        cellType,
+        source: normalizeSource(cell.source),
+        outputs: Array.isArray(cell.outputs) ? cell.outputs : undefined,
+        metadata:
+          cell.metadata && typeof cell.metadata === "object" && !Array.isArray(cell.metadata)
+            ? (cell.metadata as Record<string, unknown>)
+            : undefined,
+      };
+    })
+    .filter((c: NotebookCell | null): c is NotebookCell => c !== null);
+  const metadata =
+    obj.metadata && typeof obj.metadata === "object" && !Array.isArray(obj.metadata)
+      ? (obj.metadata as Record<string, unknown>)
+      : undefined;
+  return { cells, metadata, nbformat };
+}
+
+/** Get a specific cell by index */
+export function getCell(notebook: Notebook, index: number): NotebookCell | undefined {
+  return notebook.cells.find((c) => c.index === index);
+}
+
+/** Update a cell's source content, returning a new Notebook */
+export function updateCell(notebook: Notebook, index: number, source: string): Notebook {
+  const cells = notebook.cells.map((c) =>
+    c.index === index ? { ...c, source } : c,
+  );
+  return { ...notebook, cells };
+}
+
+/** Serialize a Notebook back to .ipynb JSON string */
+export function serializeNotebook(notebook: Notebook): string {
+  const raw = {
+    nbformat: notebook.nbformat,
+    nbformat_minor: 5,
+    metadata: notebook.metadata ?? {},
+    cells: notebook.cells.map((c) => ({
+      cell_type: c.cellType,
+      source: c.source,
+      metadata: c.metadata ?? {},
+      ...(c.cellType === "code" ? { outputs: c.outputs ?? [], execution_count: null } : {}),
+    })),
+  };
+  return JSON.stringify(raw, null, 2) + "\n";
+}

package/src/runtime/orphan-sentinel.ts

@@ -0,0 +1,7 @@
+/**
+ * Orphan sentinel — DEPRECATED, replaced by parent-guard.ts.
+ *
+ * Keeping this file as a no-op placeholder until all references are removed.
+ * Workers now self-monitor via startParentGuard() instead of relying on
+ * an external sentinel process.
+ */

package/src/runtime/output-validator.ts

@@ -0,0 +1,187 @@
+/**
+ * Phase 4 (caveman): Output format validation for live-session workers.
+ *
+ * Validates that worker output conforms to the structured output contract
+ * for the given role. If validation fails, returns structured error info
+ * that can be used for retry or fallback.
+ *
+ * Inspired by caveman's validate.py — check structural preservation
+ * (headings, code blocks, URLs) after compression.
+ */
+
+/** Role-specific output format patterns — constructed fresh per call to avoid /g lastIndex leak */
+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,
+};
+
+/** Fresh RegExp factories for structural preservation checks (avoids /g lastIndex leak) */
+const makeUrlRe = () => /\bhttps?:\/\/[^\s<>)\]"',;]+/gi;
+const makeFencedCodeRe = () => /```[\s\S]*?```/g;
+const makeInlineCodeRe = () => /`[^`\n]+`/g;
+const makeHeadingRe = () => /^#{1,6}\s+.+/gm;
+
+export interface OutputValidationResult {
+	/** Whether the output passes validation */
+	valid: boolean;
+	/** Whether the output follows the role's contract format */
+	formatMatch: boolean;
+	/** Whether structural elements (code, URLs, headings) are preserved */
+	structurePreserved: boolean;
+	/** Specific issues found */
+	issues: string[];
+}
+
+/**
+ * Validate worker output against role-specific contract + structural preservation.
+ */
+export function validateWorkerOutput(role: string, output: string): OutputValidationResult {
+	const issues: string[] = [];
+
+	// Empty output always fails
+	if (!output || !output.trim()) {
+		return { valid: false, formatMatch: false, structurePreserved: false, issues: ["Empty output"] };
+	}
+
+	// Check role-specific format
+	const patternFactory = ROLE_PATTERN_DEFS[role];
+	const pattern = patternFactory ? patternFactory() : undefined;
+	const formatMatch = !pattern || pattern.test(output);
+	if (!formatMatch) {
+		issues.push(`Output does not match expected ${role} contract format`);
+	}
+
+	// Check structural preservation (code blocks, URLs, headings)
+	let structurePreserved = true;
+	const trimmedOutput = output.trim();
+
+	// Detect if output was truncated mid-code-block
+	const opens = (trimmedOutput.match(/```/g) ?? []).length;
+	if (opens % 2 !== 0) {
+		structurePreserved = false;
+		issues.push("Unclosed code block — output may be truncated");
+	}
+
+	// Check for malformed URLs
+	const urls = trimmedOutput.match(makeUrlRe()) ?? [];
+	for (const url of urls) {
+		if (url.endsWith(".") || url.endsWith(",")) {
+			structurePreserved = false;
+			issues.push(`URL with trailing punctuation: ${url.slice(-20)}`);
+		}
+	}
+
+	return {
+		valid: formatMatch && structurePreserved,
+		formatMatch,
+		structurePreserved,
+		issues,
+	};
+}
+
+/**
+ * Extract structured findings from reviewer output.
+ * Returns array of { file, line, severity, message } objects.
+ */
+export function parseReviewerFindings(output: string): Array<{ file: string; line: number; severity: string; message: string }> {
+	const findings: Array<{ file: string; line: number; severity: string; message: string }> = [];
+	const lines = output.split("\n");
+
+	const SEVERITY_MAP: Record<string, string> = {
+		"🔴": "bug",
+		"🟡": "risk",
+		"🔵": "nit",
+		"❓": "question",
+	};
+
+	for (const line of lines) {
+		// Match: path/to/file.ts:42: 🔴 bug: problem. fix.
+		const match = line.match(/^([^:\s]+):(\d+):\s+(\p{Emoji_Presentation}) (\w+):\s+(.+)/u);
+		if (match) {
+			findings.push({
+				file: match[1],
+				line: Number(match[2]),
+				severity: SEVERITY_MAP[match[3]] ?? match[3],
+				message: match[5].trim(),
+			});
+		}
+	}
+
+	return findings;
+}
+
+/**
+ * Extract explorer results from structured output.
+ * Returns array of { file, line, symbol, note } objects.
+ */
+export function parseExplorerResults(output: string): Array<{ file: string; line: number; symbol: string; note: string }> {
+	const results: Array<{ file: string; line: number; symbol: string; note: string }> = [];
+	const lines = output.split("\n");
+
+	for (const line of lines) {
+		// Match: path/to/file.ts:42 — `symbol` — note
+		const match = line.match(/^[- ]*(\S+):(\d+)\s*[—–-]\s*`([^`]+)`\s*[—–-]\s*(.+)/);
+		if (match) {
+			results.push({
+				file: match[1],
+				line: Number(match[2]),
+				symbol: match[3],
+				note: match[4].trim(),
+			});
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Validate that compressed prose preserves structural elements from original.
+ * Returns list of specific issues (empty = valid).
+ */
+export function validateCompressionPreservation(original: string, compressed: string): string[] {
+	const issues: string[] = [];
+
+	// Check code blocks preserved
+	const origBlocks = original.match(makeFencedCodeRe()) ?? [];
+	const compBlocks = compressed.match(makeFencedCodeRe()) ?? [];
+	if (origBlocks.length !== compBlocks.length) {
+		issues.push(`Code block count: ${origBlocks.length} → ${compBlocks.length}`);
+	}
+	for (let i = 0; i < Math.min(origBlocks.length, compBlocks.length); i++) {
+		if (origBlocks[i] !== compBlocks[i]) {
+			issues.push(`Code block ${i + 1} content changed`);
+		}
+	}
+
+	// Check URLs preserved
+	const origUrls = new Set(original.match(makeUrlRe()) ?? []);
+	const compUrls = new Set(compressed.match(makeUrlRe()) ?? []);
+	for (const url of origUrls) {
+		if (!compUrls.has(url)) {
+			issues.push(`URL lost: ${url.slice(0, 60)}...`);
+		}
+	}
+
+	// Check inline code preserved
+	const origInline = original.match(makeInlineCodeRe()) ?? [];
+	const compInline = compressed.match(makeInlineCodeRe()) ?? [];
+	const origInlineSet = new Set(origInline);
+	const compInlineSet = new Set(compInline);
+	for (const code of origInlineSet) {
+		if (!compInlineSet.has(code)) {
+			issues.push(`Inline code lost: ${code}`);
+		}
+	}
+
+	// Check headings preserved
+	const origHeadings = original.match(makeHeadingRe()) ?? [];
+	const compHeadings = compressed.match(makeHeadingRe()) ?? [];
+	if (origHeadings.length !== compHeadings.length) {
+		issues.push(`Heading count: ${origHeadings.length} → ${compHeadings.length}`);
+	}
+
+	return issues;
+}

package/src/runtime/parallel-utils.ts

@@ -58,6 +58,63 @@ export async function mapConcurrent<T, R>(items: T[], limit: number, fn: (item:
 	return results;
 }
 
+/**
+ * Phase 6: mapConcurrent with AbortSignal and fail-fast support.
+ * On abort: returns partial results (may contain undefined entries).
+ * On error: throws immediately (fail-fast) and cancels remaining work.
+ */
+export async function mapConcurrentWithSignal<T, R>(
+	items: T[],
+	limit: number,
+	fn: (item: T, i: number, signal: AbortSignal) => Promise<R>,
+	signal?: AbortSignal,
+): Promise<{ results: (R | undefined)[]; aborted: boolean }> {
+	const safeLimit = Math.max(1, Math.floor(limit) || 1);
+	const results: (R | undefined)[] = new Array(items.length);
+	let next = 0;
+	let aborted = false;
+
+	const abortController = new AbortController();
+	const workerSignal = signal
+		? AbortSignal.any([signal, abortController.signal])
+		: abortController.signal;
+
+	let rejectFirst: (error: unknown) => void;
+	const firstErrorPromise = new Promise<never>((_, reject) => {
+		rejectFirst = reject;
+	});
+
+	const worker = async (): Promise<void> => {
+		while (!workerSignal.aborted) {
+			const i = next++;
+			if (i >= items.length) return;
+			try {
+				results[i] = await fn(items[i], i, workerSignal);
+			} catch (error) {
+				if (!workerSignal.aborted) {
+					abortController.abort();
+					rejectFirst(error);
+					throw error;
+				}
+			}
+		}
+	};
+
+	const workers = Array.from({ length: Math.min(safeLimit, items.length) }, () => worker());
+
+	try {
+		await Promise.race([Promise.all(workers), firstErrorPromise]);
+	} catch (error) {
+		if (signal?.aborted) {
+			aborted = true;
+			return { results, aborted };
+		}
+		throw error;
+	}
+
+	return { results, aborted: signal?.aborted ?? false };
+}
+
 export interface ParallelTaskResult {
 	agent: string;
 	taskIndex?: number;

package/src/runtime/parent-guard.ts

@@ -0,0 +1,80 @@
+/**
+ * Parent liveness guard for pi-crew worker processes.
+ *
+ * Workers call `startParentGuard(parentPid)` at startup. A lightweight
+ * interval checks if the parent PID is still alive. When the parent dies
+ * (SIGKILL, crash, power loss, terminal close), the worker self-terminates
+ * immediately — no sentinel process needed.
+ *
+ * Note: `process.kill(pid, 0)` works on both Unix and Windows in Node.js
+ * for checking process existence. On Windows, it may throw for processes
+ * owned by other users (permission error), but correctly detects dead PIDs.
+ *
+ * Usage in worker entry points:
+ * ```ts
+ * const parentPid = Number(process.env.PI_CREW_PARENT_PID);
+ * if (parentPid > 0) startParentGuard(parentPid);
+ * ```
+ */
+
+const POLL_INTERVAL_MS = 3_000;
+
+let guardInterval: ReturnType<typeof setInterval> | undefined;
+
+function isPidAlive(pid: number): boolean {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function selfTerminate(parentPid: number): never {
+	// Best-effort: try to log why we're dying
+	try {
+		if (typeof process.stderr?.write === "function") {
+			process.stderr.write(`[pi-crew] Parent process ${parentPid} is dead — self-terminating worker ${process.pid}\n`);
+		}
+	} catch {
+		// Ignore
+	}
+	process.exit(124); // 124 = "parent died" exit code
+}
+
+/**
+ * Start a lightweight poll that checks if the parent process is still alive.
+ * If the parent dies, this worker exits immediately with code 124.
+ *
+ * The interval is `unref()`'d so it doesn't keep the event loop alive
+ * on its own — but if the worker has other work (LLM calls, tool execution),
+ * the check continues running in the background.
+ */
+export function startParentGuard(parentPid: number): void {
+	if (!parentPid || !Number.isFinite(parentPid) || parentPid <= 0) return;
+
+	// Immediate check — if parent is already dead, don't even start
+	if (!isPidAlive(parentPid)) {
+		selfTerminate(parentPid);
+	}
+
+	guardInterval = setInterval(() => {
+		if (!isPidAlive(parentPid)) {
+			if (guardInterval) clearInterval(guardInterval);
+			selfTerminate(parentPid);
+		}
+	}, POLL_INTERVAL_MS);
+
+	guardInterval.unref();
+}
+
+/**
+ * Stop the parent guard. Called when the worker finishes normally
+ * and doesn't need to watch the parent anymore.
+ */
+export function stopParentGuard(): void {
+	if (guardInterval) {
+		clearInterval(guardInterval);
+		guardInterval = undefined;
+	}
+}

package/src/runtime/pi-args.ts

@@ -15,6 +15,7 @@ export interface BuildPiWorkerArgsInput {
 	model?: string;
 	sessionEnabled?: boolean;
 	maxDepth?: number;
+	skillPaths?: string[];
 	env?: NodeJS.ProcessEnv;
 }
 
@@ -24,10 +25,16 @@ export interface BuildPiWorkerArgsResult {
 	tempDir?: string;
 }
 
+function isValidThinkingLevel(value: string | undefined): value is string {
+	return value !== undefined && THINKING_LEVELS.includes(value);
+}
+
 export function applyThinkingSuffix(model: string | undefined, thinking: string | undefined): string | undefined {
 	if (!model || !thinking || thinking === "off") return model;
 	const colonIdx = model.lastIndexOf(":");
-	if (colonIdx !== -1 && THINKING_LEVELS.includes(model.substring(colonIdx + 1))) return model;
+	if (colonIdx !== -1 && isValidThinkingLevel(model.substring(colonIdx + 1))) return model;
+	// Invalid config values fall back to Pi's default thinking behavior.
+	if (!isValidThinkingLevel(thinking)) return model;
 	return `${model}:${thinking}`;
 }
 
@@ -54,8 +61,15 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 	const args = ["--mode", "json", "-p"];
 	if (input.sessionEnabled === false) args.push("--no-session");
 
-	const model = applyThinkingSuffix(input.model ?? input.agent.model, input.agent.thinking);
-	if (model) args.push("--model", model);
+	const resolvedModel = input.model ?? input.agent.model;
+	if (resolvedModel) {
+		const modelWithThinking = applyThinkingSuffix(resolvedModel, input.agent.thinking);
+		if (modelWithThinking) args.push("--model", modelWithThinking);
+	}
+	// When no model resolved, pass thinking separately so Pi can apply it to the inherited parent model.
+	if (!resolvedModel && input.agent.thinking && input.agent.thinking !== "off" && isValidThinkingLevel(input.agent.thinking)) {
+		args.push("--thinking", input.agent.thinking);
+	}
 
 	if (input.agent.tools?.length) args.push("--tools", input.agent.tools.join(","));
 	if (input.agent.extensions !== undefined) {
@@ -65,6 +79,7 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		args.push("--extension", PROMPT_RUNTIME_EXTENSION_PATH);
 	}
 	if (!input.agent.inheritSkills) args.push("--no-skills");
+	for (const skillPath of input.skillPaths ?? []) args.push("--skill", skillPath);
 
 	let tempDir: string | undefined;
 	if (input.agent.systemPrompt) {