@ferris1225/pi-subagents 4.3.9 → 4.3.10

package/src/presentation/format.ts

@@ -9,6 +9,7 @@ import { runLabel, shrinkRunLabel } from "./monitor.ts";
 import { emptyUsage } from "../execution/rpc-control.ts";
 import {
 	RESULT_LINE_MAX,
+	getResultError,
 	getResultOutput,
 	isFailedResult,
 	truncateResultOutput,
@@ -143,6 +144,7 @@ export function formatCompletionBlock(
 		const artifact = options.resultRoot
 			? writeResultArtifact(output, result.agent, options.resultRoot)
 			: "(result root unavailable)";
+		if (options.resultRoot) result.resultFile = artifact;
 		// State the real loss and condition the read: handing the parent both a
 		// summary and a full-text entrance invites the same content twice.
 		const lineLoss = shownLines < totalLines ? `${shownLines} of ${totalLines} lines shown` : `${shownLines} line${shownLines === 1 ? "" : "s"} shown`;
@@ -153,23 +155,11 @@ export function formatCompletionBlock(
 	return lines.join("\n");
 }
 
-/** Instruction appended to a model-level failure: the sub-agent's provider never
- * produced usable output (or the run stalled), so the task is handed back to the
- * main window instead of being left as a dead failure. When the run preserved a
- * session with earlier work (and the run id is known), steer the main agent to
- * RESUME it in-context once a model is available, instead of re-dispatching
- * fresh (which would re-scan everything). */
-export function modelLevelTakeoverNote(result: SingleResult, opts?: { runId?: number }): string {
+/** A terminal model failure hands the unfinished task to main, not another run. */
+export function modelLevelTakeoverNote(result: SingleResult): string {
 	const retry = result.modelFallbackFrom ? ", and the current main model also failed" : "";
-	const detail = result.errorMessage?.trim();
-	const cause = detail
-		? `its model/provider call failed (${detail})`
-		: "its model was unavailable or failed (or the run stalled)";
-	const sessionPreserved = Boolean(result.sessionDir && result.sessionId) && opts?.runId !== undefined;
-	const recovery = sessionPreserved
-		? ` The sub-agent's earlier work in this run is preserved. Once a model is available again, call subagent_control with { action: "resume", id: ${opts!.runId} } to CONTINUE it in-context (it keeps the same run id and does not re-scan), or execute the task in the main window with your own tools.`
-		: ` Please execute this task in the main window with your own tools; do not re-dispatch it as a sub-agent.`;
-	return `The sub-agent could not complete this task: ${cause}${retry}.${recovery}`;
+	const cause = getResultError(result) ?? "its model was unavailable or failed";
+	return `The sub-agent could not complete this task: ${cause}${retry}. Earlier edits and any retained result/session artifacts remain available. Main must inspect that work and finish with its own tools; do not re-dispatch this phase.`;
 }
 
 /** Resolve a run-id request to actual ids: an exact numeric match always wins

package/src/presentation/monitor.ts

@@ -20,7 +20,6 @@ import type { IsolationMode, WorktreeFinalizationStatus } from "../isolation/wor
 // ---------------------------------------------------------------------------
 
 export type RunStatus = "queued" | "running" | "interrupting" | "parked" | "done" | "failed";
-export type ContinuationKind = "resume-retained" | "resume-appended";
 
 /** Why a queued run has produced no output yet. Three genuinely different
  * situations used to be reported as one "queued": waiting for a free process
@@ -56,8 +55,6 @@ export interface RunView {
 	thinking?: string;
 	isolation?: IsolationMode;
 	integrationStatus?: RunIntegrationStatus;
-	/** Short worktree-group identity (mkdtemp suffix) shared by every run inside
-	 * one isolated worktree; changes when a continuation worktree is created. */
 	worktreeId?: string;
 	status: RunStatus;
 	/** What a queued run is actually waiting for; see RunWaitReason. */
@@ -73,15 +70,11 @@ export interface RunView {
 	elapsedMs: number;
 	/** Epoch ms when the latest active segment stopped. */
 	endedAt?: number;
-	/** Why this generation reused retained context, shown in the widget/status. */
-	continuationKind?: ContinuationKind;
 }
 
-/** Extra metadata for a run whose row must carry isolation or resume context. */
 export interface RunChainMeta {
 	isolation?: IsolationMode;
 	worktreeId?: string;
-	continuationKind?: ContinuationKind;
 	/** Initial wait reason; defaults to "process-slot" (a fresh dispatch enters
 	 * the process queue). Children spawned outside the queue pass "starting"
 	 * because they never wait for a slot. */
@@ -326,7 +319,6 @@ export function formatDuration(ms: number): string {
 	return `${hours}h${String(minutes % 60).padStart(2, "0")}m${String(seconds).padStart(2, "0")}s`;
 }
 
-/** Cumulative active time across generations; parked gaps never count. */
 export function elapsedMilliseconds(run: RunView, now: number = Date.now()): number {
 	let elapsed = run.elapsedMs ?? 0;
 	if (run.activeSince !== undefined) elapsed += Math.max(0, now - run.activeSince);
@@ -343,14 +335,6 @@ export function formatElapsed(run: RunView, now: number = Date.now()): string {
 	return formatDuration(elapsedMilliseconds(run, now));
 }
 
-export function continuationLabel(kind: ContinuationKind | undefined): string | undefined {
-	switch (kind) {
-		case "resume-retained": return "resume: current objective";
-		case "resume-appended": return "resume: appended objective";
-		default: return undefined;
-	}
-}
-
 /** Max length of the argument target inside a formatted activity line. */
 export const ACTIVITY_TARGET_MAX = 60;
 
@@ -505,7 +489,6 @@ export class MonitorStore {
 			usage: emptyUsage(),
 			elapsedMs: 0,
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined, ...(meta.worktreeId ? { worktreeId: meta.worktreeId } : {}) } : {}),
-			...(meta?.continuationKind ? { continuationKind: meta.continuationKind } : {}),
 		});
 		this.notify();
 		return id;
@@ -608,83 +591,11 @@ export class MonitorStore {
 	}
 
 
-	/** Update the objective shown for a resumed generation. */
-	setTask(id: number, task: string): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.task = task;
-		run.label = runLabel(task);
-		this.notify();
-	}
-
-	setContinuationKind(id: number, kind: ContinuationKind): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.continuationKind = kind;
-		this.notify();
-	}
-
 	getElapsedMs(id: number, now: number = Date.now()): number | undefined {
 		const run = this.find(id);
 		return run ? elapsedMilliseconds(run, now) : undefined;
 	}
 
-	/** Reuse a stable logical run id for a resumed generation without discarding
-	 * active time accumulated by earlier generations. */
-	restartRun(
-		id: number,
-		agent: string,
-		task: string,
-		model?: string,
-		thinking?: string,
-		isolation?: IsolationMode,
-		meta?: { elapsedMs?: number; continuationKind?: ContinuationKind; worktreeId?: string },
-	): void {
-		const run = this.find(id);
-		if (!run) {
-			this.runs.push({
-				id,
-				agent,
-				task,
-				label: runLabel(task),
-				model,
-				thinking,
-				...(isolation
-					? {
-						isolation,
-						integrationStatus: isolation === "worktree" ? "pending" as const : undefined,
-						...(isolation === "worktree" && meta?.worktreeId ? { worktreeId: meta.worktreeId } : {}),
-					}
-					: {}),
-				status: "queued",
-				waitReason: "process-slot",
-				usage: emptyUsage(),
-				elapsedMs: meta?.elapsedMs ?? 0,
-				continuationKind: meta?.continuationKind,
-			});
-			this.notify();
-			return;
-		}
-		run.agent = agent;
-		run.task = task;
-		run.label = runLabel(task);
-		run.model = model;
-		run.thinking = thinking;
-		if (isolation) run.isolation = isolation;
-		run.integrationStatus = isolation === "worktree" ? "pending" : undefined;
-		if (isolation === "worktree" && meta?.worktreeId) run.worktreeId = meta.worktreeId;
-		else if (isolation !== "worktree") run.worktreeId = undefined;
-		run.status = "queued";
-		run.waitReason = "process-slot";
-		run.usage = emptyUsage();
-		run.activity = undefined;
-		run.activeSince = undefined;
-		run.endedAt = undefined;
-		run.elapsedMs = Math.max(run.elapsedMs, meta?.elapsedMs ?? 0);
-		run.continuationKind = meta?.continuationKind;
-		this.notify();
-	}
-
 	/** Look up a run by id without removing it. */
 	findRun(id: number): RunView | undefined {
 		return this.find(id);
@@ -721,8 +632,6 @@ export class MonitorStore {
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
 		const parts = [run.agent];
-		const continuation = continuationLabel(run.continuationKind);
-		if (continuation) parts.push(continuation);
 		if (run.model) parts.push(run.model);
 		if (run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (run.isolation === "worktree") parts.push(`worktree ${run.integrationStatus ?? "active"}`);

package/src/presentation/widget.ts

@@ -3,8 +3,7 @@
  *
  * Layout contract:
  * - Aligned identity columns: `icon  #id  agent` pad to the widest displayed
- *   id and agent so every label starts at the same column; a resumed thread
- *   carries a dim `↻` inside the agent column.
+ *   id and agent so every label starts at the same column.
  * - A live run owns two lines. Line 1 is what it is: identity, task label,
  *   then the telemetry flow (worktree, wait state, token flow in the pi-footer
  *   vocabulary `↑in ↓out R/W cache`, cost, `provider/model`, effective
@@ -51,7 +50,7 @@ const ACTIVITY_MIN_WIDTH = 6;
 interface ColumnLayout {
 	/** Display width of the widest `#id` among rendered roots. */
 	idWidth: number;
-	/** Display width of the widest agent name (plus resume marker) among them. */
+	/** Display width of the widest agent name among rendered runs. */
 	agentWidth: number;
 }
 
@@ -80,8 +79,7 @@ export function waitWord(run: Pick<RunView, "waitReason">): string {
 
 /** Worktree-group badge shown on the row that owns the isolated worktree: the
  * short group identity plus its integration state, so a run visibly moves
- * through applying → applied (or retained) and a continuation worktree (new
- * identity) is distinguishable from the original one. */
+ * through applying → applied (or retained). */
 function worktreeBadge(run: RunView): string {
 	const id = run.worktreeId ?? "?";
 	switch (run.integrationStatus) {
@@ -105,21 +103,13 @@ function composeTail(parts: Array<string | undefined>, budget: number): string {
 	return present.join(SEPARATOR);
 }
 
-/** Marker text that shares the agent column so alignment survives resumes. */
-function agentColumnText(run: RunView): string {
-	return run.continuationKind ? `${run.agent} ↻` : run.agent;
-}
-
-/** `icon  #id  agent` in fixed columns — never truncated. The id is
- * right-aligned and the agent column is padded so every label starts at the
- * same x; a resumed thread carries a dim `↻` inside the agent column. */
+/** Fixed identity columns; labels begin at the same display column. */
 function identitySegment(run: RunView, theme: Theme, layout: ColumnLayout): string {
 	const icon = statusIcon(run.status, theme);
 	const id = `#${run.id}`.padStart(layout.idWidth);
 	const name = theme.fg("accent", theme.bold(run.agent));
-	const resumed = run.continuationKind ? ` ${theme.fg("dim", "↻")}` : "";
-	const pad = " ".repeat(Math.max(0, layout.agentWidth - visibleWidth(agentColumnText(run))));
-	return `${icon} ${theme.fg("dim", id)} ${name}${resumed}${pad}`;
+	const pad = " ".repeat(Math.max(0, layout.agentWidth - visibleWidth(run.agent)));
+	return `${icon} ${theme.fg("dim", id)} ${name}${pad}`;
 }
 
 /** One footer-style usage part: token flow plus accrued cost, dropped as a
@@ -198,7 +188,7 @@ export function formatActiveRunLines(
 	const active = runs.filter((run) => isRunActiveStatus(run.status));
 	const layout: ColumnLayout = {
 		idWidth: Math.max(...active.map((run) => visibleWidth(`#${run.id}`)), 0),
-		agentWidth: Math.max(...active.map((run) => visibleWidth(agentColumnText(run))), 0),
+		agentWidth: Math.max(...active.map((run) => visibleWidth(run.agent)), 0),
 	};
 	const lines: string[] = [];
 	let shown = 0;

package/src/execution/session-fork.ts

@@ -1,86 +0,0 @@
-/** Pi SessionManager-backed cloning of a retained sub-agent session branch. */
-
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { existsSync } from "node:fs";
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { writeTempOwnerMarker } from "../isolation/temp-hygiene.ts";
-
-export interface ForkedSession {
-	sessionDir: string;
-	sessionId: string;
-	sessionFile: string;
-}
-
-/** Locate one retained session by its authoritative header id. */
-export async function findRetainedSessionFile(
-	sessionDir: string,
-	sessionId: string,
-): Promise<string> {
-	// The retained header may point at a worktree that has since been removed.
-	// The session id is authoritative inside this explicit private directory;
-	// listing the directory directly avoids a stale-cwd filter rejecting it.
-	const sessions = await SessionManager.listAll(sessionDir);
-	const matches = sessions.filter((session) => session.id === sessionId);
-	if (matches.length === 0) {
-		throw new Error(`Retained session ${sessionId} was not found in ${sessionDir}.`);
-	}
-	if (matches.length > 1) {
-		throw new Error(`Retained session id ${sessionId} is ambiguous in ${sessionDir}.`);
-	}
-	return matches[0].path;
-}
-
-/**
- * Copy only the source file's active branch into a new isolated temp session
- * directory. SessionManager performs all JSONL/tree handling; source state is
- * never mutated.
- */
-export async function forkRetainedSession(options: {
-	/** Cwd stored in the source session header (used for exact lookup). */
-	cwd: string;
-	/** Optional cwd for the cloned session header and future child tools. */
-	targetCwd?: string;
-	sessionDir: string;
-	sessionId: string;
-	/** Parent directory for the cloned branch: the project-scoped durable
-	 * sessions root, so forks never land in the OS temp directory. */
-	targetRoot: string;
-}): Promise<ForkedSession> {
-	const sourceSessionFile = await findRetainedSessionFile(
-		options.sessionDir,
-		options.sessionId,
-	);
-	const root = options.targetRoot;
-	await mkdir(root, { recursive: true });
-	const sessionDir = await mkdtemp(join(root, "pi-subagent-session-fork-"));
-	writeTempOwnerMarker(sessionDir);
-	try {
-		// Supplying the new directory makes createBranchedSession write there.
-		// cwdOverride rewrites the cloned header so a settled isolated session can
-		// safely continue in its fresh worktree instead of a removed old path.
-		const manager = SessionManager.open(
-			sourceSessionFile,
-			sessionDir,
-			options.targetCwd ?? options.cwd,
-		);
-		const leafId = manager.getLeafId();
-		if (!leafId) throw new Error(`Retained session ${options.sessionId} has no active branch to fork.`);
-		const sessionFile = manager.createBranchedSession(leafId);
-		if (!sessionFile) throw new Error("Pi SessionManager did not create a persistent fork.");
-		// Pi defers branch files that contain no assistant response. Such a file
-		// cannot be resumed by RPC without creating a blank session, so reject
-		// rather than pretending context was preserved.
-		if (!existsSync(sessionFile)) {
-			throw new Error(`Forked session branch has no persisted assistant checkpoint at ${sessionFile}.`);
-		}
-		return {
-			sessionDir,
-			sessionId: manager.getSessionId(),
-			sessionFile,
-		};
-	} catch (error) {
-		await rm(sessionDir, { recursive: true, force: true }).catch(() => undefined);
-		throw error;
-	}
-}