pi-crew 0.1.7 → 0.1.8

package/src/runtime/task-runner.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agent-config.ts";
-import type { CrewLimitsConfig } from "../config/config.ts";
+import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
@@ -8,7 +8,7 @@ import { saveRunManifest, saveRunTasks } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
-import { captureWorktreeDiff, prepareTaskWorkspace } from "../worktree/worktree-manager.ts";
+import { captureWorktreeDiff, captureWorktreeDiffStat, prepareTaskWorkspace } from "../worktree/worktree-manager.ts";
 import { buildModelCandidates, formatModelAttemptNote, isRetryableModelFailure, type ModelAttemptSummary } from "./model-fallback.ts";
 import { parsePiJsonOutput, type ParsedPiJsonOutput } from "./pi-json-output.ts";
 import { runChildPi } from "./child-pi.ts";
@@ -19,7 +19,9 @@ import { permissionForRole } from "./role-permission.ts";
 import { collectDependencyOutputContext, renderDependencyOutputContext, writeTaskInputsArtifact, writeTaskSharedOutput } from "./task-output-context.ts";
 import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
 import { parseSessionUsage } from "./session-usage.ts";
-import type { CrewAgentProgress } from "./crew-agent-runtime.ts";
+import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { buildMemoryBlock } from "./agent-memory.ts";
+import { runLiveSessionTask } from "./live-session-runtime.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -29,6 +31,11 @@ export interface TaskRunnerInput {
 	agent: AgentConfig;
 	signal?: AbortSignal;
 	executeWorkers: boolean;
+	runtimeKind?: CrewRuntimeKind;
+	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
 	limits?: CrewLimitsConfig;
 	dependencyContextText?: string;
 }
@@ -57,7 +64,8 @@ function coordinationBridgeInstructions(task: TeamTaskState): string {
 	].join("\n");
 }
 
-function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState): string {
+function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState, agent?: AgentConfig): string {
+	const memoryBlock = agent?.memory ? buildMemoryBlock(agent.name, agent.memory, task.cwd, Boolean(agent.tools?.some((tool) => tool === "write" || tool === "edit"))) : "";
 	return [
 		"# pi-crew Worker Runtime Context",
 		`Run ID: ${manifest.runId}`,
@@ -88,6 +96,7 @@ function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: T
 		task.taskPacket ? renderTaskPacket(task.taskPacket) : "",
 		"",
 		(inputDependencyContext(task) || ""),
+		memoryBlock,
 		"Task:",
 		step.task.replaceAll("{goal}", manifest.goal),
 	].join("\n");
@@ -227,12 +236,13 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		...(dependencyContextText ? { dependencyContextText } : {}),
 	} as TeamTaskState;
 	let tasks = updateTask(input.tasks, task);
+	const runtimeKind = input.runtimeKind ?? (input.executeWorkers ? "child-process" : "scaffold");
 	saveRunTasks(manifest, tasks);
-	upsertCrewAgent(manifest, recordFromTask(manifest, task, input.executeWorkers ? "child-process" : "scaffold"));
-	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
+	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
+	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, runtime: runtimeKind, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
 	const permissionMode = permissionForRole(task.role);
 
-	const prompt = renderTaskPrompt(manifest, input.step, task);
+	const prompt = renderTaskPrompt(manifest, input.step, task, input.agent);
 	const promptArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "prompt",
 		relativePath: `prompts/${task.id}.md`,
@@ -248,7 +258,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	let modelAttempts: ModelAttemptSummary[] | undefined;
 	let parsedOutput: ParsedPiJsonOutput | undefined;
 
-	let startupEvidence = createStartupEvidence({ command: input.executeWorkers ? "pi" : "safe-scaffold", startedAt: new Date(task.startedAt ?? new Date().toISOString()), finishedAt: new Date(), promptSentAt: new Date(task.startedAt ?? new Date().toISOString()), promptAccepted: true, exitCode: 0 });
+	let startupEvidence = createStartupEvidence({ command: runtimeKind === "child-process" ? "pi" : runtimeKind === "live-session" ? "live-session" : "safe-scaffold", startedAt: new Date(task.startedAt ?? new Date().toISOString()), finishedAt: new Date(), promptSentAt: new Date(task.startedAt ?? new Date().toISOString()), promptAccepted: true, exitCode: 0 });
 	const inputsArtifact = writeTaskInputsArtifact(manifest, task, dependencyContext);
 	const coordinationArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
@@ -256,7 +266,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${coordinationBridgeInstructions(task)}\n`,
 		producer: task.id,
 	});
-	if (input.executeWorkers) {
+	if (runtimeKind === "child-process") {
 		const candidates = buildModelCandidates(input.step.model ?? input.agent.model, input.agent.fallbackModels, undefined);
 		const attemptModels = candidates.length > 0 ? candidates : [input.step.model ?? input.agent.model];
 		const logs: string[] = [];
@@ -326,6 +336,55 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				producer: task.id,
 			});
 		}
+	} else if (runtimeKind === "live-session") {
+		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
+		const attemptStartedAt = new Date();
+		const liveResult = await runLiveSessionTask({
+			manifest,
+			task,
+			step: input.step,
+			agent: input.agent,
+			prompt,
+			signal: input.signal,
+			transcriptPath,
+			runtimeConfig: input.runtimeConfig,
+			parentContext: input.parentContext,
+			parentModel: input.parentModel,
+			modelRegistry: input.modelRegistry,
+			onOutput: (text) => appendCrewAgentOutput(manifest, task.id, text),
+			onEvent: (event) => {
+				appendCrewAgentEvent(manifest, task.id, event);
+				task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
+				tasks = updateTask(tasks, task);
+				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { event } });
+			},
+		});
+		startupEvidence = createStartupEvidence({ command: "live-session", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: liveResult.exitCode === 0 && !liveResult.error, stderr: liveResult.stderr, error: liveResult.error, exitCode: liveResult.exitCode });
+		exitCode = liveResult.exitCode;
+		error = liveResult.error || (liveResult.exitCode && liveResult.exitCode !== 0 ? liveResult.stderr || `Live session exited with ${liveResult.exitCode}` : undefined);
+		parsedOutput = { finalText: liveResult.stdout, textEvents: liveResult.stdout ? [liveResult.stdout] : [], jsonEvents: liveResult.jsonEvents, usage: liveResult.usage };
+		if (liveResult.usage) task = { ...task, usage: liveResult.usage, agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage) };
+		resultArtifact = writeArtifact(manifest.artifactsRoot, {
+			kind: "result",
+			relativePath: `results/${task.id}.txt`,
+			content: liveResult.stdout || liveResult.stderr || "(no output)",
+			producer: task.id,
+		});
+		logArtifact = writeArtifact(manifest.artifactsRoot, {
+			kind: "log",
+			relativePath: `logs/${task.id}.log`,
+			content: [`runtime=live-session`, `finalExitCode=${exitCode ?? "null"}`, `jsonEvents=${liveResult.jsonEvents}`, liveResult.usage ? `usage=${JSON.stringify(liveResult.usage)}` : "", "", "STDOUT:", liveResult.stdout, "", "STDERR:", liveResult.stderr].join("\n"),
+			producer: task.id,
+		});
+		if (fs.existsSync(transcriptPath)) {
+			transcriptArtifact = writeArtifact(manifest.artifactsRoot, {
+				kind: "log",
+				relativePath: `transcripts/${task.id}.jsonl`,
+				content: fs.readFileSync(transcriptPath, "utf-8"),
+				producer: task.id,
+			});
+		}
 	} else {
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",
@@ -346,6 +405,12 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: captureWorktreeDiff(workspace.worktreePath),
 		producer: task.id,
 	}) : undefined;
+	const diffStatArtifact = workspace.worktreePath ? writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.diff-stat.json`,
+		content: `${JSON.stringify({ ...captureWorktreeDiffStat(workspace.worktreePath), syntheticPaths: workspace.syntheticPaths ?? [], nodeModulesLinked: workspace.nodeModulesLinked ?? false }, null, 2)}\n`,
+		producer: task.id,
+	}) : undefined;
 
 	task = {
 		...task,
@@ -357,7 +422,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		jsonEvents: parsedOutput?.jsonEvents,
 		agentProgress: error && task.agentProgress?.currentTool ? { ...task.agentProgress, failedTool: task.agentProgress.currentTool } : task.agentProgress,
 		error,
-		verification: createVerificationEvidence(taskPacket.verification, !error, error ? `Task failed: ${error}` : input.executeWorkers ? "Worker finished without reporting a verification failure." : "Safe scaffold mode; verification commands were not executed."),
+		verification: createVerificationEvidence(taskPacket.verification, !error, error ? `Task failed: ${error}` : runtimeKind === "scaffold" ? "Safe scaffold mode; verification commands were not executed." : `${runtimeKind} worker finished without reporting a verification failure.`),
 		promptArtifact,
 		resultArtifact,
 		claim: undefined,
@@ -391,10 +456,10 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${JSON.stringify({ role: task.role, permissionMode }, null, 2)}\n`,
 		producer: task.id,
 	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : [])] };
+	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
 	saveRunManifest(manifest);
 	saveRunTasks(manifest, tasks);
-	upsertCrewAgent(manifest, recordFromTask(manifest, task, input.executeWorkers ? "child-process" : "scaffold"));
+	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
 	appendEvent(manifest.eventsPath, { type: error ? "task.failed" : "task.completed", runId: manifest.runId, taskId: task.id, message: error });
 	return { manifest, tasks };
 }

package/src/runtime/team-runner.ts

@@ -27,6 +27,9 @@ export interface ExecuteTeamRunInput {
 	limits?: CrewLimitsConfig;
 	runtime?: CrewRuntimeCapabilities;
 	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
 	signal?: AbortSignal;
 }
 
@@ -174,7 +177,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		const results = await Promise.all(readyBatch.map((task) => {
 			const step = findStep(input.workflow, task);
 			const agent = findAgent(input.agents, task);
-			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, limits: input.limits });
+			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, limits: input.limits });
 		}));
 		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
 		tasks = mergeTaskUpdates(tasks, results);

package/src/utils/file-coalescer.ts

@@ -0,0 +1,33 @@
+interface TimerApi {
+	setTimeout(handler: () => void, delayMs: number): unknown;
+	clearTimeout(handle: unknown): void;
+}
+
+const defaultTimerApi: TimerApi = {
+	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
+export interface FileCoalescer {
+	schedule(file: string, delayMs?: number): boolean;
+	clear(): void;
+}
+
+export function createFileCoalescer(handler: (file: string) => void, defaultDelayMs: number, timerApi: TimerApi = defaultTimerApi): FileCoalescer {
+	const pending = new Map<string, unknown>();
+	return {
+		schedule(file, delayMs = defaultDelayMs) {
+			if (pending.has(file)) return false;
+			const timer = timerApi.setTimeout(() => {
+				pending.delete(file);
+				handler(file);
+			}, delayMs);
+			pending.set(file, timer);
+			return true;
+		},
+		clear() {
+			for (const timer of pending.values()) timerApi.clearTimeout(timer);
+			pending.clear();
+		},
+	};
+}

package/src/worktree/worktree-manager.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadConfig } from "../config/config.ts";
@@ -9,6 +9,15 @@ export interface PreparedTaskWorkspace {
 	worktreePath?: string;
 	branch?: string;
 	reused?: boolean;
+	nodeModulesLinked?: boolean;
+	syntheticPaths?: string[];
+}
+
+export interface WorktreeDiffStat {
+	filesChanged: number;
+	insertions: number;
+	deletions: number;
+	diffStat: string;
 }
 
 function git(cwd: string, args: string[]): string {
@@ -30,6 +39,47 @@ export function assertCleanLeader(repoRoot: string): void {
 	}
 }
 
+function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boolean {
+	const source = path.join(repoRoot, "node_modules");
+	const target = path.join(worktreePath, "node_modules");
+	if (!fs.existsSync(source) || fs.existsSync(target)) return false;
+	try {
+		fs.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function normalizeSyntheticPath(worktreePath: string, rawPath: string): string {
+	const resolved = path.resolve(worktreePath, rawPath);
+	const relative = path.relative(worktreePath, resolved);
+	if (!relative || relative === "." || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`synthetic path escapes worktree: ${rawPath}`);
+	return path.normalize(relative);
+}
+
+function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot: string, worktreePath: string, branch: string): string[] {
+	const cfg = loadConfig(manifest.cwd).config.worktree;
+	if (!cfg?.setupHook) return [];
+	const hookPath = path.isAbsolute(cfg.setupHook) ? cfg.setupHook : path.resolve(repoRoot, cfg.setupHook);
+	if (!fs.existsSync(hookPath) || fs.statSync(hookPath).isDirectory()) throw new Error(`worktree setup hook not found or not a file: ${hookPath}`);
+	const nodeHook = hookPath.endsWith(".js") || hookPath.endsWith(".cjs") || hookPath.endsWith(".mjs");
+	const result = spawnSync(nodeHook ? process.execPath : hookPath, nodeHook ? [hookPath] : [], {
+		cwd: worktreePath,
+		encoding: "utf-8",
+		input: JSON.stringify({ version: 1, repoRoot, worktreePath, agentCwd: worktreePath, branch, runId: manifest.runId, taskId: task.id, agent: task.agent }),
+		timeout: cfg.setupHookTimeoutMs ?? 30_000,
+		shell: false,
+	});
+	if (result.error) throw new Error(`worktree setup hook failed: ${result.error.message}`);
+	if (result.status !== 0) throw new Error(`worktree setup hook failed with exit code ${result.status}: ${result.stderr || result.stdout || "no output"}`);
+	const trimmed = result.stdout.trim();
+	if (!trimmed) return [];
+	const parsed = JSON.parse(trimmed) as { syntheticPaths?: unknown };
+	if (!Array.isArray(parsed.syntheticPaths)) return [];
+	return [...new Set(parsed.syntheticPaths.filter((entry): entry is string => typeof entry === "string").map((entry) => normalizeSyntheticPath(worktreePath, entry)))];
+}
+
 export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskState): PreparedTaskWorkspace {
 	if (manifest.workspaceMode !== "worktree") return { cwd: task.cwd };
 	const repoRoot = findGitRoot(manifest.cwd);
@@ -47,7 +97,28 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		return { cwd: worktreePath, worktreePath, branch, reused: true };
 	}
 	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
-	return { cwd: worktreePath, worktreePath, branch, reused: false };
+	const syntheticPaths = runSetupHook(manifest, task, repoRoot, worktreePath, branch);
+	const nodeModulesLinked = loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, reused: false, nodeModulesLinked, syntheticPaths };
+}
+
+export function captureWorktreeDiffStat(worktreePath: string): WorktreeDiffStat {
+	try {
+		const diffStat = git(worktreePath, ["diff", "--stat"]);
+		const numstat = git(worktreePath, ["diff", "--numstat"]);
+		let filesChanged = 0;
+		let insertions = 0;
+		let deletions = 0;
+		for (const line of numstat.split(/\r?\n/).filter(Boolean)) {
+			const [add, del] = line.split(/\s+/);
+			filesChanged += 1;
+			insertions += Number(add) || 0;
+			deletions += Number(del) || 0;
+		}
+		return { filesChanged, insertions, deletions, diffStat };
+	} catch {
+		return { filesChanged: 0, insertions: 0, deletions: 0, diffStat: "" };
+	}
 }
 
 export function captureWorktreeDiff(worktreePath: string): string {