pi-subagents 0.23.1 → 0.24.1

package/src/runs/background/async-status.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.ts";
-import { type ActivityState, type AsyncParallelGroupStatus, type AsyncStatus, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
+import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.ts";
+import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
@@ -9,7 +10,7 @@ import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
 interface AsyncRunStepSummary {
 	index: number;
 	agent: string;
-	status: string;
+	status: AsyncJobStep["status"];
 	activityState?: ActivityState;
 	lastActivityAt?: number;
 	currentTool?: string;
@@ -65,16 +66,6 @@ interface AsyncRunListOptions {
 	reconcile?: boolean;
 }
 
-export interface AsyncRunOverlayData {
-	active: AsyncRunSummary[];
-	recent: AsyncRunSummary[];
-}
-
-export interface AsyncRunOverlayOptions {
-	recentLimit?: number;
-	sessionId?: string;
-}
-
 function getErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -185,9 +176,9 @@ function sortRuns(runs: AsyncRunSummary[]): AsyncRunSummary[] {
 		switch (state) {
 			case "running": return 0;
 			case "queued": return 1;
-		case "failed": return 2;
-		case "paused": return 2;
-		case "complete": return 3;
+			case "failed": return 2;
+			case "paused": return 2;
+			case "complete": return 3;
 		}
 	};
 	return [...runs].sort((a, b) => {
@@ -229,35 +220,15 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
 }
 
-export function listAsyncRunsForOverlay(asyncDirRoot: string, options: AsyncRunOverlayOptions = {}): AsyncRunOverlayData {
-	const recentLimit = options.recentLimit ?? 5;
-	const all = listAsyncRuns(asyncDirRoot, { sessionId: options.sessionId });
-	const recent = all
-		.filter((run) => run.state === "complete" || run.state === "failed" || run.state === "paused")
-		.sort((a, b) => (b.lastUpdate ?? b.endedAt ?? b.startedAt) - (a.lastUpdate ?? a.endedAt ?? a.startedAt))
-		.slice(0, recentLimit);
-	return {
-		active: all.filter((run) => run.state === "queued" || run.state === "running"),
-		recent,
-	};
-}
-
 function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number; currentPath?: string; turnCount?: number; toolCount?: number }): string | undefined {
 	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt) facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
+	if (input.currentTool && input.currentToolStartedAt !== undefined) facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
 	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
 	if (input.currentPath) facts.push(shortenPath(input.currentPath));
 	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
 	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	if (!input.lastActivityAt) {
-		if (input.activityState === "needs_attention") return ["needs attention", ...facts].join(" | ");
-		if (input.activityState === "active_long_running") return ["active but long-running", ...facts].join(" | ");
-		return facts.length ? facts.join(" | ") : undefined;
-	}
-	const elapsed = formatDuration(Math.max(0, Date.now() - input.lastActivityAt));
-	if (input.activityState === "needs_attention") return [`no activity for ${elapsed}`, ...facts].join(" | ");
-	if (input.activityState === "active_long_running") return [`active but long-running; last activity ${elapsed} ago`, ...facts].join(" | ");
-	return [`active ${elapsed} ago`, ...facts].join(" | ");
+	const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
+	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
 }
 
 function formatStepLine(step: AsyncRunStepSummary): string {
@@ -270,16 +241,9 @@ function formatStepLine(step: AsyncRunStepSummary): string {
 	return parts.join(" | ");
 }
 
-function formatParallelProgress(steps: Pick<AsyncRunStepSummary, "status">[], total: number, showRunning: boolean): string {
-	const running = steps.filter((step) => step.status === "running").length;
-	const done = steps.filter((step) => step.status === "complete" || step.status === "completed").length;
-	const failed = steps.filter((step) => step.status === "failed").length;
-	const paused = steps.filter((step) => step.status === "paused").length;
-	const parts = [`${done}/${total} done`];
-	if (showRunning && running > 0) parts.unshift(running === 1 ? "1 agent running" : `${running} agents running`);
-	if (failed > 0) parts.push(`${failed} failed`);
-	if (paused > 0) parts.push(`${paused} paused`);
-	return parts.join(" · ");
+export function formatAsyncRunOutputPath(run: Pick<AsyncRunSummary, "asyncDir" | "outputFile">): string | undefined {
+	if (!run.outputFile) return undefined;
+	return path.isAbsolute(run.outputFile) ? run.outputFile : path.join(run.asyncDir, run.outputFile);
 }
 
 export function formatAsyncRunProgressLabel(run: Pick<AsyncRunSummary, "mode" | "state" | "currentStep" | "chainStepCount" | "parallelGroups" | "steps">): string {
@@ -291,11 +255,11 @@ export function formatAsyncRunProgressLabel(run: Pick<AsyncRunSummary, "mode" |
 		: undefined;
 	if (activeGroup) {
 		const groupSteps = run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count);
-		const groupLabel = formatParallelProgress(groupSteps, activeGroup.count, run.state === "running");
+		const groupLabel = formatParallelOutcome(groupSteps, activeGroup.count, { showRunning: run.state === "running" });
 		if (run.mode === "parallel") return groupLabel;
 		return `step ${activeGroup.stepIndex + 1}/${chainStepCount} · parallel group: ${groupLabel}`;
 	}
-	if (run.mode === "parallel") return formatParallelProgress(run.steps, stepCount, run.state === "running");
+	if (run.mode === "parallel") return formatParallelOutcome(run.steps, stepCount, { showRunning: run.state === "running" });
 	if (run.mode === "chain" && run.currentStep !== undefined && groups.length > 0) {
 		const logicalStep = flatToLogicalStepIndex(run.currentStep, chainStepCount, groups);
 		return `step ${logicalStep + 1}/${chainStepCount}`;
@@ -319,6 +283,8 @@ export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active as
 		for (const step of run.steps) {
 			lines.push(`  ${formatStepLine(step)}`);
 		}
+		const outputPath = formatAsyncRunOutputPath(run);
+		if (outputPath) lines.push(`  output: ${shortenPath(outputPath)}`);
 		if (run.sessionFile) lines.push(`  session: ${shortenPath(run.sessionFile)}`);
 		lines.push("");
 	}

package/src/runs/background/notify.ts

@@ -2,7 +2,7 @@
  * Subagent completion notifications.
  */
 
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
 

package/src/runs/background/result-watcher.ts

@@ -87,7 +87,7 @@ export function createResultWatcher(
 				intercomTarget?: string;
 			};
 			if (data.sessionId && data.sessionId !== state.currentSessionId) return;
-			if (!data.sessionId && data.cwd && data.cwd !== state.baseCwd) return;
+			if (!data.sessionId && data.cwd && (!state.baseCwd || data.cwd !== state.baseCwd)) return;
 
 			const now = Date.now();
 			const completionKey = buildCompletionKey(data, `result:${file}`);

package/src/runs/background/run-status.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import { formatAsyncRunList, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.ts";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.ts";
+import { formatActivityLabel } from "../../shared/status-format.ts";
 import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details } from "../../shared/types.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { resolveAsyncRunLocation } from "./async-resume.ts";
@@ -22,12 +23,6 @@ interface RunStatusDeps {
 	now?: () => number;
 }
 
-function activityText(activityState: unknown, lastActivityAt: unknown): string | undefined {
-	if (typeof lastActivityAt !== "number") return undefined;
-	const seconds = Math.floor(Math.max(0, Date.now() - lastActivityAt) / 1000);
-	return activityState === "needs_attention" ? `no activity for ${seconds}s` : `active ${seconds}s ago`;
-}
-
 function hasExistingSessionFile(value: unknown): value is string {
 	return typeof value === "string" && fs.existsSync(value);
 }
@@ -119,6 +114,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		const logPath = path.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
 		const eventsPath = path.join(asyncDir, "events.jsonl");
 		if (status) {
+			const outputPath = formatAsyncRunOutputPath({ asyncDir, outputFile: status.outputFile });
 			const progressLabel = formatAsyncRunProgressLabel({
 				mode: status.mode,
 				state: status.state,
@@ -129,7 +125,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			});
 			const started = new Date(status.startedAt).toISOString();
 			const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
-			const statusActivityText = status.state === "running" ? activityText(status.activityState, status.lastActivityAt) : undefined;
+			const statusActivityText = status.state === "running" ? formatActivityLabel(status.lastActivityAt, status.activityState) : undefined;
 
 			const lines = [
 				`Run: ${status.runId}`,
@@ -140,13 +136,16 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				`Started: ${started}`,
 				`Updated: ${updated}`,
 				`Dir: ${asyncDir}`,
+				outputPath ? `Output: ${outputPath}` : undefined,
 				reconciliation.message ? `Diagnosis: ${reconciliation.message}` : undefined,
 				reconciliation.resultPath && fs.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : undefined,
 			].filter((line): line is string => Boolean(line));
 			for (const [index, step] of (status.steps ?? []).entries()) {
-				const stepActivityText = step.status === "running" ? activityText(step.activityState, step.lastActivityAt) : undefined;
+				const stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
 				const errorText = step.error ? `, error: ${step.error}` : "";
 				lines.push(`${stepLineLabel(status, index)}: ${step.agent} ${step.status}${stepActivityText ? `, ${stepActivityText}` : ""}${errorText}`);
+				const stepOutputPath = path.join(asyncDir, `output-${index}.log`);
+				if (stepOutputPath !== outputPath && fs.existsSync(stepOutputPath)) lines.push(`  Output: ${stepOutputPath}`);
 				if (step.status === "running") {
 					lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.agent, index)} (if registered)`);
 				}

package/src/runs/background/subagent-runner.ts

@@ -1,12 +1,11 @@
 import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
-import { createRequire } from "node:module";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
-import type { Message } from "@mariozechner/pi-ai";
+import type { Message } from "@earendil-works/pi-ai";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
 import { appendJsonl, getArtifactPaths } from "../../shared/artifacts.ts";
-import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
+import { PI_CODING_AGENT_PACKAGE, getPiSpawnCommand, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.ts";
 import { captureSingleOutputSnapshot, finalizeSingleOutput, formatSavedOutputReference, resolveSingleOutput, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
 	type ActivityState,
@@ -109,7 +108,6 @@ interface StepResult {
 	truncated?: boolean;
 }
 
-const require = createRequire(import.meta.url);
 const ASYNC_INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
 
 function findLatestSessionFile(sessionDir: string): string | null {
@@ -424,21 +422,9 @@ function runPiStreaming(
 }
 
 function resolvePiPackageRootFallback(): string {
-	// Try to resolve the main entry point and walk up to find the package root
-	const entryPoint = require.resolve("@mariozechner/pi-coding-agent");
-	// Entry point is typically /path/to/dist/index.js, so go up to find package root
-	let dir = path.dirname(entryPoint);
-	while (dir !== path.dirname(dir)) {
-		const pkgJsonPath = path.join(dir, "package.json");
-		try {
-			const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
-			if (pkg.name === "@mariozechner/pi-coding-agent") return dir;
-		} catch {
-			// Keep walking up until a readable package.json is found.
-		}
-		dir = path.dirname(dir);
-	}
-	throw new Error("Could not resolve @mariozechner/pi-coding-agent package root");
+	const root = resolveInstalledPiPackageRoot();
+	if (root) return root;
+	throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
 }
 
 async function exportSessionHtml(sessionFile: string, outputDir: string, piPackageRoot?: string): Promise<string> {