pi-crew 0.2.20 → 0.2.21

package/src/state/types.ts

@@ -276,6 +276,14 @@ export interface TeamTaskState {
 
 	/** Parsed metric key-values from worker output (CREW_METRIC lines). */
 	metrics?: Record<string, number>;
+
+	/** Lifetime token usage accumulated via message_end events. Survives compaction
+	 *  (session.stats reset on compaction, but this is an independent accumulator). */
+	lifetimeUsage?: { input: number; output: number; cacheWrite: number };
+
+	/** Steering messages queued before the task's session was ready.
+	 *  Delivered when the session initializes (mirrors pi-subagents3 pendingSteers pattern). */
+	pendingSteers?: string[];
 }
 
 export interface ControlReservation {
@@ -283,3 +291,35 @@ export interface ControlReservation {
 	controllerId: string;
 	acceptsControlEvents: boolean;
 }
+
+/**
+ * A task scheduled to fire on a cron expression, interval, or one-shot.
+ * Persisted at `<cwd>/.crew/state/schedules/<sessionId>.json`.
+ * Session-scoped: survives /resume, resets on /new.
+ */
+export interface ScheduledTask {
+	id: string;
+	name: string;
+	description: string;
+	/** Raw schedule: cron expr | "+10m" | "5m" | ISO timestamp */
+	schedule: string;
+	scheduleType: "cron" | "interval" | "once";
+	intervalMs?: number;
+	/** Workflow/step to execute when the schedule fires */
+	workflowName: string;
+	stepId?: string;
+	/** Resolved at create time from workflow/step config */
+	agentName: string;
+	model?: string;
+	enabled: boolean;
+	createdAt: string;
+	lastRun?: string;
+	lastStatus?: "success" | "error" | "running";
+	nextRun?: string;
+	runCount: number;
+}
+
+export interface ScheduleStoreData {
+	version: 1;
+	jobs: ScheduledTask[];
+}

package/src/state/usage.ts

@@ -1,5 +1,25 @@
 import type { TeamTaskState, UsageState } from "./types.ts";
 
+/**
+ * Lifetime usage — accumulated via message_end events, survives compaction.
+ * cacheRead is excluded because each turn's cacheRead is the cumulative cached
+ * prefix re-read on that one call — summing across turns would count it N times.
+ * See: https://github.com/nichekate/pi-subagents3/issues/38
+ */
+export type LifetimeUsage = { input: number; output: number; cacheWrite: number };
+
+/** Sum of lifetime usage components, or 0 if undefined. */
+export function getLifetimeTotal(u?: LifetimeUsage): number {
+	return u ? u.input + u.output + u.cacheWrite : 0;
+}
+
+/** Add a usage delta into a target accumulator (mutates target). */
+export function addUsage(into: LifetimeUsage, delta: LifetimeUsage): void {
+	into.input += delta.input;
+	into.output += delta.output;
+	into.cacheWrite += delta.cacheWrite;
+}
+
 export function aggregateUsage(tasks: TeamTaskState[]): UsageState | undefined {
 	const total: UsageState = {};
 	let found = false;

package/src/ui/crew-widget.ts

@@ -40,7 +40,7 @@ const MAX_AGENTS_DISPLAY = 3;
 /** R1: How many turns finished agents linger before disappearing. */
 const FINISHED_LINGER_MAX_AGE = 1;
 const ERROR_LINGER_MAX_AGE = 2;
-const ERROR_STATUSES = new Set(["failed", "cancelled", "stopped"]);
+const ERROR_STATUSES = new Set(["failed", "cancelled", "stopped", "needs_attention"]);
 /** R3: Faster refresh when live agents are running. Aligned with spinner frame. */
 const LIVE_REFRESH_MS = 160;
 
@@ -303,7 +303,7 @@ export function buildCrewWidgetLines(cwd: string, frame = 0, maxLines = 8, provi
 		for (const agent of finishedAgents.slice(0, 2)) {
 			const liveHandle = liveForRun.find((h) => h.taskId === agent.taskId);
 			const name = liveHandle?.agent ?? agent.agent;
-			const icon = agent.status === "completed" ? "\u2713" : agent.status === "failed" ? "\u2717" : "\u25AA";
+			const icon = agent.status === "completed" ? "\u2713" : agent.status === "failed" ? "\u2717" : agent.status === "needs_attention" ? "\u26A0" : "\u25AA";
 			const stats = agentStats(agent, liveHandle);
 			const desc = liveHandle?.description ?? agent.role;
 			lines.push(`\u2502  \u251C\u2500 ${icon} ${name} \u00B7 ${desc}${stats ? ` \u00B7 ${stats}` : ""}`);

package/src/ui/run-event-bus.ts

@@ -26,7 +26,7 @@ const WORKER_PROGRESS_TYPES = new Set([
 	"tool_execution_start", "tool_result", "agent_progress", "worker_status",
 ]);
 const WORKER_LIFECYCLE_TYPES = new Set([
-	"task.started", "task.completed", "task.failed",
+	"task.started", "task.completed", "task.failed", "task.needs_attention",
 	"task_started", "task_completed", "task_failed", "task_cancelled",
 	"run.started", "run.completed", "run.cancelled", "run.failed",
 	"run_started", "run_completed", "run_cancelled", "run_blocked",

package/src/ui/run-snapshot-cache.ts

@@ -307,7 +307,7 @@ async function recentOutputLinesAsync(manifest: TeamRunManifest, agents: CrewAge
 }
 
 function progressFromTasks(tasks: TeamTaskState[]): RunUiProgress {
-	const progress: RunUiProgress = { total: tasks.length, completed: 0, running: 0, failed: 0, queued: 0, waiting: 0, cancelled: 0, skipped: 0 };
+	const progress: RunUiProgress = { total: tasks.length, completed: 0, running: 0, failed: 0, queued: 0, waiting: 0, cancelled: 0, skipped: 0, needsAttention: 0 };
 	for (const task of tasks) {
 		if (task.status === "completed") progress.completed += 1;
 		else if (task.status === "running") progress.running += 1;
@@ -316,6 +316,7 @@ function progressFromTasks(tasks: TeamTaskState[]): RunUiProgress {
 		else if (task.status === "waiting") progress.waiting = (progress.waiting ?? 0) + 1;
 		else if (task.status === "cancelled") progress.cancelled = (progress.cancelled ?? 0) + 1;
 		else if (task.status === "skipped") progress.skipped = (progress.skipped ?? 0) + 1;
+		else if (task.status === "needs_attention") progress.needsAttention = (progress.needsAttention ?? 0) + 1;
 	}
 	return progress;
 }

package/src/ui/snapshot-types.ts

@@ -11,6 +11,7 @@ export interface RunUiProgress {
 	waiting?: number;
 	cancelled?: number;
 	skipped?: number;
+	needsAttention?: number;
 }
 
 export interface RunUiUsage {

package/src/utils/gh-protocol.ts

@@ -386,7 +386,7 @@ export function resolveGitHubUrl(parsed: Parsed, scheme: "issue" | "pr", cwd: st
 		if (parsed.mode === "list") {
 			try {
 				const raw = execFileSync(
-					"gh", ["pr", "view", String(parsed.number), "--repo", repo, "--json", "files", "--jq", ".files[] | \"\(.filename) +\(.additions) -\(.deletions) [\(.status)]\""],
+					"gh", ["pr", "view", String(parsed.number), "--repo", repo, "--json", "files", "--jq", ".files[] | \"(.filename) +(.additions) -(.deletions) [(.status)]\""],
 					{ cwd, encoding: "utf-8", timeout: 30_000, stdio: ["pipe", "pipe", "pipe"] },
 				);
 				const fileLines = raw.split("\n").filter(Boolean);
@@ -408,7 +408,7 @@ export function resolveGitHubUrl(parsed: Parsed, scheme: "issue" | "pr", cwd: st
 		if (parsed.mode === "slice" && parsed.index !== undefined) {
 			try {
 				const raw = execFileSync(
-					"gh", ["pr", "view", String(parsed.number), "--repo", repo, "--json", "files", "--jq", ".files[] | \"\(.filename) +\(.additions) -\(.deletions) [\(.status)]\""],
+					"gh", ["pr", "view", String(parsed.number), "--repo", repo, "--json", "files", "--jq", ".files[] | \"(.filename) +(.additions) -(.deletions) [(.status)]\""],
 					{ cwd, encoding: "utf-8", timeout: 30_000, stdio: ["pipe", "pipe", "pipe"] },
 				);
 				const fileLines = raw.split("\n").filter(Boolean);

package/src/utils/names.ts

@@ -23,5 +23,5 @@ export function parseConfigObject(config: unknown): { value?: Record<string, unk
 }
 
 export function hasOwn(obj: Record<string, unknown>, key: string): boolean {
-	return Object.prototype.hasOwnProperty.call(obj, key);
+	return  Object.hasOwn(obj, key);
 }

package/src/utils/sse-parser.ts

@@ -127,8 +127,6 @@ export async function* readSseJson<T>(
 			const parsed: T = JSON.parse(evt.data) as T;
 			yield parsed;
 		} catch {
-			// Skip non-JSON SSE data events (e.g., ping, error messages, sentinels)
-			continue;
 		}
 	}
 }

package/src/worktree/branch-freshness.ts

@@ -15,7 +15,7 @@ export interface BranchFreshness {
 }
 
 function git(cwd: string, args: string[]): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }).trim();
 }
 
 function count(cwd: string, range: string): number {

package/src/worktree/cleanup.ts

@@ -10,10 +10,12 @@ export interface WorktreeCleanupResult {
 	removed: string[];
 	preserved: Array<{ path: string; reason: string }>;
 	artifactPaths: string[];
+	/** Branch names created from dirty worktrees that were committed. */
+	committedBranches: string[];
 }
 
 function git(cwd: string, args: string[]): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" } }).trim();
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" }, windowsHide: true }).trim();
 }
 
 function isDirty(worktreePath: string): boolean {
@@ -35,23 +37,61 @@ function captureDiff(worktreePath: string): string {
 
 export function cleanupRunWorktrees(manifest: TeamRunManifest, options: { force?: boolean; signal?: AbortSignal } = {}): WorktreeCleanupResult {
 	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, manifest.runId);
-	const result: WorktreeCleanupResult = { removed: [], preserved: [], artifactPaths: [] };
+	const result: WorktreeCleanupResult = { removed: [], preserved: [], artifactPaths: [], committedBranches: [] };
 	if (!fs.existsSync(worktreeRoot)) return result;
 
-	for (const entry of fs.readdirSync(worktreeRoot)) {
+	// M3 fix: use withFileTypes to avoid race between readdirSync and statSync.
+	const withFileTypes = fs.readdirSync(worktreeRoot, { withFileTypes: true });
+	for (const entry of withFileTypes) {
 		if (options.signal?.aborted) break;
-		const worktreePath = path.join(worktreeRoot, entry);
-		if (!fs.statSync(worktreePath).isDirectory()) continue;
+		if (!entry.isDirectory()) continue;
+		const worktreePath = path.join(worktreeRoot, entry.name);
+		try {
+			const stat = fs.statSync(worktreePath);
+			if (!stat.isDirectory()) continue;
+		} catch {
+			// Entry deleted between readdir and stat — skip safely.
+			continue;
+		}
 		const dirty = isDirty(worktreePath);
-		if (dirty && !options.force) {
-			const artifact = writeArtifact(manifest.artifactsRoot, {
-				kind: "diff",
-				relativePath: `cleanup/${entry}.diff`,
-				content: captureDiff(worktreePath),
-				producer: "worktree-cleanup",
-			});
-			result.artifactPaths.push(artifact.path);
-			result.preserved.push({ path: worktreePath, reason: "dirty worktree preserved" });
+		const branchName = `pi-crew/${manifest.runId}/${entry.name}`;
+		if (dirty) {
+			// Commit changes to a branch instead of just preserving the worktree
+			try {
+				execFileSync("git", ["add", "-A"], { cwd: worktreePath, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" }, windowsHide: true });
+				const safeDesc = entry.name.slice(0, 200);
+				execFileSync("git", ["commit", "-m", `pi-crew: ${safeDesc}`], { cwd: worktreePath, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" }, windowsHide: true });
+				// Create branch in the main repo pointing to this worktree's HEAD
+				try {
+					execFileSync("git", ["branch", branchName], { cwd: worktreePath, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" }, windowsHide: true });
+				} catch {
+					// Branch already exists — use timestamp suffix
+					const tsBranch = `${branchName}-${Date.now()}`;
+					execFileSync("git", ["branch", tsBranch], { cwd: worktreePath, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" }, windowsHide: true });
+				}
+				result.committedBranches.push(branchName);
+				// Remove the worktree (branch persists)
+				const removeArgs = ["worktree", "remove", "--force", worktreePath];
+				git(manifest.cwd, removeArgs);
+				result.removed.push(worktreePath);
+				const artifact = writeArtifact(manifest.artifactsRoot, {
+					kind: "metadata",
+					relativePath: `metadata/worktree-branch-${entry.name}.json`,
+					content: JSON.stringify({ worktreePath, branch: branchName, committedAt: new Date().toISOString(), mergeCommand: `git merge ${branchName}` }, null, 2),
+					producer: "worktree-cleanup",
+				});
+				result.artifactPaths.push(artifact.path);
+			} catch (error) {
+				// Fallback to preserving dirty worktree
+				const artifact = writeArtifact(manifest.artifactsRoot, {
+					kind: "diff",
+					relativePath: `cleanup/${entry}.diff`,
+					content: captureDiff(worktreePath),
+					producer: "worktree-cleanup",
+				});
+				result.artifactPaths.push(artifact.path);
+				result.preserved.push({ path: worktreePath, reason: `dirty worktree preserved (commit failed: ${error instanceof Error ? error.message : String(error)})` });
+			}
 			continue;
 		}
 		const args = ["worktree", "remove"];

package/src/worktree/worktree-manager.ts

@@ -25,7 +25,7 @@ export interface WorktreeDiffStat {
 }
 
 function git(cwd: string, args: string[]): string {
-	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" } }).trim();
+	return execFileSync("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, LANG: "C", LC_ALL: "C" }, windowsHide: true }).trim();
 }
 
 function sanitizeBranchPart(value: string): string {
@@ -50,10 +50,13 @@ function linkNodeModulesIfPresent(repoRoot: string, worktreePath: string): boole
 	try { sourceStat = fs.statSync(source); } catch { return false; }
 	if (!sourceStat.isDirectory()) return false;
 	if (fs.existsSync(target)) return false;
+		// M5 fix: log symlink failure reason, especially on Windows non-admin.
 	try {
 		fs.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
 		return true;
-	} catch {
+	} catch (error) {
+		const isWindows = process.platform === "win32";
+		logInternalError("worktree.symlink-fail", error, isWindows ? "Windows non-admin: SeCreateSymbolicLinkPrivilege needed for node_modules symlink" : String(error));
 		return false;
 	}
 }
@@ -86,12 +89,19 @@ function runSetupHook(manifest: TeamRunManifest, task: TeamTaskState, repoRoot:
 	const trimmed = result.stdout.trim();
 	if (!trimmed) return [];
 	try {
-		// Extract JSON from last line — hooks may output debug logging before JSON
-		const lines = trimmed.split(/\r?\n/);
-		const lastLine = lines[lines.length - 1] ?? trimmed;
-		const parsed = JSON.parse(lastLine) 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)))];
+		// Extract JSON — hooks may output debug logging before JSON.
+	// M4 fix: try full trimmed (multi-line JSON object) before falling back to last line.
+	const lines = trimmed.split(/\r?\n/);
+	let parsed: { syntheticPaths?: unknown } | null = null;
+	try {
+		parsed = JSON.parse(trimmed) as { syntheticPaths?: unknown };
+	} catch { /* fall through — try last line */ }
+	if (!parsed && lines.length > 0) {
+		const lastLine = lines[lines.length - 1];
+		try { parsed = JSON.parse(lastLine) as { syntheticPaths?: unknown }; } catch { /* give up */ }
+	}
+	if (!parsed || !Array.isArray(parsed.syntheticPaths)) return [];
+	return [...new Set(parsed.syntheticPaths.filter((entry): entry is string => typeof entry === "string").map((entry) => normalizeSyntheticPath(worktreePath, entry)))];
 	} catch (error) {
 		logInternalError("worktree.setupHook.parse", error, `lastLine=${(trimmed.split(/\r?\n/).pop() ?? "").slice(0, 200)}`);
 		return [];
@@ -105,7 +115,7 @@ function branchExists(repoRoot: string, branch: string): { local: boolean; remot
 	// Check remote-tracking branch
 	try {
 		const out = execFileSync("git", ["for-each-ref", "--format=%(refname)", `refs/remotes/*/${branch}`],
-			{ cwd: repoRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+			{ cwd: repoRoot, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], windowsHide: true }).trim();
 		return { local: false, remoteOnly: out.length > 0 };
 	} catch { return { local: false, remoteOnly: false }; }
 }