pi-subagents 0.58.0 → 0.60.0

package/src/runs/background/scheduled-runs.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -11,6 +12,8 @@ import type { SubagentParamsLike } from "../foreground/subagent-executor.ts";
 import { validateExecutionAcceptance } from "../shared/acceptance.ts";
 import type { ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 import { previewSimpleWorkflowRun } from "../../workflows/scripted-workflow.ts";
+import { resolveGitRepositoryIdentity } from "../../workflows/chat-progress.ts";
+import { getConfigDirName } from "../../shared/utils.ts";
 
 export const SCHEDULED_RUN_ACTIONS = [
 	"schedule.create",
@@ -142,11 +145,83 @@ function validateScheduleId(id: string): string {
 	return id;
 }
 
+function normalizedComparisonPath(value: string): string {
+	const absolute = path.resolve(value);
+	if (process.platform !== "win32") return absolute;
+	let normalized = absolute;
+	try { normalized = fs.realpathSync.native(absolute); } catch {}
+	normalized = normalized.replaceAll("/", "\\");
+	if (normalized.startsWith("\\\\?\\UNC\\")) normalized = `\\\\${normalized.slice(8)}`;
+	else if (normalized.startsWith("\\\\?\\")) normalized = normalized.slice(4);
+	normalized = path.win32.normalize(normalized).toLowerCase();
+	if (normalized.length > 3) normalized = normalized.replace(/[\\]+$/, "");
+	return normalized;
+}
+
 function pathWithin(root: string, candidate: string): boolean {
-	const relative = path.relative(root, candidate);
+	const relative = path.relative(normalizedComparisonPath(root), normalizedComparisonPath(candidate));
 	return relative === "" || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
 }
 
+function resolveGitCommonDirForCheckout(checkoutRoot: string): string | undefined {
+	const gitPath = path.join(checkoutRoot, ".git");
+	try {
+		const stat = fs.statSync(gitPath);
+		if (stat.isDirectory()) return fs.realpathSync.native(gitPath);
+		if (!stat.isFile()) return undefined;
+		const match = /^gitdir:[ \t]*([^\r\n]+)$/i.exec(fs.readFileSync(gitPath, "utf-8").trim());
+		return match?.[1] ? fs.realpathSync.native(path.resolve(checkoutRoot, match[1])) : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function samePath(left: string, right: string): boolean {
+	return normalizedComparisonPath(left) === normalizedComparisonPath(right);
+}
+
+function resolveTrustedGitConfigRoot(checkoutRoot: string, commonDir: string): string | undefined {
+	const resolvedCommonDir = resolveGitCommonDirForCheckout(checkoutRoot);
+	if (!resolvedCommonDir || !samePath(resolvedCommonDir, commonDir)) return undefined;
+	const configRoot = path.join(checkoutRoot, getConfigDirName());
+	try {
+		const resolved = fs.realpathSync.native(configRoot);
+		return fs.statSync(resolved).isDirectory() && pathWithin(checkoutRoot, resolved) ? resolved : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function registeredGitWorktreeRoots(projectCwd: string): string[] {
+	const result = spawnSync("git", ["-C", projectCwd, "worktree", "list", "--porcelain"], { encoding: "utf-8", windowsHide: true });
+	if (result.status !== 0 || typeof result.stdout !== "string") return [];
+	const roots: string[] = [];
+	for (const line of result.stdout.split(/\r?\n/)) {
+		if (!line.startsWith("worktree ")) continue;
+		try { roots.push(fs.realpathSync.native(line.slice("worktree ".length).trim())); } catch {}
+	}
+	return roots;
+}
+
+function resolveSharedGitConfigRoot(projectCwd: string): string | undefined {
+	const repository = resolveGitRepositoryIdentity(projectCwd);
+	if (!repository) return undefined;
+	let projectConfigRoot: string;
+	try {
+		projectConfigRoot = fs.realpathSync.native(path.join(projectCwd, getConfigDirName()));
+	} catch {
+		return undefined;
+	}
+	// Git may report a separate-git-dir primary checkout as its common git
+	// directory, not as the checkout root. Without a registered checkout root,
+	// do not infer a shared config path from that unprovable layout.
+	for (const checkoutRoot of new Set(registeredGitWorktreeRoots(projectCwd))) {
+		const resolved = resolveTrustedGitConfigRoot(checkoutRoot, repository.commonDir);
+		if (resolved && samePath(resolved, projectConfigRoot)) return resolved;
+	}
+	return undefined;
+}
+
 function assertScheduleRoot(root: string, projectCwd: string | undefined, create: boolean): void {
 	if (!projectCwd) {
 		if (create) fs.mkdirSync(root, { recursive: true, mode: 0o700 });
@@ -154,7 +229,7 @@ function assertScheduleRoot(root: string, projectCwd: string | undefined, create
 	}
 	let projectPath: string;
 	try {
-		projectPath = fs.realpathSync(projectCwd);
+		projectPath = fs.realpathSync.native(projectCwd);
 	} catch (error) {
 		if (!create && (error as NodeJS.ErrnoException).code === "ENOENT") return;
 		throw error;
@@ -165,10 +240,14 @@ function assertScheduleRoot(root: string, projectCwd: string | undefined, create
 		if (parent === existing) break;
 		existing = parent;
 	}
-	if (!pathWithin(projectPath, fs.realpathSync(existing))) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
+	const existingPath = fs.realpathSync.native(existing);
+	const sharedGitConfigRoot = pathWithin(projectPath, existingPath) ? undefined : resolveSharedGitConfigRoot(projectCwd);
+	const isTrustedPath = (candidate: string): boolean => pathWithin(projectPath, candidate)
+		|| (sharedGitConfigRoot !== undefined && pathWithin(sharedGitConfigRoot, candidate));
+	if (!isTrustedPath(existingPath)) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
 	if (!create) return;
 	fs.mkdirSync(root, { recursive: true, mode: 0o700 });
-	if (!pathWithin(projectPath, fs.realpathSync(root))) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
+	if (!isTrustedPath(fs.realpathSync.native(root))) throw new Error(`Project schedule root '${root}' resolves outside the real project.`);
 }
 
 function scheduleDir(root: string, id: string, create = false, projectCwd?: string): string {
@@ -182,9 +261,9 @@ function scheduleDir(root: string, id: string, create = false, projectCwd?: stri
 		if (!create) return dir;
 		fs.mkdirSync(dir, { mode: 0o700 });
 	}
-	const rootPath = fs.realpathSync(root);
-	const dirPath = fs.realpathSync(dir);
-	if (dirPath !== path.join(rootPath, id)) throw new Error(`Schedule path '${dir}' escapes the project schedule root.`);
+	const rootPath = fs.realpathSync.native(root);
+	const dirPath = fs.realpathSync.native(dir);
+	if (!samePath(dirPath, path.join(rootPath, id))) throw new Error(`Schedule path '${dir}' escapes the project schedule root.`);
 	return dir;
 }
 

package/src/runs/background/stale-run-reconciler.ts

@@ -8,6 +8,7 @@ import { DIRS, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSu
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
+import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
 
@@ -24,6 +25,7 @@ interface StartedRunMetadata {
 	parallelGroups?: AsyncParallelGroupStatus[];
 	startedAt?: number;
 	sessionFile?: string;
+	sessionName?: string;
 }
 
 interface ReconcileAsyncRunOptions {
@@ -90,6 +92,7 @@ function appendJsonlBestEffort(filePath: string, payload: object): void {
 
 interface ResultChildOutcome {
 	agent?: string;
+	sessionName?: string;
 	success?: boolean;
 	error?: string;
 	sessionFile?: string;
@@ -101,7 +104,7 @@ interface ResultChildOutcome {
 }
 
 interface ResultRepairData {
-	state: "complete" | "failed" | "paused" | "stopped" | "rejected";
+	state: "complete" | "failed" | "partial" | "paused" | "stopped" | "rejected";
 	results?: ResultChildOutcome[];
 }
 
@@ -117,7 +120,7 @@ function regularFileExists(filePath: string): boolean {
 function readResultRepairData(resultPath: string): ResultRepairData | undefined {
 	try {
 		const data = JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { success?: boolean; state?: string; exitCode?: number; results?: unknown };
-		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
+		const state = data.success ? "complete" : data.state === "stopped" ? "stopped" : data.state === "rejected" ? "rejected" : data.state === "partial" ? "partial" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
 		const results = Array.isArray(data.results)
 			? data.results.map((entry, index) => {
 				if (!entry || typeof entry !== "object" || Array.isArray(entry)) return {};
@@ -157,8 +160,9 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 			endedAt: step.endedAt ?? now,
 			durationMs: step.startedAt !== undefined && step.durationMs === undefined ? Math.max(0, now - step.startedAt) : step.durationMs,
 			exitCode: step.exitCode ?? (state === "complete" || state === "paused" ? 0 : 1),
-			error: state === "failed" || state === "stopped" ? step.error ?? child?.error : step.error,
+			error: state === "failed" || state === "partial" || state === "stopped" ? step.error ?? child?.error : step.error,
 			stopped: state === "stopped" ? true : step.stopped,
+			sessionName: step.sessionName ?? child?.sessionName,
 			sessionFile: step.sessionFile ?? child?.sessionFile,
 			model,
 			thinking,
@@ -254,6 +258,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			summary: message,
 			results: repairedSteps.map((step) => ({
 				agent: step.agent,
+				...(step.sessionName ? { sessionName: step.sessionName } : {}),
 				output: step.status === "complete" || step.status === "completed" ? "" : message,
 				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
 				success: step.status === "complete" || step.status === "completed",
@@ -290,7 +295,7 @@ function writeFailedRepair(asyncDir: string, status: AsyncStatus, resultPath: st
 }
 
 function terminal(state: AsyncStatus["state"]): boolean {
-	return state === "complete" || state === "failed" || state === "paused" || state === "stopped" || state === "rejected";
+	return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped" || state === "rejected";
 }
 
 function* nestedRuns(children: NestedRunSummary[] | undefined): Generator<NestedRunSummary> {
@@ -353,6 +358,7 @@ export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOp
 	const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
 	const effectiveStatus = status ?? startedStatus;
 	if (!effectiveStatus) return { status: null, repaired: false };
+	assertWorkflowGraphHostSteps(effectiveStatus.workflowGraph, path.join(asyncDir, "status.json"), effectiveStatus.runId);
 	const statusPath = path.join(asyncDir, "status.json");
 	for (const [index, step] of (effectiveStatus.steps ?? []).entries()) {
 		const stepRecord = step as Record<string, unknown>;

package/src/runs/background/steering.ts

@@ -4,7 +4,6 @@ import { writePrivateAtomicJson } from "../../shared/atomic-json.ts";
 import type {
 	AsyncStatus,
 	ResolvedToolBudget,
-	ResolvedTurnBudget,
 	SteerActionResult,
 	SteeringRecoveryDescriptor,
 	SteeringRequestStatus,
@@ -195,26 +194,17 @@ export function readSteeringStatus(asyncDir: string): SteeringStatus | undefined
 }
 
 export function remainingSteeringRecoveryLimits(
-	descriptor: Pick<SteeringRecoveryDescriptor, "absoluteDeadlineAt" | "initialTurnBudget" | "initialToolBudget">,
-	status: Pick<AsyncStatus, "turnBudget" | "turnCount" | "toolBudget" | "toolCount">,
+	descriptor: Pick<SteeringRecoveryDescriptor, "absoluteDeadlineAt" | "initialToolBudget">,
+	status: Pick<AsyncStatus, "toolBudget" | "toolCount">,
 	now = Date.now(),
-): { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: ResolvedTurnBudget; toolBudget?: ResolvedToolBudget } {
-	const limits: { timeoutMs?: number; absoluteDeadlineAt?: number; turnBudget?: ResolvedTurnBudget; toolBudget?: ResolvedToolBudget } = {};
+): { timeoutMs?: number; absoluteDeadlineAt?: number; toolBudget?: ResolvedToolBudget } {
+	const limits: { timeoutMs?: number; absoluteDeadlineAt?: number; toolBudget?: ResolvedToolBudget } = {};
 	if (descriptor.absoluteDeadlineAt !== undefined) {
 		const timeoutMs = descriptor.absoluteDeadlineAt - now;
 		if (timeoutMs <= 0) throw new Error("Source run has no remaining deadline budget; it remains paused.");
 		limits.timeoutMs = timeoutMs;
 		limits.absoluteDeadlineAt = descriptor.absoluteDeadlineAt;
 	}
-	if (descriptor.initialTurnBudget) {
-		const consumed = status.turnBudget?.turnCount ?? status.turnCount ?? 0;
-		const totalRemaining = descriptor.initialTurnBudget.maxTurns + descriptor.initialTurnBudget.graceTurns - consumed;
-		if (totalRemaining <= 0) throw new Error("Source run has no remaining turn budget; it remains paused.");
-		const softRemaining = Math.max(0, descriptor.initialTurnBudget.maxTurns - consumed);
-		limits.turnBudget = softRemaining > 0
-			? { maxTurns: softRemaining, graceTurns: totalRemaining - softRemaining }
-			: { maxTurns: 1, graceTurns: totalRemaining - 1 };
-	}
 	if (descriptor.initialToolBudget) {
 		const consumed = status.toolBudget?.toolCount ?? status.toolCount ?? 0;
 		const hard = descriptor.initialToolBudget.hard - consumed;