pi-crew 0.9.41 → 0.9.44

package/src/extension/registration/tool-registration.ts

@@ -0,0 +1,50 @@
+/**
+ * Tool registration installer for pi-crew.
+ *
+ * Single entry point that wires every `pi.registerTool(...)` call site
+ * in the extension. Today that means two heavy tools:
+ *   • `team` — the multi-agent orchestration tool (team-tool.ts).
+ *   • subagent tools — agent spawn tool + result-join helpers
+ *     (subagent-tools.ts).
+ *
+ * The actual tool handlers live in `registration/team-tool.ts` and
+ * `registration/subagent-tools.ts` (already extracted); this file is
+ * the orchestrator-level wrapper that calls them with the right deps.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { RegistrationContext } from "./registration-types.ts";
+import { registerSubagentTools } from "./subagent-tools.ts";
+import { registerTeamTool } from "./team-tool.ts";
+
+/**
+ * Register all pi-crew tools on the ExtensionAPI.
+ *
+ * Pulls every dependency the underlying tools need off `ctx`. The
+ * orchestrator guarantees those fields are populated before this call
+ * (see registerPiTeams in ../register.ts).
+ */
+export function registerPiTools(pi: ExtensionAPI, ctx: RegistrationContext): void {
+	registerTeamTool(pi, {
+		foregroundControllers: ctx.foregroundControllers,
+		startForegroundRun: ctx.startForegroundRun,
+		abortForegroundRun: ctx.abortForegroundRun,
+		openLiveSidebar: ctx.openLiveSidebar,
+		getManifestCache: ctx.getManifestCache,
+		getRunSnapshotCache: ctx.getRunSnapshotCache,
+		getMetricRegistry: () => ctx.observabilityState.metricRegistry,
+		widgetState: ctx.widgetState,
+		onJsonEvent: (taskId, runId, event) => {
+			const record = event as Record<string, unknown>;
+			const eventType = typeof record.type === "string" ? record.type : undefined;
+			if (eventType) ctx.lifecycleState.overflowTracker?.feedEvent(taskId, runId, eventType);
+		},
+	});
+	registerSubagentTools(pi, ctx.subagentManager, {
+		ownerSessionGeneration: ctx.captureSessionGeneration,
+		// Subagent options only type-check against `unknown` for ctx; cast
+		// back to ExtensionContext since the subagent tool re-validates.
+		startForegroundRun: (subCtx, runner, runId) =>
+			ctx.startForegroundRun(subCtx as Parameters<typeof ctx.startForegroundRun>[0], runner, runId),
+		batchBarrier: ctx.batchBarrier,
+	});
+}

package/src/extension/registration/wire-cross-extension.ts

@@ -0,0 +1,37 @@
+/**
+ * Cross-extension wiring helper.
+ *
+ * Two small wires:
+ *   • wireRpc — the in-process pi-crew RPC handle (other modules in
+ *     the same extension can subscribe via `pi.events`).
+ *   • wireGlobalRegistry — the cross-extension crew global registry,
+ *     lazily loaded from team-tool.ts (heavy module) and installed under
+ *     `globalThis[Symbol.for("pi-crew:registry")]` so peer extensions
+ *     (e.g., pi-subagents3) can discover pi-crew at runtime.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerPiCrewRpc } from "../cross-extension-rpc.ts";
+import type { RegistrationContext } from "./registration-types.ts";
+
+/** Install both wires on the registration context. */
+export function installCrossExtensionWiring(pi: ExtensionAPI, ctx: RegistrationContext): void {
+	// Wire the in-process RPC handle.
+	const getPiEvents = (): Parameters<typeof registerPiCrewRpc>[0] | undefined => {
+		if (pi && typeof pi === "object" && "events" in pi) {
+			return (pi as { events?: Parameters<typeof registerPiCrewRpc>[0] }).events;
+		}
+		return undefined;
+	};
+	ctx.rpcHandle = registerPiCrewRpc(getPiEvents(), () => ctx.currentCtx);
+
+	// Install the cross-extension crew global registry. Lazy import keeps
+	// team-tool.ts (which pulls in the entire runtime chain) out of the
+	// cold-start module graph.
+	void import("../team-tool.ts").then(({ installCrewGlobalRegistry }) => {
+		const manifestCacheForRegistry = ctx.getManifestCache(ctx.currentCtx?.cwd ?? process.cwd());
+		installCrewGlobalRegistry({
+			manifestCache: manifestCacheForRegistry,
+			cwdProvider: () => ctx.currentCtx?.cwd ?? process.cwd(),
+		});
+	});
+}

package/src/extension/rpc-hmac.ts

@@ -53,6 +53,20 @@ export interface RpcSignaturePayload {
 
 export type RpcSignedPayload = RpcSignaturePayload & { signature: string };
 
+// Process-latched: emit a soft, non-alarming note once per process when an RPC
+// request is actually processed without HMAC. The previous warning was emitted
+// at extension registration (every pi load) and was considered noisy by users
+// who never wire cross-extension RPC. Opt out with PI_CREW_SUPPRESS_RPC_WARNING=1.
+let _rpcHmacSoftInfoEmitted = false;
+function rpcHmacSoftInfoOnce(): void {
+	if (_rpcHmacSoftInfoEmitted) return;
+	_rpcHmacSoftInfoEmitted = true;
+	console.warn(
+		"[pi-crew] PI_CREW_RPC_SECRET not set; cross-extension RPC requests will be accepted without origin authentication. " +
+			"Operation allowlists and session checks still apply. Set PI_CREW_RPC_SECRET or PI_CREW_SUPPRESS_RPC_WARNING=1 to silence this message.",
+	);
+}
+
 // --- Signing -----------------------------------------------------------------
 
 /**
@@ -123,7 +137,13 @@ export function withHmacVerification<P extends { requestId: string }>(
 ): (params: P) => unknown | Promise<unknown> {
 	return (params: P) => {
 		if (!isHmacEnabled()) {
-			// No secret configured → backward compat: allow unsigned
+			// No secret configured → backward compat: allow unsigned.
+			// Emit a soft info note (once per process) only when an actual RPC
+			// request is being processed — the prior registration-time warning
+			// was too noisy for users who never wire cross-extension RPC.
+			if (process.env.PI_CREW_SUPPRESS_RPC_WARNING !== "1") {
+				rpcHmacSoftInfoOnce();
+			}
 			return handler(params);
 		}
 

package/src/extension/run-import.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
 import { type ConflictReport, detectImportConflicts } from "../runtime/delta-conflict.ts";
+import { atomicWriteFile } from "../state/atomic-write.ts";
 import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { assertSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { assertRunBundle } from "./run-bundle-schema.ts";
@@ -116,8 +117,8 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 	for (const target of [targetJson, targetSummary]) {
 		if (fs.existsSync(target) && fs.lstatSync(target).isSymbolicLink()) throw new Error(`Invalid import target: ${target}`);
 	}
-	fs.writeFileSync(targetJson, `${JSON.stringify({ ...raw, importedAt, importedFrom: resolvedPath }, null, 2)}\n`, "utf-8");
-	fs.writeFileSync(
+	atomicWriteFile(targetJson, `${JSON.stringify({ ...raw, importedAt, importedFrom: resolvedPath }, null, 2)}\n`);
+	atomicWriteFile(
 		targetSummary,
 		[
 			`# Imported pi-crew run ${runId}`,
@@ -136,7 +137,6 @@ export function importRunBundle(cwd: string, bundlePath: string, scope: "project
 			),
 			"",
 		].join("\n"),
-		"utf-8",
 	);
 	return {
 		runId,

package/src/extension/team-tool/auto-summarize.ts

@@ -25,14 +25,14 @@ export function handleAutoSummarizeOn(params: TeamToolParamsValue, ctx: TeamCont
 	// Apply config updates if provided
 	if (cfg.threshold !== undefined) {
 		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);
-		if (!isNaN(threshold) && threshold >= 0) {
+		if (!Number.isNaN(threshold) && threshold >= 0) {
 			service.setThreshold(threshold);
 		}
 	}
 
 	if (cfg.minTools !== undefined) {
 		const minTools = typeof cfg.minTools === "number" ? cfg.minTools : parseInt(String(cfg.minTools), 10);
-		if (!isNaN(minTools) && minTools >= 0) {
+		if (!Number.isNaN(minTools) && minTools >= 0) {
 			service.setMinToolsUsed(minTools);
 		}
 	}
@@ -103,14 +103,14 @@ export function handleAutoSummarizeConfig(params: TeamToolParamsValue, ctx: Team
 
 	if (cfg.threshold !== undefined) {
 		const threshold = typeof cfg.threshold === "number" ? cfg.threshold : parseInt(String(cfg.threshold), 10);
-		if (!isNaN(threshold) && threshold >= 0) {
+		if (!Number.isNaN(threshold) && threshold >= 0) {
 			updates.threshold = threshold;
 		}
 	}
 
 	if (cfg.minTools !== undefined) {
 		const minTools = typeof cfg.minTools === "number" ? cfg.minTools : parseInt(String(cfg.minTools), 10);
-		if (!isNaN(minTools) && minTools >= 0) {
+		if (!Number.isNaN(minTools) && minTools >= 0) {
 			updates.minTools = minTools;
 		}
 	}

package/src/extension/team-tool/cancel.ts

@@ -56,7 +56,7 @@ export function abortOwned(runId: string, taskIds: string[] | undefined, ctx: Te
 			continue;
 		}
 		if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") continue;
-		if (foreignRun && !force) {
+		if (foreignRun && force !== true) {
 			result.foreignIds.push(id);
 			continue;
 		}
@@ -92,7 +92,7 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 
 	// Pre-lock ownership check: reject foreign-owned runs unless force is set
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
-	if (foreignRun && !params.force) {
+	if (foreignRun && params.force !== true) {
 		return result(
 			`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
 			{ action: "retry", status: "error", runId: loaded.manifest.runId },
@@ -184,7 +184,7 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 
 	// Pre-lock ownership check: reject foreign-owned runs unless force is set
 	const preCheck = abortOwned(loaded.manifest.runId, undefined, ctx, params.force);
-	if (preCheck.abortedIds.length === 0 && preCheck.foreignIds.length > 0 && !params.force) {
+	if (preCheck.abortedIds.length === 0 && preCheck.foreignIds.length > 0 && params.force !== true) {
 		return result(
 			`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
 			{
@@ -230,7 +230,7 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 	}
 
 	return withRunLockSync(loaded.manifest, () => {
-		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force)
+		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && params.force !== true)
 			return result(
 				`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`,
 				{
@@ -243,7 +243,7 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 
 		// Classify tasks for foreign-aware cancellation
 		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx, params.force);
-		if (abortResult.abortedIds.length === 0 && abortResult.foreignIds.length > 0 && !params.force) {
+		if (abortResult.abortedIds.length === 0 && abortResult.foreignIds.length > 0 && params.force !== true) {
 			return result(
 				`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`,
 				{

package/src/extension/team-tool/chain-executor.ts

@@ -30,6 +30,7 @@ import type { ChainTaskRunner } from "../../runtime/chain-runner.ts";
 import type { Decision, TaskPacket, TaskResult } from "../../runtime/handoff-manager.ts";
 import { readIfSmallWithTee } from "../../runtime/task-output-context.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { atomicWriteFile } from "../../state/atomic-write.ts";
 import { createRunPaths, loadRunManifestById } from "../../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
@@ -361,7 +362,7 @@ export function writeRunFixture(
 	if (opts.resultText) {
 		const resultDir = path.join(paths.artifactsRoot, "results");
 		fs.mkdirSync(resultDir, { recursive: true });
-		fs.writeFileSync(path.join(resultDir, `${taskId}.txt`), opts.resultText, "utf-8");
+		atomicWriteFile(path.join(resultDir, `${taskId}.txt`), opts.resultText);
 		manifest.artifacts.push({
 			kind: "result",
 			path: `results/${taskId}.txt`,
@@ -371,8 +372,8 @@ export function writeRunFixture(
 		});
 	}
 
-	fs.writeFileSync(paths.manifestPath, JSON.stringify(manifest), "utf-8");
-	fs.writeFileSync(paths.tasksPath, JSON.stringify(tasks ?? []), "utf-8");
-	fs.writeFileSync(paths.eventsPath, "", "utf-8");
+	atomicWriteFile(paths.manifestPath, JSON.stringify(manifest));
+	atomicWriteFile(paths.tasksPath, JSON.stringify(tasks ?? []));
+	atomicWriteFile(paths.eventsPath, "");
 	return manifest;
 }

package/src/extension/team-tool/context.ts

@@ -135,5 +135,15 @@ export function buildParentContext(ctx: TeamContext): string | undefined {
 
 export function configRecord(config: unknown): Record<string, unknown> {
 	if (!config || typeof config !== "object" || Array.isArray(config)) return {};
-	return config as Record<string, unknown>;
+	// AUDIT-07 defense-in-depth: filter prototype-pollution keys. Callers (api, doctor,
+	// lifecycle-actions, intent-policy, team-tool) pass `params.config` from the team-tool
+	// invocation which is NOT sanitized by the same loadConfig/sanitizeObject path.
+	const obj = config as Record<string, unknown>;
+	const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+	const safe: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(obj)) {
+		if (DANGEROUS_KEYS.has(k)) continue;
+		safe[k] = v;
+	}
+	return safe;
 }

package/src/extension/team-tool/doctor.ts

@@ -10,6 +10,7 @@ import { getRuntimeWarmupStatus } from "../../runtime/runtime-warmup.ts";
 import { formatZombieReport, scanZombieSubagents } from "../../runtime/zombie-scanner.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { TeamToolParams } from "../../schema/team-tool-schema.ts";
+import { atomicWriteFile } from "../../state/atomic-write.ts";
 import { allTeams, discoverTeams } from "../../teams/discover-teams.ts";
 import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
 import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workflows.ts";
@@ -98,7 +99,7 @@ function checkWritableDir(dir: string): { ok: boolean; detail: string } {
 		// fs.accessSync(W_OK) is unreliable on Windows; verify by writing a temp file.
 		const probePath = `${dir}/.pi-crew-write-test`;
 		try {
-			fs.writeFileSync(probePath, "ok", "utf-8");
+			atomicWriteFile(probePath, "ok");
 			fs.rmSync(probePath, { force: true });
 		} catch {
 			return {

package/src/extension/team-tool/goal-wrap.ts

@@ -152,7 +152,7 @@ export function shouldGoalWrap(
 			message?: string;
 	  } {
 	const wc = readGoalWrapConfig(cwd, workflow.name);
-	if (!wc || wc.enabled !== true) {
+	if (wc?.enabled !== true) {
 		return { enabled: false, reason: "config-off" };
 	}
 	const validationError = validateGoalWrapConfig(wc);
@@ -181,7 +181,7 @@ export async function startGoalWrappedRun(
 ): Promise<ReturnType<typeof result>> {
 	const cwd = ctx.cwd;
 	const wc = readGoalWrapConfig(cwd, workflow.name);
-	if (!wc || wc.enabled !== true) {
+	if (wc?.enabled !== true) {
 		return result(
 			`goal-wrap is not enabled for workflow '${workflow.name}' in .crew/config.json.`,
 			{ action: "run", status: "error" },

package/src/extension/team-tool/goal.ts

@@ -16,7 +16,7 @@
 
 import { GoalStore } from "../../runtime/goal-state-store.ts";
 import { snapshotManifests } from "../../runtime/verification-integrity.ts";
-import { acquireWorkspaceLock, isWorkspaceBusy, type WorkspaceLockHandle } from "../../runtime/workspace-lock.ts";
+import { isWorkspaceBusy } from "../../runtime/workspace-lock.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEvent } from "../../state/event-log.ts";
 import { createRunPaths, saveRunManifestAsync } from "../../state/state-store.ts";

package/src/extension/team-tool/handle-schedule.ts

@@ -1,6 +1,6 @@
 import * as crypto from "node:crypto";
 import { humanizeSchedule, nextRunTime, parseSchedule } from "../../runtime/scheduler.ts";
-import { loadCrewSettings, saveCrewSettings } from "../../runtime/settings-store.ts";
+import { type CrewSettings, updateCrewSettings } from "../../runtime/settings-store.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
@@ -50,7 +50,14 @@ function buildScheduleSpec(params: ScheduleParams): {
 			scheduleType: "cron" as const,
 		};
 	}
-	if (params.interval !== undefined && params.interval > 0) {
+	if (params.interval !== undefined && (!Number.isFinite(params.interval) || params.interval <= 0)) {
+		throw new Error("interval must be a positive finite number");
+	}
+	if (params.once !== undefined) {
+		const ts = typeof params.once === "number" ? params.once : Date.parse(String(params.once));
+		if (!Number.isFinite(ts)) throw new Error("once must be a valid timestamp");
+	}
+	if (params.interval !== undefined) {
 		const specStr = `${params.interval}ms`;
 		const spec = parseSchedule(specStr);
 		if ("error" in spec) throw new Error(spec.error);
@@ -183,21 +190,16 @@ export function handleSchedule(params: TeamToolParamsValue, ctx: TeamContext): P
 	);
 }
 
+function scheduledJobsOf(settings: CrewSettings): import("../../runtime/scheduler.ts").ScheduledJob[] {
+	return Array.isArray(settings.scheduledJobs) ? (settings.scheduledJobs as import("../../runtime/scheduler.ts").ScheduledJob[]) : [];
+}
+
 function persistScheduledJob(cwd: string, job: import("../../runtime/scheduler.ts").ScheduledJob): void {
 	try {
-		const settings = loadCrewSettings(cwd);
-		const existingJobs: import("../../runtime/scheduler.ts").ScheduledJob[] = Array.isArray(
-			(settings as Record<string, unknown>).scheduledJobs,
-		)
-			? ((settings as Record<string, unknown>).scheduledJobs as import("../../runtime/scheduler.ts").ScheduledJob[])
-			: [];
-		saveCrewSettings(
-			{
-				...settings,
-				scheduledJobs: [...existingJobs, job],
-			} as Parameters<typeof saveCrewSettings>[0],
-			cwd,
-		);
+		updateCrewSettings(cwd, (settings) => ({
+			...settings,
+			scheduledJobs: [...scheduledJobsOf(settings), job],
+		}));
 	} catch {
 		/* best-effort persistence */
 	}
@@ -206,14 +208,10 @@ function persistScheduledJob(cwd: string, job: import("../../runtime/scheduler.t
 /** Update an existing scheduled job in persistent settings. */
 export function persistScheduledJobUpdate(cwd: string, job: import("../../runtime/scheduler.ts").ScheduledJob): void {
 	try {
-		const settings = loadCrewSettings(cwd);
-		const existingJobs: import("../../runtime/scheduler.ts").ScheduledJob[] = Array.isArray(
-			(settings as Record<string, unknown>).scheduledJobs,
-		)
-			? ((settings as Record<string, unknown>).scheduledJobs as import("../../runtime/scheduler.ts").ScheduledJob[])
-			: [];
-		const updated = existingJobs.map((j) => (j.id === job.id ? job : j));
-		saveCrewSettings({ ...settings, scheduledJobs: updated } as Parameters<typeof saveCrewSettings>[0], cwd);
+		updateCrewSettings(cwd, (settings) => ({
+			...settings,
+			scheduledJobs: scheduledJobsOf(settings).map((j) => (j.id === job.id ? job : j)),
+		}));
 	} catch {
 		/* best-effort persistence */
 	}
@@ -222,19 +220,10 @@ export function persistScheduledJobUpdate(cwd: string, job: import("../../runtim
 /** Remove a scheduled job from persistent settings. */
 function persistScheduledJobRemove(cwd: string, jobId: string): void {
 	try {
-		const settings = loadCrewSettings(cwd);
-		const existingJobs: import("../../runtime/scheduler.ts").ScheduledJob[] = Array.isArray(
-			(settings as Record<string, unknown>).scheduledJobs,
-		)
-			? ((settings as Record<string, unknown>).scheduledJobs as import("../../runtime/scheduler.ts").ScheduledJob[])
-			: [];
-		saveCrewSettings(
-			{
-				...settings,
-				scheduledJobs: existingJobs.filter((j) => j.id !== jobId),
-			} as Parameters<typeof saveCrewSettings>[0],
-			cwd,
-		);
+		updateCrewSettings(cwd, (settings) => ({
+			...settings,
+			scheduledJobs: scheduledJobsOf(settings).filter((j) => j.id !== jobId),
+		}));
 	} catch {
 		/* best-effort persistence */
 	}

package/src/extension/team-tool/orchestrate.ts

@@ -4,7 +4,6 @@
  * Parses a plan document and outputs agent chain commands.
  */
 import * as fs from "node:fs";
-import * as path from "node:path";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { resolveContainedPath } from "../../utils/safe-paths.ts";
 import {

package/src/extension/team-tool/parallel-dispatch.ts

@@ -149,6 +149,11 @@ async function spawnSingleTask(
 			team,
 			workflow,
 			goal,
+			// EXT F1: mirror handleRun — without ownerSessionId, the foreign-run check in
+			// cancel/retry/resume (cancel.ts:50: `typeof ownerSessionId === "string"`) is
+			// skipped and any session can cancel/retry parallel-dispatched runs.
+			ownerSessionId: ctx.sessionId,
+			runKind: "team-run",
 		});
 
 		appendEvent(created.manifest.eventsPath, {