pi-subagents 0.34.0 → 0.35.0

package/src/tui/render.ts

@@ -268,6 +268,7 @@ function firstOutputLine(text: string): string {
 
 function resultStatusLine(result: Details["results"][number], output: string): string {
 	if (result.detached) return result.detachedReason ? `Detached: ${result.detachedReason}` : "Detached";
+	if (result.stopped) return "Stopped";
 	if (result.interrupted) return "Paused";
 	if (result.exitCode !== 0) return `Error: ${result.error ?? (firstOutputLine(output) || `exit ${result.exitCode}`)}`;
 	if (result.acceptance?.status && result.acceptance.status !== "not-required") return `Done · acceptance: ${result.acceptance.status}`;
@@ -281,6 +282,7 @@ function resultGlyph(result: Details["results"][number], output: string, theme:
 		return theme.fg("accent", runningGlyph(seed));
 	}
 	if (result.detached) return theme.fg("warning", "■");
+	if (result.stopped) return theme.fg("warning", "■");
 	if (result.interrupted) return theme.fg("warning", "■");
 	if (result.exitCode !== 0) return theme.fg("error", "✗");
 	if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) return theme.fg("warning", "✓");
@@ -349,6 +351,7 @@ function widgetActivity(job: AsyncJobState): string {
 	if (job.status === "running") return "thinking…";
 	if (job.status === "queued") return "queued…";
 	if (job.status === "paused") return "Paused";
+	if (job.status === "stopped") return "Stopped";
 	if (job.status === "failed") return "Failed";
 	return "Done";
 }
@@ -397,6 +400,7 @@ function widgetStatusGlyph(job: AsyncJobState, theme: Theme): string {
 	if (job.status === "queued") return theme.fg("muted", "◦");
 	if (job.status === "complete") return theme.fg("success", "✓");
 	if (job.status === "paused") return theme.fg("warning", "■");
+	if (job.status === "stopped") return theme.fg("warning", "■");
 	return theme.fg("error", "✗");
 }
 
@@ -405,6 +409,7 @@ function widgetStepGlyph(status: AsyncJobStep["status"], theme: Theme, seed?: nu
 	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
 	if (status === "failed") return theme.fg("error", "✗");
 	if (status === "paused") return theme.fg("warning", "■");
+	if (status === "stopped") return theme.fg("warning", "■");
 	return theme.fg("muted", "◦");
 }
 
@@ -413,6 +418,7 @@ function widgetStepStatus(status: AsyncJobStep["status"], theme: Theme): string
 	if (status === "complete" || status === "completed") return theme.fg("success", "complete");
 	if (status === "failed") return theme.fg("error", "failed");
 	if (status === "paused") return theme.fg("warning", "paused");
+	if (status === "stopped") return theme.fg("warning", "stopped");
 	return theme.fg("dim", status);
 }
 
@@ -620,7 +626,7 @@ function buildMultiProgressLabel(details: Pick<Details, "mode" | "results" | "pr
 
 	if (details.mode === "parallel") {
 		const totalCount = details.totalSteps ?? details.results.length;
-		const statuses = new Array(totalCount).fill("pending") as Array<"pending" | "running" | "completed" | "failed" | "detached">;
+		const statuses = new Array(totalCount).fill("pending") as Array<"pending" | "running" | "completed" | "failed" | "stopped" | "detached">;
 		for (const progress of details.progress ?? []) {
 			if (progress.index >= 0 && progress.index < totalCount) statuses[progress.index] = progress.status;
 		}
@@ -631,11 +637,13 @@ function buildMultiProgressLabel(details: Pick<Details, "mode" | "results" | "pr
 			const index = result.progress?.index ?? progressFromArray?.index ?? i;
 			if (index < 0 || index >= totalCount) continue;
 			const status = result.progress?.status
-				?? (result.interrupted || result.detached
-					? "detached"
-					: result.exitCode === 0
-						? "completed"
-						: "failed");
+				?? (result.stopped
+					? "stopped"
+					: result.interrupted || result.detached
+						? "detached"
+						: result.exitCode === 0
+							? "completed"
+							: "failed");
 			statuses[index] = status;
 		}
 		const running = statuses.filter((status) => status === "running").length;
@@ -788,6 +796,7 @@ function nestedStatusGlyph(state: NestedRunSummary["state"] | NestedStepSummary[
 	if (state === "complete" || state === "completed") return theme.fg("success", "✓");
 	if (state === "failed") return theme.fg("error", "✗");
 	if (state === "paused") return theme.fg("warning", "■");
+	if (state === "stopped") return theme.fg("warning", "■");
 	return theme.fg("muted", "◦");
 }
 
@@ -795,6 +804,29 @@ function nestedRunSeed(run: NestedRunSummary): number | undefined {
 	return runningSeed(run.lastUpdate, run.lastActivityAt, run.currentStep, run.toolCount, run.turnCount, run.totalTokens?.total, run.currentToolStartedAt);
 }
 
+function formatClockTime(ms: number | undefined): string | undefined {
+	if (ms === undefined || !Number.isFinite(ms)) return undefined;
+	const date = new Date(ms);
+	const pad = (value: number) => value.toString().padStart(2, "0");
+	return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+function nestedRunEventTime(run: NestedRunSummary): number | undefined {
+	return run.state === "running"
+		? (run.lastActivityAt ?? run.currentToolStartedAt ?? run.lastUpdate ?? run.startedAt)
+		: (run.endedAt ?? run.lastUpdate ?? run.lastActivityAt ?? run.startedAt);
+}
+
+function nestedStepTimestamp(step: NestedStepSummary, fallback?: number): string | undefined {
+	return formatClockTime(step.status === "running"
+		? (step.lastActivityAt ?? step.currentToolStartedAt ?? fallback ?? step.startedAt)
+		: (step.endedAt ?? step.lastActivityAt ?? fallback ?? step.startedAt));
+}
+
+function nestedTimestampPrefix(timestamp: string | undefined): string {
+	return timestamp ? `[${timestamp}] ` : "";
+}
+
 function nestedActivity(input: Pick<NestedRunSummary | NestedStepSummary, "activityState" | "lastActivityAt" | "currentTool" | "currentToolStartedAt" | "currentPath" | "turnCount" | "toolCount">, state: NestedRunSummary["state"] | NestedStepSummary["status"], snapshotNow?: number): string {
 	const facts: string[] = [];
 	if (input.currentTool && input.currentToolStartedAt !== undefined && snapshotNow !== undefined) facts.push(`${input.currentTool} ${formatDuration(Math.max(0, snapshotNow - input.currentToolStartedAt))}`);
@@ -809,6 +841,7 @@ function nestedActivity(input: Pick<NestedRunSummary | NestedStepSummary, "activ
 	if (state === "running") return "thinking…";
 	if (state === "queued" || state === "pending") return "queued…";
 	if (state === "paused") return "Paused";
+	if (state === "stopped") return "Stopped";
 	if (state === "failed") return "Failed";
 	return "Done";
 }
@@ -817,7 +850,8 @@ function formatNestedWidgetLines(children: NestedRunSummary[] | undefined, theme
 	if (!children?.length || lineBudget <= 0) return [];
 	if (!expanded) {
 		const aggregate = formatNestedAggregate(children);
-		return aggregate ? [theme.fg("dim", `↳ ${aggregate}`)] : [];
+		const latest = children.reduce((acc, child) => Math.max(acc, nestedRunEventTime(child) ?? 0), 0);
+		return aggregate ? [theme.fg("dim", `↳ ${nestedTimestampPrefix(formatClockTime(latest))}${aggregate}`)] : [];
 	}
 	const lines: string[] = [];
 	const maxDepth = 2;
@@ -837,7 +871,7 @@ function formatNestedWidgetLines(children: NestedRunSummary[] | undefined, theme
 			}
 			const activity = nestedActivity(child, child.state, snapshotNow ?? child.lastUpdate);
 			const error = child.error ? ` · ${child.error}` : "";
-			lines.push(theme.fg("dim", `${prefix}↳ ${nestedStatusGlyph(child.state, theme, nestedRunSeed(child))} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`));
+			lines.push(theme.fg("dim", `${prefix}↳ ${nestedTimestampPrefix(formatClockTime(nestedRunEventTime(child)))}${nestedStatusGlyph(child.state, theme, nestedRunSeed(child))} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`));
 			if (depth === maxDepth) {
 				const aggregate = formatNestedAggregate([...(child.steps?.flatMap((step) => step.children ?? []) ?? []), ...(child.children ?? [])]);
 				if (aggregate && lines.length < lineBudget) lines.push(theme.fg("dim", `${prefix}  ↳ ${aggregate}`));
@@ -845,7 +879,7 @@ function formatNestedWidgetLines(children: NestedRunSummary[] | undefined, theme
 			}
 			for (const step of child.steps ?? []) {
 				if (lines.length >= lineBudget) return;
-				lines.push(theme.fg("dim", `${prefix}  ↳ ${nestedStatusGlyph(step.status, theme)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`));
+				lines.push(theme.fg("dim", `${prefix}  ↳ ${nestedTimestampPrefix(nestedStepTimestamp(step, child.lastUpdate))}${nestedStatusGlyph(step.status, theme)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`));
 				append(step.children, depth + 1, `${prefix}    `);
 			}
 			append(child.children, depth + 1, `${prefix}  `);
@@ -984,13 +1018,14 @@ function widgetSessionMatches(expanded: boolean): boolean {
 		&& widgetLayoutSession.columns === currentTerminalColumns();
 }
 
-function widgetHeaderCounts(jobs: AsyncJobState[]): { running: AsyncJobState[]; queued: AsyncJobState[]; complete: AsyncJobState[]; failed: AsyncJobState[]; paused: AsyncJobState[] } {
+function widgetHeaderCounts(jobs: AsyncJobState[]): { running: AsyncJobState[]; queued: AsyncJobState[]; complete: AsyncJobState[]; failed: AsyncJobState[]; paused: AsyncJobState[]; stopped: AsyncJobState[] } {
 	return {
 		running: jobs.filter((job) => job.status === "running"),
 		queued: jobs.filter((job) => job.status === "queued"),
 		complete: jobs.filter((job) => job.status === "complete"),
 		failed: jobs.filter((job) => job.status === "failed"),
 		paused: jobs.filter((job) => job.status === "paused"),
+		stopped: jobs.filter((job) => job.status === "stopped"),
 	};
 }
 
@@ -1002,6 +1037,7 @@ function buildSingleLineWidgetLines(jobs: AsyncJobState[], theme: Theme, width:
 	if (counts.running.length > 0) parts.push(`${counts.running.length}/${jobs.length} running`);
 	if (counts.queued.length > 0) parts.push(`${counts.queued.length} queued`);
 	if (counts.failed.length > 0) parts.push(`${counts.failed.length} failed`);
+	if (counts.stopped.length > 0) parts.push(`${counts.stopped.length} stopped`);
 	if (counts.paused.length > 0) parts.push(`${counts.paused.length} paused`);
 	if (!hasActive && counts.complete.length > 0) parts.push(`${counts.complete.length}/${jobs.length} done`);
 	return [truncLine(`${theme.fg(hasActive ? "accent" : "dim", glyph)} ${theme.fg(hasActive ? "accent" : "dim", "subagents")} (${parts.join(", ") || `${jobs.length} total`})`, width)];
@@ -1065,6 +1101,7 @@ function progressiveHeaderLine(jobs: AsyncJobState[], theme: Theme, width: numbe
 	if (counts.queued.length > 0) parts.push(`${counts.queued.length} queued`);
 	if (!hasActive) {
 		if (counts.failed.length > 0) parts.push(`${counts.failed.length} failed`);
+		if (counts.stopped.length > 0) parts.push(`${counts.stopped.length} stopped`);
 		if (counts.paused.length > 0) parts.push(`${counts.paused.length} paused`);
 		if (counts.complete.length > 0) parts.push(`${counts.complete.length}/${jobs.length} done`);
 	}
@@ -1089,7 +1126,7 @@ function progressiveHiddenLine(hiddenJobs: AsyncJobState[], theme: Theme, width:
 	const parts: string[] = [];
 	if (counts.running.length > 0) parts.push(`${counts.running.length} running`);
 	if (counts.queued.length > 0) parts.push(`${counts.queued.length} queued`);
-	const finished = counts.complete.length + counts.failed.length + counts.paused.length;
+	const finished = counts.complete.length + counts.failed.length + counts.paused.length + counts.stopped.length;
 	if (finished > 0) parts.push(`${finished} finished`);
 	return truncLine(theme.fg("dim", `  +${hiddenJobs.length} more${parts.length ? ` (${parts.join(", ")})` : ""}`), width);
 }
@@ -1292,11 +1329,17 @@ function renderSingleCompact(d: Details, r: Details["results"][number], theme: T
 		c.addChild(new Text(truncLine(theme.fg("dim", `  ⎿  ${activity}`), width), 0, 0));
 		const liveStatus = buildLiveStatusLine(r.progress, progressSnapshotNow);
 		if (liveStatus && liveStatus !== activity) c.addChild(new Text(truncLine(theme.fg("dim", `     ${liveStatus}`), width), 0, 0));
+		for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, progressSnapshotNow)) {
+			c.addChild(new Text(truncLine(`  ${nestedLine}`, width), 0, 0));
+		}
 		c.addChild(new Text(truncLine(theme.fg("accent", `  ${liveDetailHintText()}`), width), 0, 0));
 		if (r.artifactPaths) c.addChild(new Text(truncLine(theme.fg("dim", `  output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
 		return c;
 	}
 
+	for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, r.progress?.lastActivityAt)) {
+		c.addChild(new Text(truncLine(`  ${nestedLine}`, width), 0, 0));
+	}
 	c.addChild(new Text(truncLine(theme.fg("dim", `  ⎿  ${resultStatusLine(r, output)}`), width), 0, 0));
 	const preview = firstOutputLine(output);
 	if (preview && r.exitCode === 0 && !hasEmptyTextOutputWithoutOutputTarget(r.task, output)) {
@@ -1312,7 +1355,9 @@ function renderMultiCompact(d: Details, theme: Theme, frame?: number): Component
 	const hasRunning = d.progress?.some((p) => p.status === "running")
 		|| d.results.some((r) => r.progress?.status === "running")
 		|| workflowGraphHasStatus(d, ["running"]);
-	const failed = d.results.some((r) => r.exitCode !== 0 && r.progress?.status !== "running")
+	const stopped = d.results.some((r) => r.stopped && r.progress?.status !== "running")
+		|| workflowGraphHasStatus(d, ["stopped"]);
+	const failed = d.results.some((r) => !r.stopped && r.exitCode !== 0 && r.progress?.status !== "running")
 		|| workflowGraphHasStatus(d, ["failed"]);
 	const paused = d.results.some((r) => (r.interrupted || r.detached) && r.progress?.status !== "running")
 		|| workflowGraphHasStatus(d, ["paused", "detached"]);
@@ -1335,8 +1380,10 @@ function renderMultiCompact(d: Details, theme: Theme, frame?: number): Component
 	const stats = statJoin(theme, [multiLabel.headerLabel, formatProgressStats(theme, totalSummary), formatTotalCostStat(d.totalCost)]);
 	const glyph = hasRunning
 		? theme.fg("accent", runningGlyph(frame !== undefined ? (runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex) ?? 0) + frame : runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex)))
-		: failed
-			? theme.fg("error", "✗")
+		: stopped
+			? theme.fg("warning", "■")
+			: failed
+				? theme.fg("error", "✗")
 			: paused
 				? theme.fg("warning", "■")
 				: theme.fg("success", "✓");
@@ -1388,10 +1435,18 @@ function renderMultiCompact(d: Details, theme: Theme, frame?: number): Component
 		if (rRunning && rProg && "status" in rProg) {
 			const activity = compactCurrentActivity(rProg);
 			c.addChild(new Text(truncLine(theme.fg("dim", `    ⎿  ${activity}`), width), 0, 0));
+			for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, snapshotNowForProgress(rProg))) {
+				c.addChild(new Text(truncLine(`    ${nestedLine}`, width), 0, 0));
+			}
 			c.addChild(new Text(truncLine(theme.fg("accent", `    ${liveDetailHintText()}`), width), 0, 0));
 		} else if (!rPending && (r.exitCode !== 0 || r.interrupted || r.detached || hasEmptyTextOutputWithoutOutputTarget(r.task, output))) {
 			c.addChild(new Text(truncLine(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    ⎿  ${resultStatusLine(r, output)}`), width), 0, 0));
 		}
+		if (!rRunning && !rPending) {
+			for (const nestedLine of formatNestedWidgetLines(r.children, theme, width, false, r.progress?.lastActivityAt)) {
+				c.addChild(new Text(truncLine(`    ${nestedLine}`, width), 0, 0));
+			}
+		}
 		const outputTarget = extractOutputTarget(r.task);
 		if (outputTarget) c.addChild(new Text(truncLine(theme.fg("dim", `    output: ${outputTarget}`), width), 0, 0));
 		if (r.artifactPaths) c.addChild(new Text(truncLine(theme.fg("dim", `    output: ${shortenPath(r.artifactPaths.outputPath)}`), width), 0, 0));
@@ -1462,6 +1517,9 @@ export function renderSubagentResult(
 
 		if (isRunning && r.progress) {
 			const progressSnapshotNow = snapshotNowForProgress(r.progress);
+			for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, progressSnapshotNow, 12)) {
+				c.addChild(new Text(fit(`  ${nestedLine}`), 0, 0));
+			}
 			const toolLine = formatCurrentToolLine(r.progress, w, expanded, progressSnapshotNow);
 			if (toolLine) {
 				c.addChild(new Text(fit(theme.fg("warning", `> ${toolLine}`)), 0, 0));
@@ -1489,6 +1547,10 @@ export function renderSubagentResult(
 			if (toolLine || liveStatusLine || r.progress.recentTools?.length || r.progress.recentOutput?.length || r.artifactPaths) {
 				c.addChild(new Spacer(1));
 			}
+		} else {
+			for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, r.progress?.lastActivityAt, 8)) {
+				c.addChild(new Text(fit(`  ${nestedLine}`), 0, 0));
+			}
 		}
 
 		if (expanded) {
@@ -1533,6 +1595,7 @@ export function renderSubagentResult(
 		&& hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r)),
 	);
 	const hasWorkflowFailure = workflowGraphHasStatus(d, ["failed"]);
+	const hasWorkflowStop = d.results.some((r) => r.stopped && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["stopped"]);
 	const hasWorkflowPause = workflowGraphHasStatus(d, ["paused", "detached"]);
 	const icon = hasRunning
 		? theme.fg("warning", "running")
@@ -1540,8 +1603,10 @@ export function renderSubagentResult(
 			? theme.fg("warning", "warning")
 			: hasWorkflowFailure
 				? theme.fg("error", "failed")
-				: hasWorkflowPause
-					? theme.fg("warning", "paused")
+				: hasWorkflowStop
+					? theme.fg("warning", "stopped")
+					: hasWorkflowPause
+						? theme.fg("warning", "paused")
 					: ok === d.results.length
 						? theme.fg("success", "ok")
 						: theme.fg("error", "failed");
@@ -1707,6 +1772,9 @@ export function renderSubagentResult(
 			if (liveStatusLine) {
 				c.addChild(new Text(fit(theme.fg("accent", `    ${liveStatusLine}`)), 0, 0));
 			}
+			for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, progressSnapshotNow, 8)) {
+				c.addChild(new Text(fit(`    ${nestedLine}`), 0, 0));
+			}
 			c.addChild(new Text(fit(theme.fg("accent", `    ${liveDetailHintText()}`)), 0, 0));
 			if (r.artifactPaths) {
 				c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
@@ -1726,6 +1794,12 @@ export function renderSubagentResult(
 			}
 		}
 
+		if (!rRunning) {
+			for (const nestedLine of formatNestedWidgetLines(r.children, theme, w, true, r.progress?.lastActivityAt, 8)) {
+				c.addChild(new Text(fit(`    ${nestedLine}`), 0, 0));
+			}
+		}
+
 		if (!rRunning && r.artifactPaths) {
 			c.addChild(new Text(fit(theme.fg("dim", `    artifacts: ${shortenPath(r.artifactPaths.outputPath)}`)), 0, 0));
 		}

package/src/watchdog/change-signature.ts

@@ -0,0 +1,127 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const IGNORED_CHANGE_PREFIXES = [".pi-subagents/", "tmp/", "node_modules/"];
+const IGNORED_CHANGE_PATHS = new Set([".pi-subagents", "tmp", "node_modules"]);
+
+export interface WatchdogRepoChangeSignature {
+	root: string;
+	key: string;
+	changedPaths: string[];
+}
+
+function git(cwd: string, args: string[]): string | undefined {
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+	if (result.status !== 0) return undefined;
+	return result.stdout;
+}
+
+function normalizeRelPath(value: string): string {
+	return value.replaceAll(path.sep, "/").replace(/^\.\//, "");
+}
+
+function ignoredRelPath(relPath: string): boolean {
+	const normalized = normalizeRelPath(relPath);
+	return IGNORED_CHANGE_PATHS.has(normalized) || IGNORED_CHANGE_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+function hashFile(filePath: string): string {
+	return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+
+function hashPath(root: string, relPath: string): unknown {
+	const normalized = normalizeRelPath(relPath);
+	const fullPath = path.join(root, normalized);
+	let stat: fs.Stats;
+	try {
+		stat = fs.lstatSync(fullPath);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return { path: normalized, state: "deleted" };
+		throw error;
+	}
+	if (stat.isSymbolicLink()) {
+		return { path: normalized, state: "symlink", target: fs.readlinkSync(fullPath) };
+	}
+	if (stat.isDirectory()) {
+		const entries = fs.readdirSync(fullPath)
+			.map((entry) => normalizeRelPath(path.posix.join(normalized, entry)))
+			.filter((entry) => !ignoredRelPath(entry))
+			.sort();
+		return { path: normalized, state: "dir", entries: entries.map((entry) => hashPath(root, entry)) };
+	}
+	if (stat.isFile()) {
+		return { path: normalized, state: "file", mode: stat.mode & 0o777, size: stat.size, hash: hashFile(fullPath) };
+	}
+	return { path: normalized, state: "other", mode: stat.mode };
+}
+
+function parsePorcelainZ(raw: string): Array<{ status: string; paths: string[] }> {
+	const tokens = raw.split("\0").filter(Boolean);
+	const entries: Array<{ status: string; paths: string[] }> = [];
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index]!;
+		if (token.length < 4) continue;
+		const status = token.slice(0, 2);
+		const relPath = token.slice(3);
+		const paths = [relPath];
+		if (status[0] === "R" || status[0] === "C") {
+			const originalPath = tokens[++index];
+			if (originalPath) paths.push(originalPath);
+		}
+		entries.push({ status, paths });
+	}
+	return entries;
+}
+
+export function computeWatchdogRepoChangeSignature(cwd: string): WatchdogRepoChangeSignature | undefined {
+	const root = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
+	if (!root) return undefined;
+	const statusOutput = git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+	if (statusOutput === undefined) return undefined;
+	const entries = parsePorcelainZ(statusOutput)
+		.map((entry) => ({
+			status: entry.status,
+			paths: entry.paths.map(normalizeRelPath).filter((relPath) => !ignoredRelPath(relPath)),
+		}))
+		.filter((entry) => entry.paths.length > 0)
+		.sort((a, b) => `${a.status} ${a.paths.join("\0")}`.localeCompare(`${b.status} ${b.paths.join("\0")}`));
+	const changedPaths = [...new Set(entries.flatMap((entry) => entry.paths))].sort();
+	const payload = entries.map((entry) => ({
+		status: entry.status,
+		paths: entry.paths,
+		content: entry.paths.map((relPath) => hashPath(root, relPath)),
+	}));
+	const key = createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+	return { root, key, changedPaths };
+}
+
+function toolNameFromMessage(message: Record<string, unknown>): string {
+	const value = message.toolName ?? message.name;
+	return typeof value === "string" ? value : "";
+}
+
+function toolResultSucceeded(message: Record<string, unknown>): boolean {
+	return message.isError !== true && message.error === undefined;
+}
+
+function messageIndicatesRepoEdit(message: unknown): boolean {
+	if (!message || typeof message !== "object") return false;
+	const input = message as Record<string, unknown>;
+	const role = input.role;
+	if (role !== "toolResult" && role !== "tool") return false;
+	const toolName = toolNameFromMessage(input);
+	return (toolName === "edit" || toolName === "write") && toolResultSucceeded(input);
+}
+
+export function eventIndicatesRepoEdit(event: unknown): boolean {
+	if (!event || typeof event !== "object") return false;
+	const input = event as Record<string, unknown>;
+	if (input.type === "turn_end" || input.event === "turn_end") {
+		return [input.message, ...(Array.isArray(input.toolResults) ? input.toolResults : [])].some(messageIndicatesRepoEdit);
+	}
+	if (input.type === "tool_result" || input.event === "tool_result") return messageIndicatesRepoEdit({ role: "toolResult", ...input });
+	if (input.type !== "tool_result_end" && input.event !== "tool_result_end") return false;
+	return messageIndicatesRepoEdit(input.message);
+}

package/src/watchdog/child-status.ts

@@ -0,0 +1,205 @@
+import type { ResolvedWatchdogConfig, WatchdogLspConfig } from "./types.ts";
+
+export const CHILD_WATCHDOG_CONFIG_ENV = "PI_SUBAGENT_WATCHDOG_CHILD_CONFIG";
+export const CHILD_WATCHDOG_STATUS_EVENT = "subagent.watchdog.status";
+
+export const CHILD_WATCHDOG_PHASES = ["idle", "reviewing", "autofollow", "settling", "stale", "failed"] as const;
+export type ChildWatchdogPhase = typeof CHILD_WATCHDOG_PHASES[number];
+
+export interface ChildWatchdogConfig {
+	enabled: boolean;
+	runId?: string;
+	agent?: string;
+	childIndex?: number;
+	watchdogTailTimeoutMs: number;
+	agentEndTimeoutMs: number;
+	maxWarnings: number | null;
+	model?: string;
+	thinking?: string | false;
+	lsp: WatchdogLspConfig;
+	autoFollowBlockers: boolean;
+	autoFollowMaxAttempts: number | null;
+	stalemateRepeats: number;
+}
+
+export interface ChildWatchdogStatusEvent {
+	type: typeof CHILD_WATCHDOG_STATUS_EVENT;
+	runId?: string;
+	agent?: string;
+	childIndex?: number;
+	stepIndex?: number;
+	seq: number;
+	phase: ChildWatchdogPhase;
+	ts: number;
+	followUpPending: boolean;
+	reason?: string;
+}
+
+export interface ChildWatchdogStateSnapshot {
+	phase: ChildWatchdogPhase;
+	seq: number;
+	lastUpdate: number;
+	followUpPending: boolean;
+	reason?: string;
+	timedOut?: boolean;
+}
+
+export function resolveChildWatchdogConfig(input: {
+	config: ResolvedWatchdogConfig;
+	agent?: string;
+	runId?: string;
+	childIndex?: number;
+}): ChildWatchdogConfig | undefined {
+	const override = input.agent ? input.config.children.overrides[input.agent] : undefined;
+	const enabled = input.config.enabled && (override?.enabled ?? input.config.children.enabled);
+	if (!enabled) return undefined;
+	const model = override?.model ?? input.config.children.model;
+	const thinking = override?.thinking ?? input.config.children.thinking;
+	return {
+		enabled: true,
+		...(input.runId ? { runId: input.runId } : {}),
+		...(input.agent ? { agent: input.agent } : {}),
+		...(input.childIndex !== undefined ? { childIndex: input.childIndex } : {}),
+		watchdogTailTimeoutMs: input.config.children.watchdogTailTimeoutMs,
+		agentEndTimeoutMs: input.config.agentEndTimeoutMs,
+		maxWarnings: input.config.maxWarnings,
+		...(model ? { model } : {}),
+		...(thinking !== undefined ? { thinking } : {}),
+		lsp: { ...input.config.lsp },
+		autoFollowBlockers: input.config.children.autoFollow.blockers,
+		autoFollowMaxAttempts: input.config.children.autoFollow.maxAttempts,
+		stalemateRepeats: input.config.children.autoFollow.stalemateRepeats,
+	};
+}
+
+export function encodeChildWatchdogConfig(config: ChildWatchdogConfig | undefined): string | undefined {
+	return config ? JSON.stringify(config) : undefined;
+}
+
+function childConfigObject(value: unknown, field: string): Record<string, unknown> {
+	if (value && typeof value === "object" && !Array.isArray(value)) return value as Record<string, unknown>;
+	throw new Error(`Invalid child watchdog config: ${field} must be an object.`);
+}
+
+function childConfigOptionalString(input: Record<string, unknown>, field: string): string | undefined {
+	if (!(field in input)) return undefined;
+	const value = input[field];
+	if (typeof value === "string" && value.trim()) return value;
+	throw new Error(`Invalid child watchdog config: ${field} must be a non-empty string.`);
+}
+
+function childConfigOptionalIndex(input: Record<string, unknown>, field: string): number | undefined {
+	if (!(field in input)) return undefined;
+	const value = input[field];
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
+	throw new Error(`Invalid child watchdog config: ${field} must be a non-negative integer.`);
+}
+
+function childConfigPositiveInteger(input: Record<string, unknown>, field: string): number {
+	const value = input[field];
+	if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
+	throw new Error(`Invalid child watchdog config: ${field} must be a positive integer.`);
+}
+
+function childConfigNullableNonNegativeInteger(input: Record<string, unknown>, field: string): number | null {
+	const value = input[field];
+	if (value === null) return null;
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
+	throw new Error(`Invalid child watchdog config: ${field} must be null or a non-negative integer.`);
+}
+
+function childConfigBoolean(input: Record<string, unknown>, field: string): boolean {
+	const value = input[field];
+	if (typeof value === "boolean") return value;
+	throw new Error(`Invalid child watchdog config: ${field} must be a boolean.`);
+}
+
+function childConfigLsp(value: unknown): WatchdogLspConfig {
+	const input = childConfigObject(value, "lsp");
+	if (typeof input.enabled !== "boolean") throw new Error("Invalid child watchdog config: lsp.enabled must be a boolean.");
+	if (typeof input.timeoutMs !== "number" || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1) {
+		throw new Error("Invalid child watchdog config: lsp.timeoutMs must be a positive integer.");
+	}
+	if (typeof input.maxFiles !== "number" || !Number.isInteger(input.maxFiles) || input.maxFiles < 1) {
+		throw new Error("Invalid child watchdog config: lsp.maxFiles must be a positive integer.");
+	}
+	if (typeof input.maxDiagnostics !== "number" || !Number.isInteger(input.maxDiagnostics) || input.maxDiagnostics < 0) {
+		throw new Error("Invalid child watchdog config: lsp.maxDiagnostics must be a non-negative integer.");
+	}
+	return {
+		enabled: input.enabled,
+		timeoutMs: input.timeoutMs,
+		maxFiles: input.maxFiles,
+		maxDiagnostics: input.maxDiagnostics,
+	};
+}
+
+export function decodeChildWatchdogConfig(raw: string | undefined): ChildWatchdogConfig | undefined {
+	if (!raw) return undefined;
+	const parsed = childConfigObject(JSON.parse(raw), "root");
+	if (parsed.enabled === false) return undefined;
+	if (parsed.enabled !== true) throw new Error("Invalid child watchdog config: enabled must be true or false.");
+	const thinking = parsed.thinking;
+	if (thinking !== undefined && typeof thinking !== "string" && thinking !== false) {
+		throw new Error("Invalid child watchdog config: thinking must be a string or false.");
+	}
+	const runId = childConfigOptionalString(parsed, "runId");
+	const agent = childConfigOptionalString(parsed, "agent");
+	const childIndex = childConfigOptionalIndex(parsed, "childIndex");
+	const model = childConfigOptionalString(parsed, "model");
+	return {
+		enabled: true,
+		...(runId ? { runId } : {}),
+		...(agent ? { agent } : {}),
+		...(childIndex !== undefined ? { childIndex } : {}),
+		watchdogTailTimeoutMs: childConfigPositiveInteger(parsed, "watchdogTailTimeoutMs"),
+		agentEndTimeoutMs: childConfigPositiveInteger(parsed, "agentEndTimeoutMs"),
+		maxWarnings: childConfigNullableNonNegativeInteger(parsed, "maxWarnings"),
+		...(model ? { model } : {}),
+		...(thinking !== undefined ? { thinking: thinking as string | false } : {}),
+		lsp: childConfigLsp(parsed.lsp),
+		autoFollowBlockers: childConfigBoolean(parsed, "autoFollowBlockers"),
+		autoFollowMaxAttempts: childConfigNullableNonNegativeInteger(parsed, "autoFollowMaxAttempts"),
+		stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats"),
+	};
+}
+
+export function isChildWatchdogStatusEvent(value: unknown): value is ChildWatchdogStatusEvent {
+	if (!value || typeof value !== "object") return false;
+	const event = value as Partial<ChildWatchdogStatusEvent>;
+	return event.type === CHILD_WATCHDOG_STATUS_EVENT
+		&& typeof event.seq === "number"
+		&& Number.isInteger(event.seq)
+		&& event.seq >= 0
+		&& typeof event.ts === "number"
+		&& Number.isFinite(event.ts)
+		&& typeof event.followUpPending === "boolean"
+		&& typeof event.phase === "string"
+		&& (CHILD_WATCHDOG_PHASES as readonly string[]).includes(event.phase);
+}
+
+export function childWatchdogIsActive(snapshot: ChildWatchdogStateSnapshot | undefined): boolean {
+	if (!snapshot) return false;
+	return snapshot.followUpPending || snapshot.phase === "reviewing" || snapshot.phase === "autofollow" || snapshot.phase === "settling";
+}
+
+export function acceptChildWatchdogEvent(input: {
+	current: ChildWatchdogStateSnapshot | undefined;
+	event: ChildWatchdogStatusEvent;
+	runId?: string;
+	agent?: string;
+	childIndex?: number;
+}): ChildWatchdogStateSnapshot | undefined {
+	if (input.runId !== undefined && input.event.runId !== input.runId) return undefined;
+	if (input.agent !== undefined && input.event.agent !== input.agent) return undefined;
+	const eventIndex = input.event.childIndex ?? input.event.stepIndex;
+	if (input.childIndex !== undefined && eventIndex !== input.childIndex) return undefined;
+	if (input.current && input.event.seq <= input.current.seq) return undefined;
+	return {
+		phase: input.event.phase,
+		seq: input.event.seq,
+		lastUpdate: input.event.ts,
+		followUpPending: input.event.followUpPending,
+		...(input.event.reason ? { reason: input.event.reason } : {}),
+	};
+}