pi-crew 0.8.13 → 0.9.0

package/src/extension/team-tool/workflow-manage.ts

@@ -0,0 +1,194 @@
+/**
+ * team-tool/workflow-manage.ts — Handlers for the 5 workflow-management actions (P3).
+ *
+ * Plan: 07-PLAN.md v3 P3 + §0c C3 (destructive-gate, NOT autonomous-policy) + C5 (paths).
+ *
+ * Actions:
+ *   - workflow-create : write a .dwf.ts from params.config.script. SECURITY: gated by
+ *                       destructive-gate.ts (confirm:true required) + path-allowlist
+ *                       (resolveRealContainedPath) + content validation. NEVER auto-invoked
+ *                       by the agent (the gate enforces this).
+ *   - workflow-get    : return a workflow's source/metadata (read-only).
+ *   - workflow-list   : list all workflows incl. runtime discriminator (extends existing list).
+ *   - workflow-save   : persist an ephemeral script as a named reusable workflow.
+ *   - workflow-delete : remove a dynamic workflow file (confirm-gated).
+ */
+
+import { readFileSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { dirname, join, basename } from "node:path";
+import { result, type TeamContext } from "./context.ts";
+import { assertSafePathId, resolveRealContainedPath } from "../../utils/safe-paths.ts";
+import { projectCrewRoot, userPiRoot, packageRoot } from "../../utils/paths.ts";
+import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workflows.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+
+/** The 3 allowed bases for dynamic-workflow scripts (§0c C5). */
+function allowedWorkflowDirs(cwd: string): string[] {
+	// Fix round-6: align with discoverWorkflows (which reads userPiRoot/workflows, NOT
+	// userCrewRoot/workflows). The old userCrewRoot path silently orphaned user-scope workflows.
+	return [
+		join(projectCrewRoot(cwd), "workflows"),
+		join(userPiRoot(), "workflows"),
+		join(packageRoot(), "workflows"),
+	];
+}
+
+/** Best-effort ADVISORY content check (review H-3): trivially bypassable
+ * (require('child'+'_process'), globalThis.process.mainModule.require, dynamic import,
+ *  String.fromCharCode, etc.). This is NOT a security boundary — it catches only
+ *  the most obvious accidental violations. The real boundary is the path-allowlist
+ *  + commit-review trust model. Do NOT rely on this for security. */
+const FORBIDDEN_PATTERNS = [
+	/require\s*\(\s*['"]child_process['"]/,
+	/\bprocess\.exit\s*\(/,
+	/import\s+.*['"]net['"]/,
+	/import\s+.*['"]http['"]/,
+	/import\s+.*['"]https['"]/,
+	/eval\s*\(\s*new\s+Function/,
+];
+
+function validateScriptContent(content: string): string | undefined {
+	for (const pattern of FORBIDDEN_PATTERNS) {
+		if (pattern.test(content)) {
+			return `Script content matches a forbidden pattern (${pattern.source}). Dynamic workflows must not spawn processes, exit, or make network calls directly — use ctx.agent().`;
+		}
+	}
+	return undefined;
+}
+
+/** Resolve a workflow name + scope to a safe write path inside an allowed dir. */
+function resolveWorkflowWritePath(cwd: string, name: string, scope: "user" | "project" = "project"): string {
+	assertSafePathId("workflowName", name);
+	// Fix round-6: user scope must use userPiRoot/workflows (matches discovery), not userCrewRoot.
+	const base = scope === "user" ? join(userPiRoot(), "workflows") : join(projectCrewRoot(cwd), "workflows");
+	return resolveRealContainedPath(base, `${name}.dwf.ts`);
+}
+
+export function handleWorkflowCreate(params: TeamToolParamsValue, ctx: TeamContext): ReturnType<typeof result> {
+	// SECURITY (§0c C3): the destructive-gate.ts set enforces confirm:true BEFORE this handler
+	// runs (the run is blocked at the tool_call layer if confirm is missing). We re-check here
+	// as defense-in-depth in case the gate is bypassed.
+	if (params.confirm !== true) {
+		return result("workflow-create is a new arbitrary-code-execution surface and requires confirm:true. Add the action to DESTRUCTIVE_TEAM_ACTIONS (destructive-gate.ts) so the runtime gate enforces this.", { action: "workflow-create", status: "error" }, true);
+	}
+	const name = params.config?.name as string | undefined;
+	const script = params.config?.script as string | undefined;
+	if (!name || typeof name !== "string") {
+		return result("workflow-create requires config.name (the workflow name, path-safe).", { action: "workflow-create", status: "error" }, true);
+	}
+	if (!script || typeof script !== "string") {
+		return result("workflow-create requires config.script (the .dwf.ts source).", { action: "workflow-create", status: "error" }, true);
+	}
+	const validationError = validateScriptContent(script);
+	if (validationError) {
+		return result(`workflow-create rejected: ${validationError}`, { action: "workflow-create", status: "error" }, true);
+	}
+	try {
+		const scope = (params.scope === "user" ? "user" : "project") as "user" | "project";
+		const filePath = resolveWorkflowWritePath(ctx.cwd, name, scope);
+		writeFileSync(filePath, script, "utf-8");
+		return result(`Dynamic workflow '${name}' created at ${filePath}.\n\nIt is now runnable via: team action='run' workflow='${name}' goal='...'\n/scripts are commit-reviewed (postinstall-equivalent trust — see docs/dynamic-workflows.md).`, { action: "workflow-create", status: "ok", data: { name, filePath, scope } }, false);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return result(`workflow-create failed: ${message}`, { action: "workflow-create", status: "error" }, true);
+	}
+}
+
+export function handleWorkflowGet(params: TeamToolParamsValue, ctx: TeamContext): ReturnType<typeof result> {
+	const name = (params.config?.name as string | undefined) ?? params.workflow;
+	if (!name) return result("workflow-get requires config.name or workflow.", { action: "workflow-get", status: "error" }, true);
+	const wf = allWorkflows(discoverWorkflows(ctx.cwd)).find((w) => w.name === name);
+	if (!wf) return result(`Workflow '${name}' not found.`, { action: "workflow-get", status: "error" }, true);
+	const isDynamic = wf.runtime === "dynamic";
+	let source = "(static workflow — no script source)";
+	if (isDynamic && wf.filePath && existsSync(wf.filePath)) {
+		try {
+			source = readFileSync(wf.filePath, "utf-8").slice(0, 8000);
+		} catch (error) {
+			logInternalError("workflow-manage.get", error, `filePath=${wf.filePath}`);
+		}
+	}
+	return result(
+		[
+			`Workflow: ${wf.name} [${isDynamic ? "dynamic" : "static"}]`,
+			`  description: ${wf.description}`,
+			`  source: ${wf.source}`,
+			`  filePath: ${wf.filePath}`,
+			isDynamic ? `  dynamicScript: ${wf.dynamicScript}` : `  steps: ${wf.steps.length}`,
+			"",
+			isDynamic ? "Script source:" : "",
+			isDynamic ? "```" : "",
+			isDynamic ? source : "",
+			isDynamic ? "```" : "",
+		].filter(Boolean).join("\n"),
+		{ action: "workflow-get", status: "ok", data: { name: wf.name, runtime: wf.runtime ?? "static", filePath: wf.filePath } },
+		false,
+	);
+}
+
+export function handleWorkflowList(params: TeamToolParamsValue, ctx: TeamContext): ReturnType<typeof result> {
+	const workflows = allWorkflows(discoverWorkflows(ctx.cwd));
+	if (workflows.length === 0) return result("No workflows found.", { action: "workflow-list", status: "ok" }, false);
+	const lines = workflows.map((w) => {
+		const tag = w.runtime === "dynamic" ? "[dynamic]" : "[static] ";
+		const detail = w.runtime === "dynamic" ? w.dynamicScript ?? w.filePath : `${w.steps.length} steps`;
+		return `  ${tag} ${w.name.padEnd(20)} ${detail}`;
+	});
+	return result(`Workflows (${workflows.length}):\n${lines.join("\n")}`, { action: "workflow-list", status: "ok", data: { count: workflows.length, workflows: workflows.map((w) => ({ name: w.name, runtime: w.runtime ?? "static" })) } }, false);
+}
+
+export function handleWorkflowSave(params: TeamToolParamsValue, ctx: TeamContext): ReturnType<typeof result> {
+	// H-1 (review): workflow-save writes an arbitrary .dwf.ts (ACE-equivalent) — gate it
+	// via destructive-gate.ts confirm:true (now in DESTRUCTIVE_TEAM_ACTIONS) + re-check here.
+	if (params.confirm !== true) {
+		return result("workflow-save writes an executable .dwf.ts and requires confirm:true (gated by destructive-gate.ts).", { action: "workflow-save", status: "error" }, true);
+	}
+	// workflow-save: persist an ephemeral run's script as a named reusable workflow.
+	// Reads the source from config.script (the caller provides what to save).
+	const name = params.config?.name as string | undefined;
+	const script = params.config?.script as string | undefined;
+	if (!name || !script) return result("workflow-save requires config.name + config.script.", { action: "workflow-save", status: "error" }, true);
+	const validationError = validateScriptContent(script);
+	if (validationError) return result(`workflow-save rejected: ${validationError}`, { action: "workflow-save", status: "error" }, true);
+	try {
+		const filePath = resolveWorkflowWritePath(ctx.cwd, name, "project");
+		writeFileSync(filePath, script, "utf-8");
+		return result(`Saved dynamic workflow '${name}' → ${filePath}.`, { action: "workflow-save", status: "ok", data: { name, filePath } }, false);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return result(`workflow-save failed: ${message}`, { action: "workflow-save", status: "error" }, true);
+	}
+}
+
+export function handleWorkflowDelete(params: TeamToolParamsValue, ctx: TeamContext): ReturnType<typeof result> {
+	// workflow-delete is destructive (removes a file) — gated by destructive-gate.ts confirm:true.
+	if (params.confirm !== true) {
+		return result("workflow-delete requires confirm:true (gated by destructive-gate.ts).", { action: "workflow-delete", status: "error" }, true);
+	}
+	const name = (params.config?.name as string | undefined) ?? params.workflow;
+	if (!name) return result("workflow-delete requires config.name.", { action: "workflow-delete", status: "error" }, true);
+	const wf = allWorkflows(discoverWorkflows(ctx.cwd)).find((w) => w.name === name);
+	if (!wf) return result(`Workflow '${name}' not found.`, { action: "workflow-delete", status: "error" }, true);
+	if (wf.runtime !== "dynamic") return result(`Workflow '${name}' is not a dynamic workflow (only .dwf.ts files can be deleted via this action).`, { action: "workflow-delete", status: "error" }, true);
+	try {
+		assertSafePathId("workflowName", name);
+		// Verify the file is inside an allowed dir before deleting.
+		const allowed = allowedWorkflowDirs(ctx.cwd);
+		const contained = allowed.some((base) => {
+			try {
+				return resolveRealContainedPath(base, wf.filePath) === wf.filePath;
+			} catch {
+				return false;
+			}
+		});
+		if (!contained) return result(`Refusing to delete '${wf.filePath}': not inside an allowed workflows directory.`, { action: "workflow-delete", status: "error" }, true);
+		rmSync(wf.filePath, { force: true });
+		return result(`Deleted dynamic workflow '${name}' (${wf.filePath}).`, { action: "workflow-delete", status: "ok", data: { name, filePath: wf.filePath } }, false);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return result(`workflow-delete failed: ${message}`, { action: "workflow-delete", status: "error" }, true);
+	}
+}
+
+void dirname; // (import kept for future expansion; currently unused)

package/src/extension/team-tool.ts

@@ -125,6 +125,14 @@ import {
 	handleAutoSummarizeOn,
 	handleAutoSummarizeStatus,
 } from "./team-tool/auto-summarize.ts";
+import { handleGoal } from "./team-tool/goal.ts";
+import {
+	handleWorkflowCreate,
+	handleWorkflowGet,
+	handleWorkflowList,
+	handleWorkflowSave,
+	handleWorkflowDelete,
+} from "./team-tool/workflow-manage.ts";
 import {
 	type CacheControlDeps,
 	invalidateSnapshot,
@@ -1237,6 +1245,18 @@ export async function handleTeamTool(
 					return handleAnchorStatus(params, ctx);
 			}
 		}
+		case "goal":
+			return handleGoal(params, ctx);
+		case "workflow-create":
+			return handleWorkflowCreate(params, ctx);
+		case "workflow-get":
+			return handleWorkflowGet(params, ctx);
+		case "workflow-list":
+			return handleWorkflowList(params, ctx);
+		case "workflow-save":
+			return handleWorkflowSave(params, ctx);
+		case "workflow-delete":
+			return handleWorkflowDelete(params, ctx);
 		case "auto-summarize":
 		case "auto_boomerang": {
 			const subAction =

package/src/hooks/types.ts

@@ -12,7 +12,9 @@ export type HookName =
 	| "session_before_switch"
 	| "session_after_connect"
 	| "session_after_disconnect"
-	| "run_recovery";
+	| "run_recovery"
+	| "before_goal_step"
+	| "before_goal_abort";
 
 /**
  * Hook exit codes inspired by claude-mem's lifecycle architecture:

package/src/runtime/async-runner.ts

@@ -115,14 +115,22 @@ export function getBackgroundRunnerCommand(
 	// defaults to ~1.5GB on 64-bit systems, which combined with jiti compilation
 	// and child processes can exhaust system memory.
 	const memoryLimit = "--max-old-space-size=512";
+	// Phase 1.5 #3 (RFC 17): opt-in V8 diagnostic report on fatal error. Writes
+	// a report file next to the manifest when the process dies abnormally.
+	// Crucial for diagnosing the non-deterministic multi-step goal-wrap crash
+	// (commit a9f6e09) — gives us native stack, environment, and load info that
+	// application-level signal handlers cannot capture.
+	const reportFlags = process.env.PI_CREW_BG_REPORT_ON_FATAL === "1" || process.env.PI_TEAMS_BG_REPORT_ON_FATAL === "1"
+		? ["--report-on-fatalerror", "--report-compact", `--report-directory=${path.dirname(runnerPath)}`]
+		: [];
 	if (loader.kind === "jiti") {
 		return {
-			args: [memoryLimit, "--trace-uncaught", "--import", pathToFileURL(loader.path).href, runnerPath, "--cwd", cwd, "--run-id", runId],
+			args: [memoryLimit, ...reportFlags, "--trace-uncaught", "--import", pathToFileURL(loader.path).href, runnerPath, "--cwd", cwd, "--run-id", runId],
 			loader: "jiti",
 		};
 	}
 	return {
-		args: [memoryLimit, "--experimental-strip-types", runnerPath, "--cwd", cwd, "--run-id", runId],
+		args: [memoryLimit, ...reportFlags, "--experimental-strip-types", runnerPath, "--cwd", cwd, "--run-id", runId],
 		loader: "strip-types",
 	};
 }
@@ -198,6 +206,20 @@ export async function spawnBackgroundTeamRun(manifest: TeamRunManifest): Promise
 			"PI_TEAMS_PI_BIN",
 			"PI_TEAMS_MOCK_CHILD_PI",
 			"PI_CREW_ALLOW_MOCK",
+			// Phase 1.5: worker-thread atomic writer opt-in (RFC 15).
+			"PI_CREW_WORKER_ATOMIC_WRITER",
+			"PI_TEAMS_WORKER_ATOMIC_WRITER",
+			// Phase 1.5 #1: verification env sanitization opt-in (RFC 13 §6).
+			"PI_CREW_VERIFICATION_SANITIZE_ENV",
+			"PI_TEAMS_VERIFICATION_SANITIZE_ENV",
+			"PI_CREW_VERIFICATION_PRESERVE_ENV",
+			"PI_TEAMS_VERIFICATION_PRESERVE_ENV",
+			// Phase 1.5 #2: verification git-worktree sandbox opt-in (RFC 16).
+			"PI_CREW_VERIFICATION_WORKTREE",
+			"PI_TEAMS_VERIFICATION_WORKTREE",
+			// Phase 1.5 #3: V8 diagnostic report on fatal error (RFC 17 — investigation).
+			"PI_CREW_BG_REPORT_ON_FATAL",
+			"PI_TEAMS_BG_REPORT_ON_FATAL",
 		],
 	});
 	// FIX: removed delete workarounds — with explicit allowlist, these vars

package/src/runtime/background-runner.ts

@@ -537,6 +537,47 @@ async function main(): Promise<void> {
 			const fd = fs.openSync(manifest.eventsPath, "a");
 			try { fs.fsyncSync(fd); } finally { try { fs.closeSync(fd); } catch { /* best-effort */ } }
 		} catch { /* best-effort */ } // FORCE flush so we see this before death
+		// Fix round-4 CRITICAL: goal-loop and dynamic-workflow manifests use SYNTHETIC
+		// team/workflow names not in discoverTeams/discoverWorkflows. The team+workflow
+		// lookup below would throw "Team not found" BEFORE the runKind switch, making the
+		// goal feature unreachable from background. Short-circuit the new runKinds here.
+		process.env.PI_CREW_BACKGROUND_MODE = "1";
+		let earlyResult: { manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined;
+		let result: { manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined;
+		if (manifest.runKind === "goal-loop" || manifest.runKind === "dynamic-workflow") {
+			debugLog(`[background-runner] short-circuiting ${manifest.runKind} (synthetic team/workflow)`,
+			);
+			if (manifest.runKind === "goal-loop") {
+				const { runGoalLoop } = await import("./goal-loop-runner.ts");
+				const { GoalStore } = await import("./goal-state-store.ts");
+				const { discoverAgents, allAgents } = await import("../agents/discover-agents.ts");
+				const store = new GoalStore(manifest.cwd);
+				const goalState = store.load(manifest.runId);
+				if (!goalState) throw new Error(`runKind="goal-loop" but GoalLoopState '${manifest.runId}' not found (cwd=${manifest.cwd})`);
+				const goalResult = await runGoalLoop({ goalState, manifest, signal: abortController.signal, deps: { discoverAgents: (c: string) => allAgents(discoverAgents(c)) } });
+				// Fix P1-1 + round-6 #5: persist terminal status reflecting the goal's actual outcome,
+				// not a blanket 'completed'. Map goal state → manifest status.
+				const goalStatusToRunStatus: Record<string, TeamRunManifest["status"]> = {
+					achieved: "completed", max_turns: "completed", budget_exceeded: "completed",
+					blocked: "blocked", cancelled: "cancelled", paused: "blocked", running: "running",
+				};
+				const runStatus = goalStatusToRunStatus[goalResult.goalState.state] ?? "completed";
+				const finalGoalManifest: TeamRunManifest = { ...goalResult.manifest, status: runStatus, updatedAt: new Date().toISOString() };
+				saveRunManifest(finalGoalManifest);
+				earlyResult = { manifest: finalGoalManifest, tasks: goalResult.tasks };
+			} else {
+				const { runDynamicWorkflow } = await import("./dynamic-workflow-runner.ts");
+				const { allWorkflows, discoverWorkflows } = await import("../workflows/discover-workflows.ts");
+				const wf = allWorkflows(discoverWorkflows(manifest.cwd)).find((w) => w.name === manifest.workflow);
+				if (!wf || wf.runtime !== "dynamic" || !wf.dynamicScript) throw new Error(`runKind="dynamic-workflow" but workflow '${manifest.workflow}' is not dynamic (runId=${manifest.runId})`);
+				const dwfResult = await runDynamicWorkflow({ manifest, workflow: wf as import("../workflows/workflow-config.ts").DynamicWorkflowConfig, signal: abortController.signal });
+				saveRunManifest(dwfResult.manifest);
+				earlyResult = dwfResult;
+			}
+			console.log(`[background-runner] ${manifest.runKind} returned, status=${earlyResult.manifest.status}`);
+			result = earlyResult;
+		}
+		if (!earlyResult) {
 		debugLog(`[background-runner] calling directTeamAndWorkflowFromRun`,
 		);
 		const direct = directTeamAndWorkflowFromRun(manifest, tasks, agents);
@@ -612,24 +653,31 @@ async function main(): Promise<void> {
 		// NOTE: abortController is already created above (before heartbeat/interrupt guard start)
 		// so it is available here and its signal is passed through to executeTeamRun → child-pi.
 
-		debugLog(`[background-runner] calling executeTeamRun`);
-		let result;
+		debugLog(`[background-runner] dispatching runKind=${manifest.runKind ?? "team-run"}`);
 		try {
-			result = await executeTeamRun({
-				manifest,
-				tasks,
-				team,
-				workflow,
-				agents,
-				executeWorkers,
-				limits: runConfig.limits,
-				runtime,
-				runtimeConfig: runConfig.runtime,
-				skillOverride: manifest.skillOverride,
-				reliability: runConfig.reliability,
-				workspaceId: manifest.ownerSessionId ?? manifest.cwd,
-				signal: abortController.signal,
-			});
+			// Fix round-4: goal-loop/dynamic-workflow handled by the short-circuit above.
+			// This switch now only carries the traditional team-run path.
+			switch (manifest.runKind ?? "team-run") {
+				default: {
+					// Existing "team-run" path — unchanged behavior.
+					result = await executeTeamRun({
+						manifest,
+						tasks,
+						team,
+						workflow,
+						agents,
+						executeWorkers,
+						limits: runConfig.limits,
+						runtime,
+						runtimeConfig: runConfig.runtime,
+						skillOverride: manifest.skillOverride,
+						reliability: runConfig.reliability,
+						workspaceId: manifest.ownerSessionId ?? manifest.cwd,
+						signal: abortController.signal,
+					});
+					break;
+				}
+			}
 			console.log(`[background-runner] executeTeamRun returned, status=${result.manifest.status}`,
 			);
 		} catch (execError) {
@@ -639,8 +687,9 @@ async function main(): Promise<void> {
 			);
 			throw execError;
 		}
-		manifest = result.manifest;
-		tasks = result.tasks;
+		} // close if (!earlyResult) — team-run setup+execute done; earlyResult path skips to here
+		manifest = result!.manifest;
+		tasks = result!.tasks;
 		appendEvent(manifest.eventsPath, {
 			type: "async.completed",
 			runId: manifest.runId,

package/src/runtime/child-pi.ts

@@ -847,7 +847,12 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 					unregisterChildProcess(child.pid);
 				}
 				// Build comprehensive exit error for unexpected exits
-				const isUnexpectedExit = !childExited && !settled && !responseTimeoutHit && !abortRequested;
+				// Round-10 test fix: also require non-zero exit code OR a known abnormal condition.
+				// Previously fired "exited unexpectedly" on every clean exit (code=0) because the
+				// OS-level 'exit' event fires BEFORE pi's 'agent_end' JSON event reaches the line
+				// observer (race). Worker actually succeeded but onLifecycleEvent reported an error.
+				const abnormalExit = code !== 0 && code !== null;
+				const isUnexpectedExit = !childExited && !settled && !responseTimeoutHit && !abortRequested && abnormalExit;
 				const exitError = isUnexpectedExit
 					? new Error(
 						`Child Pi process exited unexpectedly (code=${code ?? "null"} signal=${signal ?? "null"}). `

package/src/runtime/completion-guard.ts

@@ -55,7 +55,7 @@ function isMutatingTool(tool: string, args: unknown): boolean {
 	return false;
 }
 
-function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
+export function collectToolCallsFromEvent(event: unknown): Array<{ tool: string; args?: unknown }> {
 	const record = asRecord(event);
 	if (!record) return [];
 	const calls: Array<{ tool: string; args?: unknown }> = [];